text stringlengths 14 6.51M |
|---|
{ }
{ XML Components v3.00 }
{ }
{ This unit is copyright © 2004 by David J Butler }
{ }
{ This unit is part of Delphi Fundamentals. }
{ Its original file name is cXMLComponents.pas }
{ The latest version is available from the Fundamentals home page }
{ http://fundementals.sourceforge.net/ }
{ }
{ I invite you to use this unit, free of charge. }
{ I invite you to distibute this unit, but it must be for free. }
{ I also invite you to contribute to its development, }
{ but do not distribute a modified copy of this file. }
{ }
{ A forum is available on SourceForge for general discussion }
{ http://sourceforge.net/forum/forum.php?forum_id=2117 }
{ }
{ }
{ Revision history: }
{ 01/04/2004 3.00 Initial version. }
{ }
{$INCLUDE ..\cDefines.inc}
unit cXMLComponents;
interface
uses
{ Delphi }
Classes,
{ XML }
cXMLDocument,
cXMLParser;
{ }
{ TXMLParserComponent }
{ }
type
TXMLParserComponent = class;
TXMLParserComponentObjectEvent = procedure (Sender: TXMLParserComponent;
Obj: AxmlType) of object;
TXMLParserComponent = class(TComponent)
private
FText : String;
FFileName : String;
FEncoding : String;
FOnTag : TXMLParserComponentObjectEvent;
FOnElement : TXMLParserComponentObjectEvent;
FOnPI : TXMLParserComponentObjectEvent;
FOnComment : TXMLParserComponentObjectEvent;
FOnDocument : TXMLParserComponentObjectEvent;
FParser : TxmlParser;
FDocument : TxmlDocument;
procedure OnParserTag(Sender: TxmlParser; Obj: AxmlType);
procedure OnParserElement(Sender: TxmlParser; Obj: AxmlType);
procedure OnParserPI(Sender: TxmlParser; Obj: AxmlType);
procedure OnParserComment(Sender: TxmlParser; Obj: AxmlType);
public
destructor Destroy; override;
property Text: String read FText write FText;
property FileName: String read FFileName write FFileName;
property Encoding: String read FEncoding write FEncoding;
property OnTag: TXMLParserComponentObjectEvent read FOnTag write FOnTag;
property OnElement: TXMLParserComponentObjectEvent read FOnElement write FOnElement;
property OnPI: TXMLParserComponentObjectEvent read FOnPI write FOnPI;
property OnComment: TXMLParserComponentObjectEvent read FOnComment write FOnComment;
property OnDocument: TXMLParserComponentObjectEvent read FOnDocument write FOnDocument;
function Parse: TxmlDocument;
property Document: TxmlDocument read FDocument;
function ReleaseDocument: TxmlDocument;
end;
TfndXMLParser = class(TXMLParserComponent)
published
property Text;
property FileName;
property Encoding;
property OnTag;
property OnElement;
property OnPI;
property OnComment;
property OnDocument;
end;
{ }
{ Component Register }
{ }
procedure Register;
implementation
uses
{ Delphi }
SysUtils;
{ }
{ TXMLParserComponent }
{ }
destructor TXMLParserComponent.Destroy;
begin
FreeAndNil(FDocument);
FreeAndNil(FParser);
inherited Destroy;
end;
procedure TXMLParserComponent.OnParserTag(Sender: TxmlParser; Obj: AxmlType);
begin
if Assigned(FOnTag) then
FOnTag(self, Obj);
end;
procedure TXMLParserComponent.OnParserElement(Sender: TxmlParser; Obj: AxmlType);
begin
if Assigned(FOnElement) then
FOnElement(self, Obj);
end;
procedure TXMLParserComponent.OnParserPI(Sender: TxmlParser; Obj: AxmlType);
begin
if Assigned(FOnPI) then
FOnPI(self, Obj);
end;
procedure TXMLParserComponent.OnParserComment(Sender: TxmlParser; Obj: AxmlType);
begin
if Assigned(FOnComment) then
FOnComment(self, Obj);
end;
function TXMLParserComponent.Parse: TxmlDocument;
begin
if not Assigned(FParser) then
begin
FParser := TxmlParser.Create;
FParser.Options := [];
FParser.OnTag := OnParserTag;
FParser.OnElement := OnParserElement;
FParser.OnPI := OnParserPI;
FParser.OnComment := OnParserComment;
end;
FParser.Encoding := FEncoding;
if FFileName <> '' then
FParser.SetFileName(FFileName) else
if FText <> '' then
FParser.SetString(FText)
else
raise ExmlParser.Create('No XML text');
FreeAndNil(FDocument);
FDocument := FParser.ExtractDocument;
if Assigned(FOnDocument) then
FOnDocument(self, FDocument);
Result := FDocument;
end;
function TXMLParserComponent.ReleaseDocument: TxmlDocument;
begin
Result := FDocument;
FDocument := nil;
end;
{ }
{ Component Register }
{ }
procedure Register;
begin
RegisterComponents('Fundamentals', [TfndXMLParser]);
end;
end.
|
unit Main;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
SMLang, StdCtrls, Menus, ComCtrls, ToolWin;
type
TfrmMain = class(TForm)
tbMain: TToolBar;
ImageList1: TImageList;
ToolButton1: TToolButton;
ToolButton2: TToolButton;
ToolButton3: TToolButton;
ToolButton4: TToolButton;
ToolButton5: TToolButton;
ToolButton6: TToolButton;
ToolButton7: TToolButton;
MainMenu1: TMainMenu;
File1: TMenuItem;
Edit1: TMenuItem;
Help1: TMenuItem;
New1: TMenuItem;
Open1: TMenuItem;
Save1: TMenuItem;
N1: TMenuItem;
Exit1: TMenuItem;
Copy1: TMenuItem;
Cut1: TMenuItem;
Paste1: TMenuItem;
About1: TMenuItem;
btnClick: TButton;
SMLanguage1: TSMLanguage;
rbEnglish: TRadioButton;
rbGerman: TRadioButton;
rbFrench: TRadioButton;
rbRussian: TRadioButton;
lblURL: TLabel;
procedure rbEnglishClick(Sender: TObject);
procedure btnClickClick(Sender: TObject);
procedure Exit1Click(Sender: TObject);
procedure lblURLClick(Sender: TObject);
private
{ Private declarations }
strMessageText: string;
public
{ Public declarations }
end;
var
frmMain: TfrmMain;
implementation
{$R *.DFM}
uses ShellAPI;
procedure TfrmMain.rbEnglishClick(Sender: TObject);
begin
if (Sender = rbEnglish) then
SMLanguage1.ResourceFile := 'english.lng'
else
if (Sender = rbGerman) then
SMLanguage1.ResourceFile := 'german.lng'
else
if (Sender = rbFrench) then
SMLanguage1.ResourceFile := 'french.lng'
else
if (Sender = rbRussian) then
SMLanguage1.ResourceFile := 'russian.lng';
SMLanguage1.ResourceFile := ExtractFilePath(Application.ExeName) + SMLanguage1.ResourceFile;
SMLanguage1.LoadResources(SMLanguage1.ResourceFile);
strMessageText := SMLanguage1.TranslateUserMessage('MessageText', 'You clicked on button');
end;
procedure TfrmMain.btnClickClick(Sender: TObject);
begin
ShowMessage(strMessageText);
end;
procedure TfrmMain.Exit1Click(Sender: TObject);
begin
Close
end;
procedure TfrmMain.lblURLClick(Sender: TObject);
begin
ShellExecute(0, 'open', PChar(lblURL.Caption), nil, nil, SW_SHOWNORMAL);
end;
end.
|
{***********************************<_INFO>************************************}
{ <Проект> Библиотека медиа-обработки }
{ }
{ <Область> 16:Медиа-контроль }
{ }
{ <Задача> Декодер для видео-вывода, формат H264 }
{ }
{ <Автор> Фадеев Р.В. }
{ }
{ <Дата> 14.01.2011 }
{ }
{ <Примечание> Нет примечаний. }
{ }
{ <Атрибуты> ООО НПП "Спецстрой-Связь", ООО "Трисофт" }
{ }
{***********************************</_INFO>***********************************}
unit Player.VideoOutput.H264;
interface
uses Windows,SysUtils,Classes, Player.VideoOutput.Base,MediaProcessing.Definitions,
Avc,Avc.avcodec, H264Def;
type
TVideoOutputDecoder_H264 = class (TVideoOutputDecoder)
private
FTempBuffer : TBytes;
FDecodedBufferSize: integer;
FVideoDecoder: IVideoDecoder;
FLastErrorCode: FFMPEG_RESULT;
procedure RecreateDecoder;
protected
procedure OnUseHardwareAccelerationChanged; override;
function DoDecodeData(const aFormat: TMediaStreamDataHeader; aData: pointer; aDataSize: cardinal; aInfo: pointer; aInfoSize: cardinal):TVideoOutputDecoderDecodeResult; override;
public
class function SupportedStreamTypes: TArray<TStreamType>; override;
procedure CopyDecoderImageToSurface(aSurface: TSurface); override;
function IsDataValid(const aFormat: TMediaStreamDataHeader; aData: pointer; aDataSize: cardinal; aInfo: pointer; aInfoSize: cardinal):boolean; override;
function GetCurrentDecodedBuffer(out aFormat: TMediaStreamDataHeader;
out aData: pointer; out aDataSize: cardinal;
out aInfo: pointer; out aInfoSize: cardinal): TVideoOutputDecoderCurrentDecodedBufferAccess; override;
constructor Create; override;
destructor Destroy; override;
function StatusInfo: string; override;
end;
implementation
uses Math, uTrace;
procedure AvcTraceCallback(aType: cardinal; aLevel: cardinal; aMessage: PAnsiChar); stdcall;
begin
TraceLine('AVC',Format('Type=%d; Level=%d; Message=%s',[aType,aLevel,aMessage]));
end;
//{$DEFINE TRACE_PROCESSING}
{ TVideoOutputDecoder_H264 }
constructor TVideoOutputDecoder_H264.Create;
begin
inherited Create;
RegisterCustomTrace(ClassName,'','.vo.h264');
RecreateDecoder;
end;
destructor TVideoOutputDecoder_H264.Destroy;
begin
inherited;
FVideoDecoder:=nil;
end;
function TVideoOutputDecoder_H264.GetCurrentDecodedBuffer(
out aFormat: TMediaStreamDataHeader; out aData: pointer;
out aDataSize: cardinal;
out aInfo: pointer; out aInfoSize: cardinal): TVideoOutputDecoderCurrentDecodedBufferAccess;
begin
aFormat.Clear;
aFormat.biMediaType:=mtVideo;
aFormat.biStreamType:=stRGB;
aFormat.VideoWidth:=ImageWidth;
aFormat.VideoHeight:=ImageHeight;
aFormat.VideoBitCount:=24;
aData:=FTempBuffer;
aDataSize:=FDecodedBufferSize;
aInfo:=nil;
aInfoSize:=0;
result:=dbaOK;
end;
function TVideoOutputDecoder_H264.IsDataValid(
const aFormat: TMediaStreamDataHeader; aData: pointer; aDataSize: cardinal;
aInfo: pointer; aInfoSize: cardinal): boolean;
begin
result:=inherited IsDataValid(aFormat,aData,aDataSize,aInfo,aInfoSize);
(*
if result then
begin
result:=(aDataSize>4) and (PDword(aData)^=$1000000); //NAL_START_MARKER
if result then
begin
result:=(PByte(aData)+4)^ shr 7=0;
end;
end;
*)
end;
procedure TVideoOutputDecoder_H264.OnUseHardwareAccelerationChanged;
begin
inherited;
RecreateDecoder;
end;
procedure TVideoOutputDecoder_H264.RecreateDecoder;
begin
FVideoDecoder:=nil;
AvcCheck(CreateVideoDecoder(AV_CODEC_ID_H264, FVideoDecoder));
Assert(FVideoDecoder<>nil);
end;
function TVideoOutputDecoder_H264.StatusInfo: string;
var
aDecoderInfo: string;
begin
result:=inherited StatusInfo;
if FVideoDecoder<>nil then
begin
SetLength(aDecoderInfo,255);
FVideoDecoder.GetDecoderInfo(PChar(aDecoderInfo),Length(aDecoderInfo));
result:=result+' DecoderInfo: '+PChar(aDecoderInfo)+#13#10;
end;
end;
class function TVideoOutputDecoder_H264.SupportedStreamTypes: TArray<TStreamType>;
begin
SetLength(result,1);
result[0]:=stH264;
end;
function TVideoOutputDecoder_H264.DoDecodeData(const aFormat: TMediaStreamDataHeader; aData: pointer; aDataSize: cardinal; aInfo: pointer; aInfoSize: cardinal):TVideoOutputDecoderDecodeResult;
var
aNeedSize: integer;
aParams: IVideoDecoderParams;
aNalType: TNalUnitType;
{$IFDEF TRACE_PROCESSING}
s: AnsiString;
i: Integer;
{$ENDIF}
begin
Assert(aData<>nil);
Assert(aFormat.biMediaType=mtVideo);
result:=drError;
if (aDataSize<4) then
begin
SetLastError('Размер фрейма меньше 4 байт');
exit;
end;
(*
if PInteger(aData)^<>$1000000 then
begin
SetLastError('Отсутствует лидирующий флаг (0x1000000). Возможно, это не H.264');
exit;
end;
*)
if ((cardinal(aFormat.VideoWidth)<>ImageWidth) or (cardinal(aFormat.VideoHeight)<>ImageHeight)) then
begin
AvcCheck(FVideoDecoder.GetParams(aParams));
aParams.SetWidth(aFormat.VideoWidth);
aParams.SetHeight(aFormat.VideoHeight);
if aInfo<>nil then
aParams.SetExtraData(aInfo,aInfoSize);
aParams:=nil;
try
AvcCheck(FVideoDecoder.Open(UseHardwareAcceleration));
SetImageSize(aFormat.VideoWidth,aFormat.VideoHeight);
except
on E:Exception do
begin
SetLastError(E.Message);
end;
end;
end;
//Assert(aFormat.VideoBitCount=24);
aNeedSize:=aFormat.VideoWidth*aFormat.VideoHeight*3;
if Length(FTempBuffer)<aNeedSize then
SetLength(FTempBuffer,aNeedSize);
FLastErrorCode:=FVideoDecoder.DecodeRGB24(aData,aDataSize, @FTempBuffer[0], aNeedSize, FDecodedBufferSize);
if (FLastErrorCode=FR_DECODING_FAIL) and (ffKeyFrame in aFormat.biFrameFlags) then
FLastErrorCode:=FVideoDecoder.DecodeRGB24(aData,aDataSize, @FTempBuffer[0], aNeedSize, FDecodedBufferSize);
aNalType:=GetNalType(aData);
{$IFDEF TRACE_PROCESSING}
s:='';
for i := 0 to Min(16,aDataSize) do
s:=s+IntToHex(PByte(aData)[i],1);
TraceLine(self.ClassName,Format('NalType=%d(%s); Result=%d; TimeStamp=%d; Prebuffer=%d; Size=%d; Bytes=$%s',[integer(aNalType),NalTypeToString(aNalType),FLastErrorCode,aFormat.TimeStamp,integer(ffPrebuffer in aFormat.biFrameFlags),aDataSize,s]));
{$ENDIF}
if FLastErrorCode=FR_SUCCESSFUL then
begin
if (FDecodedBufferSize>aNeedSize) then
SetLastError('Decoded Buffer Size>Need Size')
//do nothing, it's error
else if (FDecodedBufferSize<>0) then
result:=drSuccess;
end
else if (aNalType in [NAL_UT_SEQ_PARAM,NAL_UT_PIC_PARAM]) then
begin
result:=drWait;
end
else
SetLastError('Декодер сообщил: '+GetErrorMessage(FLastErrorCode)+' [NAL='+IntToStr(integer(aNalType))+']');
end;
procedure TVideoOutputDecoder_H264.CopyDecoderImageToSurface(aSurface: TSurface);
begin
//FIX проверяем, чтобы декодированный буфер был НЕ больше рассчетного
//Раньше было строгое равенство, но была ситуация, когда декодер обрабатывал только часть изображения
//Из-за сложного формата H264 рассчитать правильно размеры картинки представляется сложным, поэтому идем на уступки
Assert(cardinal(FDecodedBufferSize)<=ImageWidth*ImageHeight*3);
aSurface.DrawRGB24(@FTempBuffer[0],ImageWidth*ImageHeight*3);
end;
initialization
PlayerVideoOutputDecoderFactory.RegisterDecoderClass(TVideoOutputDecoder_H264);
end.
|
unit IdRawHeaders;
interface
uses
IdStack;
// TODO: research subtypes of ICMP header
type
// types redeclared to avoid dependencies on stack declarations
{
TIdSunB = packed record
s_b1, s_b2, s_b3, s_b4: byte;
end;
TIdSunW = packed record
s_w1, s_w2: word;
end;
PIdInAddr = ^TIdInAddr;
TIdInAddr = record
case integer of
0: (S_un_b: TIdSunB);
1: (S_un_w: TIdSunW);
2: (S_addr: longword);
end;
}
TIdNetTime = longword; // network byte order
const
// header sizes
Id_ARP_HSIZE = $1C; // ARP header: 28 bytes
Id_DNS_HSIZE = $0C; // DNS header base: 12 bytes
Id_ETH_HSIZE = $0E; // Etherner header: 14 bytes
Id_ICMP_HSIZE = $04; // ICMP header base: 4 bytes
Id_ICMP_ECHO_HSIZE = $08; // ICMP_ECHO header: 8 bytes
Id_ICMP_MASK_HSIZE = $0C; // ICMP_MASK header: 12 bytes
Id_ICMP_UNREACH_HSIZE = $08; // ICMP_UNREACH header: 8 bytes
Id_ICMP_TIMEXCEED_HSIZE = $08; // ICMP_TIMXCEED header: 8 bytes
Id_ICMP_REDIRECT_HSIZE = $08; // ICMP_REDIRECT header: 8 bytes
Id_ICMP_TS_HSIZE = $14; // ICMP_TIMESTAMP header: 20 bytes
Id_IGMP_HSIZE = $08; // IGMP header: 8 bytes
Id_IP_HSIZE = $14; // IP header: 20 bytes
Id_RIP_HSIZE = $18; // RIP header base: 24 bytes
Id_TCP_HSIZE = $14; // TCP header: 20 bytes
Id_UDP_HSIZE = $08; // UDP header: 8 bytes
const
Id_MAX_IPOPTLEN = 40;
const
// fragment flags
Id_IP_RF = $8000; // reserved fragment flag
Id_IP_DF = $4000; // dont fragment flag
Id_IP_MF = $2000; // more fragments flag
Id_IP_OFFMASK = $1FFF; // mask for fragmenting bits
type
// IP options structure
TIdIpOptions = packed record
{$IFDEF LINUX}
//ipopt_dst: TIdInAddr; // first-hop dst if source routed (Linux only)
{$ENDIF}
ipopt_list: array [0..Id_MAX_IPOPTLEN-1] of char; // options proper
end;
// IP packet header
PIdIpHdr = ^TIdIpHdr;
TIdIpHdr = packed record
ip_verlen: byte; // 1st nibble version, 2nd nibble header length div 4 (little-endian)
ip_tos: byte; // type of service
ip_len: word; // total length
ip_id: word; // identification
ip_off: word; // 1st nibble flags, next 3 nibbles fragment offset (little-endian)
ip_ttl: byte; // time to live
ip_p: byte; // protocol
ip_sum: word; // checksum
ip_src: TIdInAddr; // source address
ip_dst: TIdInAddr; // dest address
ip_options: longword; // options + padding
end;
const
Id_IP_MAXPACKET = 65535;
const
// control flags
Id_TCP_FIN = $01;
Id_TCP_SYN = $02;
Id_TCP_RST = $04;
Id_TCP_PUSH = $08;
Id_TCP_ACK = $10;
Id_TCP_URG = $20;
type
// TCP options structure
TIdTcpOptions = packed record
tcpopt_list: array [0..Id_MAX_IPOPTLEN-1] of byte;
end;
// TCP packet header
PIdTcpHdr = ^TIdTcpHdr;
TIdTcpHdr = packed record
tcp_sport: word; // source port
tcp_dport: word; // destination port
tcp_seq: longword; // sequence number
tcp_ack: longword; // acknowledgement number
tcp_x2off: byte; // data offset
tcp_flags: byte; // control flags
tcp_win: word; // window
tcp_sum: word; // checksum
tcp_urp: word; // urgent pointer
end;
// UDP packet header
PIdUdpHdr = ^TIdUdpHdr;
TIdUdpHdr = packed record
udp_sport: word; // source port
udp_dport: word; // destination port
udp_ulen: word; // length
udp_sum: word; // checksum
end;
const
// ICMP types
Id_ICMP_ECHOREPLY = 0;
Id_ICMP_UNREACH = 3;
Id_ICMP_SOURCEQUENCH = 4;
Id_ICMP_REDIRECT = 5;
Id_ICMP_ECHO = 8;
Id_ICMP_ROUTERADVERT = 9;
Id_ICMP_ROUTERSOLICIT = 10;
Id_ICMP_TIMXCEED = 11;
Id_ICMP_PARAMPROB = 12;
Id_ICMP_TSTAMP = 13;
Id_ICMP_TSTAMPREPLY = 14;
Id_ICMP_IREQ = 15;
Id_ICMP_IREQREPLY = 16;
Id_ICMP_MASKREQ = 17;
Id_ICMP_MASKREPLY = 18;
// ICMP codes
Id_ICMP_UNREACH_NET = 0;
Id_ICMP_UNREACH_HOST = 1;
Id_ICMP_UNREACH_PROTOCOL = 2;
Id_ICMP_UNREACH_PORT = 3;
Id_ICMP_UNREACH_NEEDFRAG = 4;
Id_ICMP_UNREACH_SRCFAIL = 5;
Id_ICMP_UNREACH_NET_UNKNOWN = 6;
Id_ICMP_UNREACH_HOST_UNKNOWN = 7;
Id_ICMP_UNREACH_ISOLATED = 8;
Id_ICMP_UNREACH_NET_PROHIB = 9;
Id_ICMP_UNREACH_HOST_PROHIB = 10;
Id_ICMP_UNREACH_TOSNET = 11;
Id_ICMP_UNREACH_TOSHOST = 12;
Id_ICMP_UNREACH_FILTER_PROHIB = 13;
Id_ICMP_UNREACH_HOST_PRECEDENCE = 14;
Id_ICMP_UNREACH_PRECEDENCE_CUTOFF = 15;
Id_ICMP_REDIRECT_NET = 0;
Id_ICMP_REDIRECT_HOST = 1;
Id_ICMP_REDIRECT_TOSNET = 2;
Id_ICMP_REDIRECT_TOSHOST = 3;
Id_ICMP_TIMXCEED_INTRANS = 0;
Id_ICMP_TIMXCEED_REASS = 1;
Id_ICMP_PARAMPROB_OPTABSENT = 1;
type
PIdIcmpEcho = ^TIdIcmpEcho;
TIdIcmpEcho = packed record
id: word; // identifier to match requests with replies
seq: word; // sequence number to match requests with replies
end;
PIdIcmpFrag = ^TIdIcmpFrag;
TIdIcmpFrag = packed record
pad: word;
mtu: word;
end;
PIdIcmpTs = ^TIdIcmpTs;
TIdIcmpTs = packed record
otime: TIdNetTime; // time message was sent, to calc roundtrip time
rtime: TIdNetTime;
ttime: TIdNetTime;
end;
// ICMP packet header
PIdIcmpHdr = ^TIdIcmpHdr;
TIdIcmpHdr = packed record
icmp_type: byte; // message type
icmp_code: byte; // error code
icmp_sum: word; // one's complement checksum {Do not Localize}
icmp_hun: packed record
case integer of
0: (echo: TIdIcmpEcho);
1: (gateway: TIdInAddr);
2: (frag: TIdIcmpFrag);
end;
icmp_dun: packed record
case integer of
0: (ts: TIdIcmpTs);
1: (mask: longword);
2: (data: char);
end;
end;
const
// IGMP types
Id_IGMP_MEMBERSHIP_QUERY = $11; // membership query
Id_IGMP_V1_MEMBERSHIP_REPORT = $12; // v1 membership report
Id_IGMP_V2_MEMBERSHIP_REPORT = $16; // v2 membership report
Id_IGMP_LEAVE_GROUP = $17; // leave-group message
type
// IGMP packet header
PIdIgmpHdr = ^TIdIgmpHdr;
TIdIgmpHdr = packed record
igmp_type: byte;
igmp_code: byte;
igmp_sum: word;
igmp_group: TIdInAddr;
end;
const
Id_ETHER_ADDR_LEN = 6;
type
TIdEtherAddr = packed record
ether_addr_octet: array [0..Id_ETHER_ADDR_LEN-1] of byte;
end;
const
// ethernet packet types
Id_ETHERTYPE_PUP = $0200; // PUP protocol
Id_ETHERTYPE_IP = $0800; // IP protocol
Id_ETHERTYPE_ARP = $0806; // ARP protocol
Id_ETHERTYPE_REVARP = $8035; // reverse ARP protocol
Id_ETHERTYPE_VLAN = $8100; // IEEE 802.1Q VLAN tagging
Id_ETHERTYPE_LOOPBACK = $9000; // used to test interfaces
type
// ethernet packet header
PIdEthernetHdr = ^TIdEthernetHdr;
TIdEthernetHdr = packed record
ether_dhost: TIdEtherAddr; // destination ethernet address
ether_shost: TIdEtherAddr; // source ethernet address
ether_type: word; // packet type ID
end;
const
// hardware address formats
Id_ARPHRD_ETHER = 1; // ethernet hardware format
// ARP operation types
Id_ARPOP_REQUEST = 1; // req to resolve address
Id_ARPOP_REPLY = 2; // resp to previous request
Id_ARPOP_REVREQUEST = 3; // req protocol address given hardware
Id_ARPOP_REVREPLY = 4; // resp giving protocol address
Id_ARPOP_INVREQUEST = 8; // req to identify peer
Id_ARPOP_INVREPLY = 9; // resp identifying peer
type
// ARP packet header
PIdArpHdr = ^TIdArpHdr;
TIdArpHdr = packed record
arp_hrd: word; // format of hardware address
arp_pro: word; // format of protocol address
arp_hln: byte; // length of hardware address
arp_pln: byte; // length of protocol addres
arp_op: word; // operation type
// following hardcoded for ethernet/IP
arp_sha: TIdEtherAddr; // sender hardware address
arp_spa: TIdInAddr; // sender protocol address
arp_tha: TIdEtherAddr; // target hardware address
arp_tpa: TIdInAddr; // target protocol address
end;
type
// base DNS header
PIdDnsHdr = ^TIdDnsHdr;
TIdDnsHdr = packed record
dns_id: word; // DNS packet ID
dns_flags: word; // DNS flags
dns_num_q: word; // number of questions
dns_num_answ_rr: word; // number of answer resource records
dns_num_auth_rr: word; // number of authority resource records
dns_num_addi_rr: word; // number of additional resource records
end;
const
// RIP commands
Id_RIPCMD_REQUEST = 1; // want info
Id_RIPCMD_RESPONSE = 2; // responding to request
Id_RIPCMD_TRACEON = 3; // turn tracing on
Id_RIPCMD_TRACEOFF = 4; // turn it off
Id_RIPCMD_POLL = 5; // like request, but anyone answers
Id_RIPCMD_POLLENTRY = 6; // like poll, but for entire entry
Id_RIPCMD_MAX = 7;
// RIP versions
Id_RIPVER_0 = 0;
Id_RIPVER_1 = 1;
Id_RIPVER_2 = 2;
type
// base RIP header
PIdRipHdr = ^TIdRipHdr;
TIdRipHdr = packed record
rip_cmd: byte; // RIP command
rip_ver: byte; // RIP version
rip_rd: word; // zero (v1) or routing domain (v2)
rip_af: word; // address family
rip_rt: word; // zero (v1) or route tag (v2)
rip_addr: longword; // IP address
rip_mask: longword; // zero (v1) or subnet mask (v2)
rip_next_hop: longword; // zero (v1) or next hop IP address (v2)
rip_metric: longword; // metric
end;
implementation
end.
|
unit u_timer_pool;
{$mode objfpc}{$H+}
interface
uses Classes
, SysUtils
, fpc_delphi_compat
;
type // TTimerPool ============================================================
TTimerPool = class(TComponent)
protected
fList : TList;
public
constructor Create(aOwner : TComponent); override;
destructor Destroy; override;
function Add(const aInterval : integer; const aHandler : TNotifyEvent) : TxPLTimer; reintroduce;
procedure Del(const aTimer : TxPLTimer);
end;
implementation
// TTimerPool =================================================================
constructor TTimerPool.Create(aOwner: TComponent);
begin
inherited;
fList := TList.Create;
end;
destructor TTimerPool.Destroy;
begin
fList.Free; // Will free all left timers
inherited;
end;
function TTimerPool.Add(const aInterval: integer; const aHandler: TNotifyEvent): TxPLTimer;
begin
result := TxPLTimer.Create(self);
result.Interval := aInterval;
result.OnTimer := aHandler;
fList.Add(result);
end;
procedure TTimerPool.Del(const aTimer: TxPLTimer);
begin
aTimer.Enabled := false;
fList.Remove(aTimer);
aTimer.Free;
end;
end.
|
unit UnitNameCaps;
{(*}
(*------------------------------------------------------------------------------
Delphi Code formatter source code
The Original Code is UnitNameCaps, released June 2003.
The Initial Developer of the Original Code is Anthony Steele.
Portions created by Anthony Steele are Copyright (C) 1999-2008 Anthony Steele.
All Rights Reserved.
Contributor(s): Anthony Steele.
The contents of this file are subject to the Mozilla Public License Version 1.1
(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.mozilla.org/NPL/
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.
Alternatively, the contents of this file may be used under the terms of
the GNU General Public License Version 2 or later (the "GPL")
See http://www.gnu.org/licenses/gpl.html
------------------------------------------------------------------------------*)
{*)}
{ AFS 16 June 2003
- fix capitalisation on unit names
}
{$I JcfGlobal.inc}
interface
uses SwitchableVisitor;
type
TUnitNameCaps = class(TSwitchableVisitor)
private
fiCount: integer;
lsLastChange: string;
protected
function EnabledVisitSourceToken(const pcNode: TObject): Boolean; override;
public
constructor Create; override;
function IsIncludedInSettings: boolean; override;
{ return true if you want the message logged}
function FinalSummary(out psMessage: string): boolean; override;
end;
implementation
uses
{ delphi }
{$IFNDEF FPC}Windows,{$ENDIF} SysUtils,
{ local }
SourceToken, Tokens, ParseTreeNodeType, JcfSettings, FormatFlags,
TokenUtils;
function IsUnitName(const pt: TSourceToken): boolean;
var
lcNext, lcPrev: TSourceToken;
begin
Result := False;
if not IsIdentifier(pt, idStrict) then
exit;
{ unit names can be found in these places:
in unit names
uses clause
and in expressions as a prefix for vars, constants and functions }
if pt.HasParentNode(nUnitName) then
Result := True
else if pt.HasParentNode(nUsesItem) then
Result := True
else if pt.HasParentNode(nDesignator) then
begin
// must be a dot to resolve unit name
lcNext := pt.NextSolidToken;
Result := (lcNext <> nil) and (lcNext.TokenType = ttDot);
if Result then
begin
// unit name is always first part of designator. May not be preceeded by a dot
lcPrev := pt.PriorSolidToken;
Result := (lcPrev <> nil) and (lcPrev.TokenType <> ttDot);
end;
end;
end;
{ TUnitNameCaps }
constructor TUnitNameCaps.Create;
begin
inherited;
fiCount := 0;
lsLastChange := '';
FormatFlags := FormatFlags + [eCapsSpecificWord];
end;
function TUnitNameCaps.FinalSummary(out psMessage: string): boolean;
begin
Result := (fiCount > 0);
psMessage := '';
if Result then
begin
psMessage := 'Unit name caps: ';
if fiCount = 1 then
psMessage := psMessage + 'One change was made: ' + lsLastChange
else
psMessage := psMessage + IntToStr(fiCount) + ' changes were made';
end;
end;
function TUnitNameCaps.EnabledVisitSourceToken(const pcNode: TObject): Boolean;
var
lcSourceToken: TSourceToken;
lsChange: string;
begin
Result := False;
lcSourceToken := TSourceToken(pcNode);
if not IsUnitName(lcSourceToken) then
exit;
if JcfFormatSettings.UnitNameCaps.HasWord(lcSourceToken.SourceCode) then
begin
// get the fixed version
lsChange := JcfFormatSettings.UnitNameCaps.CapitaliseWord(lcSourceToken.SourceCode);
// case-sensitive test - see if anything to do.
if AnsiCompareStr(lcSourceToken.SourceCode, lsChange) <> 0 then
begin
lsLastChange := lcSourceToken.SourceCode + ' to ' + lsChange;
lcSourceToken.SourceCode := lsChange;
Inc(fiCount);
end;
end;
end;
function TUnitNameCaps.IsIncludedInSettings: boolean;
begin
Result := JcfFormatSettings.UnitNameCaps.Enabled;
end;
end.
|
unit Security4D.UnitTest.Authorizer;
interface
uses
Security4D,
Security4D.Impl,
Security4D.UnitTest.Credential,
System.SysUtils;
type
TAuthorizer = class(TSecurityProvider, IAuthorizer)
private
{ private declarations }
protected
function HasRole(const role: string): Boolean;
function HasPermission(const resource, operation: string): Boolean;
public
{ public declarations }
end;
implementation
{ TAuthorizer }
function TAuthorizer.HasPermission(const resource, operation: string): Boolean;
var
credential: TCredential;
begin
Result := False;
if HasRole(ROLE_ADMIN) then
Result := True
else
begin
credential := (SecurityContext.AuthenticatedUser.Attribute as TCredential);
if (credential.Role.Equals(ROLE_MANAGER)) and (resource.Equals('Car')) and (operation.Equals('Insert')) then
Result := True;
if (credential.Role.Equals(ROLE_MANAGER)) and (resource.Equals('Car')) and (operation.Equals('Update')) then
Result := True;
if (credential.Role.Equals(ROLE_MANAGER)) and (resource.Equals('Car')) and (operation.Equals('Delete')) then
Result := True;
if (credential.Role.Equals(ROLE_MANAGER)) and (resource.Equals('Car')) and (operation.Equals('View')) then
Result := True;
if (credential.Role.Equals(ROLE_NORMAL)) and (resource.Equals('Car')) and (operation.Equals('View')) then
Result := True;
end;
end;
function TAuthorizer.HasRole(const role: string): Boolean;
begin
if not SecurityContext.IsLoggedIn then
raise EAuthenticationException.Create('Unauthenticated user.');
Result := (SecurityContext.AuthenticatedUser.Attribute as TCredential).Role.Equals(role);
end;
end.
|
unit uPluginManager;
interface
uses
SysUtils,
Classes,
{$IFDEF MSWINDOWS}
Windows,
{$ENDIF}
{$IFDEF LINUX}
Libc,
{$ENDIF}
uPlugInDefinitions;
type
TPlugin = class(TCollectionItem)
private
fHandle: THandle;
fName: String;
public
destructor Destroy; override;
function GetProcAddress(aProc: String): Pointer;
end;
TPlugins = class(TCollection)
private
function GetItem(Index: Integer): TPlugin;
public
function Add(Name: String): TPlugin;
property Items[Index: Integer]: TPlugin read GetItem;
end;
var
Plugins: TPlugins;
implementation
uses uMain;
{ TPlugins }
function TPlugins.Add(Name: String): TPlugin;
var
i, Handle: Integer;
begin
for i := 0 to Count - 1 do
if SameText(Items[i].fName, Name) then
begin
Result := Items[i];
Exit;
end;
{$IFDEF MSWINDOWS}
Handle := LoadLibrary( PChar(AppPath + 'Plugins\' + Name + '.dll') );
{$ENDIF}
{$IFDEF LINUX}
Handle := dlopen(AppPath + 'Plugins/' + Name + '.so', RTLD_LAZY);
{$ENDIF}
if Handle <> 0 then
begin
Result := TPlugin( inherited Add );
Result.fName := Name;
Result.fHandle := Handle;
end
else
Result := nil;
end;
function TPlugins.GetItem(Index: Integer): TPlugin;
begin
Result := TPlugin( inherited GetItem(Index) );
end;
{ TPlugin }
destructor TPlugin.Destroy;
begin
FreeLibrary(fHandle);
inherited;
end;
function TPlugin.GetProcAddress(aProc: String): Pointer;
begin
Result := nil; // To shut up the compiler
if fHandle <> 0 then
begin
{$IFDEF MSWINDOWS}
Result := Windows.GetProcAddress( fHandle, PChar(aProc) );
{$ENDIF}
{$IFDEF LINUX}
Result := dlsym(fHandle, aProc);
{$ENDIF}
end;
end;
initialization
Plugins := TPlugins.Create(TPlugin);
finalization
Plugins.Free;
end.
|
{
Version 12
Copyright (c) 2011-2012 by Bernd Gabriel
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.
Note that the source modules HTMLGIF1.PAS and DITHERUNIT.PAS
are covered by separate copyright notices located in those modules.
}
{$I htmlcons.inc}
unit HtmlRenderer;
interface
uses
Windows, SysUtils,
Classes, Controls, Contnrs, Graphics, Variants, Math,
//
BegaClasses,
HtmlBoxes,
HtmlBuffer,
HtmlCaches,
HtmlDocument,
HtmlDraw,
HtmlElements,
HtmlFonts,
HtmlGlobals,
HtmlImages,
HtmlIndentation,
HtmlStyles,
HtmlSymbols,
Parser,
StyleTypes,
UrlSubs;
type
EHtmlRendererException = class(Exception);
//------------------------------------------------------------------------------
// THtmlControlOfElementMap remembers controls that are used to render elements.
//------------------------------------------------------------------------------
// Some elements like the user interaction elements button, input, etc. and
// objects like frames and iframes are represented by controls of the underlying
// visual component library (VCL, LCL, ...). These must be reused by consecutive
// renderings. This map supports one control per element.
//------------------------------------------------------------------------------
THtmlControlOfElementMap = class(TBegaCustomMap)
private
function GetKey(Index: Integer): THtmlElement;
function GetValue(Index: Integer): TControl;
public
function Get(Key: THtmlElement): TControl; {$ifdef UseInline} inline; {$endif}
function Put(Key: THtmlElement; Control: TControl): TControl; {$ifdef UseInline} inline; {$endif}
procedure Clear;
property Elements[Index: Integer]: THtmlElement read GetKey;
property Controls[Index: Integer]: TControl read GetValue;
end;
//------------------------------------------------------------------------------
// THtmlRenderedDocument holds the rendered html document.
//------------------------------------------------------------------------------
// It is a collection of html boxes. A html element produces null or more
// html boxes when rendered.
//
// An element with Display:none produces no box at all.
// A non empty block element produces 1 box.
// A non empty inline element produces 1 or more boxes depending on line wraps
// and space left by aligned elements.
//------------------------------------------------------------------------------
// THtmlRenderedDocument = class
// end;
//
// THtmlVisualizedDocument = class(THtmlRenderedDocument)
// private
// FView: THtmlBox;
// public
// constructor Create(View: THtmlBox);
// end;
//------------------------------------------------------------------------------
// THtmlRenderer renders html documents.
//------------------------------------------------------------------------------
// Given source document, media type, destination area, and optionally (if re-
// rendered) the used visual controls, it renders the document for the specified
// media and area.
//------------------------------------------------------------------------------
TMediaCapabilities = set of (mcFrames, mcScript, mcEmbed);
THtmlRendererLog = class(TStringList);
THtmlRenderer = class
private
FDocument: THtmlDocument; // the source to render to destination
FMediaType: TMediaType; // media type of destination
FCapabilities: TMediaCapabilities;
FOnGetBuffer: TGetBufferEvent;
FLog: THtmlRendererLog;
function GetResultingProperties(Element: THtmlElement): TResultingPropertyMap;
function GetBaseUrl: ThtString;
protected
function GetBuffer(const Url: ThtString): ThtBuffer;
public
constructor Create(Document: THtmlDocument; MediaType: TMediaType);
destructor Destroy; override;
property BaseUrl: ThtString read GetBaseUrl;
property MediaCapabilities: TMediaCapabilities read FCapabilities write FCapabilities;
property MediaType: TMediaType read FMediaType;
property OnGetBuffer: TGetBufferEvent read FOnGetBuffer write FOnGetBuffer;
end;
THtmlVisualRenderer = class(THtmlRenderer)
private
//--------------------------------------
// settings / environment
//--------------------------------------
// general
FHeight: Integer; // height of destination viewport in pixels
FControls: THtmlControlOfElementMap;
// fonts
FDefaultFont: ThtFont;
FDefaultFontInfo: ThtFontInfo;
// images
FImages: ThtImageCache;
FOnGetImage: TGetImageEvent;
//--------------------------------------
// status
//--------------------------------------
// positioning
FSketchMapStack: TSketchMapStack;
function DefaultFontSize: Double;
function GetControl(const Element: THtmlElement): TControl;
function GetImage(Prop: TResultingProperty; Parent, Default: ThtImage): ThtImage;
function SketchMap: TSketchMap; {$ifdef UseInline} inline; {$endif}
procedure GetFontInfo(Props: TResultingPropertyMap; out Font: ThtFontInfo; const Parent, Default: ThtFontInfo);
procedure SetPropertiesToBox(
Element: THtmlElement;
Box: THtmlBox;
Properties: TResultingPropertyMap);
//
function CreateElement(Owner: TWinControl; ParentBox: THtmlBox; Element: THtmlElement): THtmlBox;
procedure CreateChildren(Owner: TWinControl; Box: THtmlBox; Element: THtmlElement);
protected
function CreateBox(Owner: TWinControl; ParentBox: THtmlBox; Element: THtmlElement): THtmlBox;
function CreateFrameset(Owner: TWinControl; ParentBox: THtmlBox; Element: THtmlElement): THtmlFramesetBox;
public
constructor Create(
Document: THtmlDocument;
ControlMap: THtmlControlOfElementMap;
ImageCache: ThtImageCache;
MediaType: TMediaType;
DefaultFont: ThtFont;
Width, Height: Integer);
destructor Destroy; override;
procedure RenderBox(Box: THtmlBox);
procedure RenderChildren(ParentBox: THtmlBox);
procedure RenderDocument(Owner: TWinControl; ParentBox: THtmlBox);
property ControlOfElementMap: THtmlControlOfElementMap read FControls;
property OnGetImage: TGetImageEvent read FOnGetImage write FOnGetImage;
end;
implementation
var
DefaultBox: THtmlBox;
{ THtmlControlOfElementMap }
procedure THtmlControlOfElementMap.Clear;
var
Index: Integer;
begin
for Index := Count - 1 downto 0 do
TControl(Remove(Index)).Free;
end;
//-- BG ---------------------------------------------------------- 18.04.2011 --
function THtmlControlOfElementMap.Get(Key: THtmlElement): TControl;
begin
Result := inherited Get(Key);
end;
//-- BG ---------------------------------------------------------- 18.04.2011 --
function THtmlControlOfElementMap.GetKey(Index: Integer): THtmlElement;
begin
Result := inherited GetKey(Index);
end;
//-- BG ---------------------------------------------------------- 18.04.2011 --
function THtmlControlOfElementMap.GetValue(Index: Integer): TControl;
begin
Result := inherited GetValue(Index);
end;
//-- BG ---------------------------------------------------------- 18.04.2011 --
function THtmlControlOfElementMap.Put(Key: THtmlElement; Control: TControl): TControl;
begin
Result := inherited Put(Key, Control);
end;
{ THtmlRenderer }
//-- BG ---------------------------------------------------------- 17.04.2011 --
constructor THtmlRenderer.Create(Document: THtmlDocument; MediaType: TMediaType);
begin
inherited Create;
FDocument := Document;
FMediaType := MediaType;
FLog := THtmlRendererLog.Create;
end;
//-- BG ---------------------------------------------------------- 18.12.2011 --
destructor THtmlRenderer.Destroy;
begin
FLog.Free;
inherited;
end;
//-- BG ---------------------------------------------------------- 21.08.2011 --
function THtmlRenderer.GetBaseUrl: ThtString;
begin
Result := FDocument.BaseUrl;
end;
//-- BG ---------------------------------------------------------- 30.04.2011 --
function THtmlRenderer.GetBuffer(const Url: ThtString): ThtBuffer;
var
Filename: ThtString;
Stream: TStream;
begin
if assigned(FOnGetBuffer) then
Result := FOnGetBuffer(Self, Url)
else
begin
Filename := HTMLToDos(Url);
if FileExists(Filename) then
begin
Stream := TFileStream.Create(Filename, fmOpenRead + fmShareDenyWrite);
try
Result := TBuffer.Create(Stream, Filename);
finally
Stream.Free;
end;
end
else
Result := nil;
end;
end;
//-- BG ---------------------------------------------------------- 17.04.2011 --
function THtmlRenderer.GetResultingProperties(Element: THtmlElement): TResultingPropertyMap;
var
I: Integer;
Ruleset: TRuleset;
Selector: TStyleSelector;
begin
Result := TResultingPropertyMap.Create;
// 1) Fill map with properties from style attribute (highest prio),
Result.UpdateFromAttributes(Element.StyleProperties, True);
// 2) Walk through ruleset list in reverse order. If a selector of the ruleset matches,
// then call UpdateFromProperties() with the ruleset's properties and if the combination has a
// higher cascading order, this becomes the new resulting value.
if FDocument.RuleSets <> nil then
for I := FDocument.RuleSets.Count - 1 downto 0 do
begin
Ruleset := FDocument.RuleSets[I];
if FMediaType in Ruleset.MediaTypes then
begin
Selector := Ruleset.Selectors.First;
while Selector <> nil do
begin
if Element.IsMatching(Selector) then
begin
Result.UpdateFromProperties(Ruleset.Properties, Selector);
break;
end;
Selector := Selector.Next;
end;
end;
end;
// 3) Fill up missing properties with other tag attributes (like color, width, height, ...).
Result.UpdateFromAttributes(Element.AttributeProperties, False);
end;
{ THtmlVisualRenderer }
//-- BG ---------------------------------------------------------- 25.04.2011 --
constructor THtmlVisualRenderer.Create(
Document: THtmlDocument;
ControlMap: THtmlControlOfElementMap;
ImageCache: ThtImageCache;
MediaType: TMediaType;
DefaultFont: ThtFont;
Width, Height: Integer);
begin
inherited Create(Document, MediaType);
FSketchMapStack := TSketchMapStack.Create;
FSketchMapStack.Push(TSketchMap.Create(Width));
FCapabilities := [mcFrames];
FControls := ControlMap;
FImages := ImageCache;
FDefaultFont := DefaultFont;
FHeight := Height;
end;
//-- BG ---------------------------------------------------------- 29.08.2011 --
function THtmlVisualRenderer.CreateBox(Owner: TWinControl; ParentBox: THtmlBox; Element: THtmlElement): THtmlBox;
var
Properties: TResultingPropertyMap;
Info: THtmlElementBoxingInfo;
Control: THtmlBodyControl;
begin
if ParentBox = nil then
raise EHtmlRendererException.Create('RenderBox() requires a parent box <> nil.');
Properties := GetResultingProperties(Element);
try
case Element.Symbol of
BodySy:
begin
Info.Display := pdBlock;
Info.Position := posStatic;
Info.Float := flNone;
end;
else
Info.Display := ParentBox.Display;
Info.Position := ParentBox.Position;
Info.Float := ParentBox.Float;
end;
Properties.GetElementBoxingInfo(Info);
case Info.Display of
pdUnassigned:
raise EHtmlRendererException.CreateFmt(
'No "Display" assigned for element "%s" at document position %d.',
[ElementSymbolToStr(Element.Symbol), Element.DocPos]);
pdNone:
begin
Result := nil;
Exit; // do not create a Result at all for display:none
end;
end;
case Element.Symbol of
BodySy:
begin
// get or create the body control
Info.Display := ToRootDisplayStyle(Info.Display);
Control := GetControl(Element) as THtmlBodyControl;
if Control = nil then
begin
Control := THtmlBodyControl.Create(Owner);
ControlOfElementMap.Put(Element, Control);
end;
// create the body Result
Result := THtmlBodyBox.Create(Control);
Result.Tiled := True;
end;
else
// create an ordinary Result
Result := THtmlElementBox.Create;
end;
try
Result.Display := Info.Display;
Result.Float := Info.Float;
Result.Position := Info.Position;
Result.Element := Element;
Result.Properties := Properties;
Properties := nil; // now Result owns the properties. Don't free on exception, as Result will do it.
CreateChildren(Owner, Result, Element);
except
Result.Free;
raise;
end;
except
on E: Exception do
begin
FLog.AddObject(E.Message, Element);
Properties.Free;
raise;
end;
end;
end;
//-- BG ---------------------------------------------------------- 14.12.2011 --
procedure THtmlVisualRenderer.CreateChildren(Owner: TWinControl; Box: THtmlBox; Element: THtmlElement);
function GetFirstBlockBox(Box: THtmlBox): THtmlBox;
begin
Result := Box;
while (Box <> nil) and (Box.Display <> pdBlock) do
Box := Box.Next;
end;
function CanRunInto(Box: THtmlBox): Boolean;
begin
Result := (Box.Display = pdBlock) and not (Box.Position in [posAbsolute, posFixed]) and (Box.Float = flNone);
end;
{
Create the children of the given box/element.
Owner is the owner control of the box.
Box is the box created from Element.
Element is the element, whose child boxes to be created.
}
var
Child: THtmlElement;
ChildBox, NextBox: THtmlBox;
begin
Child := Element.FirstChild;
while Child <> nil do
begin
try
ChildBox := CreateElement(Owner, Box, Child);
if ChildBox <> nil then
Box.AppendChild(ChildBox);
except
on E: Exception do
FLog.AddObject(E.Message, Element);
end;
Child := Child.Next;
end;
// calculate Display for pdRunIn
ChildBox := Box.Children.First;
while ChildBox <> nil do
begin
NextBox := ChildBox.Next;
if ChildBox.Display = pdRunIn then
begin
// http://www.w3.org/TR/css3-box/#run-in-boxes:
// If the run-in box contains a block box, the run-in box becomes a block box.
// If a sibling block box (that does not float and is not absolutely positioned) follows
// the run-in box, the run-in box becomes the first inline box of the block box. A run-in
// cannot run in to a block that already starts with a run-in or that itself is a run-in.
// Otherwise, the run-in box becomes a block box.
if (GetFirstBlockBox(ChildBox.Children.First) = nil) and CanRunInto(NextBox) then
begin
Box.ExtractChild(ChildBox);
NextBox.InsertChild(ChildBox, NextBox.Children.First);
end
else
ChildBox.Display := pdBlock;
end;
ChildBox := NextBox;
end;
end;
//-- BG ---------------------------------------------------------- 25.04.2011 --
function THtmlVisualRenderer.CreateElement(Owner: TWinControl; ParentBox: THtmlBox; Element: THtmlElement): THtmlBox;
begin
case Element.Symbol of
FrameSetSy:
Result := CreateFrameset(Owner, ParentBox, Element);
else
Result := CreateBox(Owner, ParentBox, Element);
end;
end;
//-- BG ---------------------------------------------------------- 25.04.2011 --
function THtmlVisualRenderer.CreateFrameset(Owner: TWinControl; ParentBox: THtmlBox; Element: THtmlElement): THtmlFramesetBox;
begin
raise EHtmlRendererException.Create('CreateFrameset not yet implemented.');
end;
//-- BG ---------------------------------------------------------- 03.05.2011 --
function THtmlVisualRenderer.DefaultFontSize: Double;
begin
if FDefaultFont = nil then
Result := 12
else if FDefaultFont.Size < 0 then
Result := FDefaultFont.Height * 72 / FDefaultFont.PixelsPerInch
else
Result := FDefaultFont.Size;
end;
//-- BG ---------------------------------------------------------- 28.08.2011 --
destructor THtmlVisualRenderer.Destroy;
begin
FSketchMapStack.Free;
inherited;
end;
//-- BG ---------------------------------------------------------- 25.04.2011 --
function THtmlVisualRenderer.GetControl(const Element: THtmlElement): TControl;
begin
if FControls <> nil then
Result := FControls.Get(Element)
else
Result := nil;
end;
//------------------------------------------------------------------------------
procedure THtmlVisualRenderer.GetFontInfo(Props: TResultingPropertyMap; out Font: ThtFontInfo; const Parent, Default: ThtFontInfo);
var
Style: TFontStyles;
begin
Font.ibgColor := Props[BackgroundColor].GetColor(Parent.ibgColor, Default.ibgColor);
Font.iColor := Props[Color].GetColor(Parent.iColor, Default.iColor);
Style := [];
if Props[FontWeight].GetFontWeight(Parent.iWeight, Default.iWeight) >= 600 then
Include(Style, fsBold);
if Props[FontStyle].IsItalic(fsItalic in Parent.iStyle, fsItalic in Default.iStyle) then
Include(Style, fsItalic);
Font.iStyle := Style + Props[TextDecoration].GetTextDecoration(
Parent.iStyle * [fsUnderline, fsStrikeOut],
Default.iStyle * [fsUnderline, fsStrikeOut]);
Font.iSize := Props[FontSize].GetFontSize(DefaultFontSize, Parent.iSize, Default.iSize);
Font.iCharset := Default.iCharSet;
Font.iName := Props[FontFamily].GetFontName(Parent.iName, Default.iName);
Font.iCharExtra := Props[LetterSpacing].GetValue(Parent.iCharExtra, Default.iCharExtra);
end;
//-- BG ---------------------------------------------------------- 30.04.2011 --
function THtmlVisualRenderer.GetImage(Prop: TResultingProperty; Parent, Default: ThtImage): ThtImage;
var
ImageName: ThtString;
ImageIndex: Integer;
FileName: ThtString;
Stream: TStream;
begin
Result := Default;
if Prop <> nil then
if Prop.Prop.Value = Inherit then
Result := Parent
else
begin
ImageName := RemoveQuotes(Prop.Prop.Value);
if FImages.Find(ImageName, ImageIndex) then
Result := FImages.GetImage(ImageIndex)
else
begin
if assigned(FOnGetImage) then
Result := FOnGetImage(Self, ImageName)
else
begin
FileName := HTMLToDos(ImageName);
try
Stream := TFileStream.Create(FileName, fmOpenRead + fmShareDenyWrite);
try
Result := LoadImageFromStream(Stream, NotTransp);
finally
Stream.Free;
end;
except
Result := nil;
end;
end;
FImages.InsertImage(ImageIndex, ImageName, Result);
end;
end;
end;
//-- BG ---------------------------------------------------------- 18.12.2011 --
procedure THtmlVisualRenderer.RenderBox(Box: THtmlBox);
begin
SetPropertiesToBox(Box.Element, Box, Box.Properties);
RenderChildren(Box);
end;
//-- BG ---------------------------------------------------------- 18.12.2011 --
procedure THtmlVisualRenderer.RenderChildren(ParentBox: THtmlBox);
var
Box: THtmlBox;
begin
Box := ParentBox.Children.First;
while Box <> nil do
begin
RenderBox(Box);
Box := Box.Next;
end;
end;
//-- BG ---------------------------------------------------------- 17.04.2011 --
procedure THtmlVisualRenderer.RenderDocument(Owner: TWinControl; ParentBox: THtmlBox);
var
Box: THtmlBox;
begin
Box := CreateElement(Owner, ParentBox, FDocument.Tree);
if Box <> nil then
begin
ParentBox.AppendChild(Box);
RenderChildren(ParentBox);
//ParentBox.BoundsRect := Box.BoundsRect;
end;
end;
//-- BG ---------------------------------------------------------- 30.04.2011 --
procedure THtmlVisualRenderer.SetPropertiesToBox(
Element: THtmlElement;
Box: THtmlBox;
Properties: TResultingPropertyMap);
procedure GetStaticBounds(psWidth: TPropertySymbol; ParentWidth, EmBase: Double; out Left, Right: Integer);
begin
Left := 0;
if Properties[psWidth].HasValue then
Right := Left + Trunc(Properties[psWidth].GetLength(0.0, ParentWidth, EmBase, 0.0))
else
Right := Left;
end;
procedure GetAbsoluteBounds(psLeft, psRight, psWidth: TPropertySymbol; ParentWidth, EmBase: Double; out Left, Right: Integer);
begin
// Prefer left over right
if Properties[psLeft].HasValue then
begin
Left := Trunc(Properties[psLeft].GetLength(0.0, ParentWidth, EmBase, 0.0));
// prefer width over right
if Properties[psWidth].HasValue then
Right := Left + Trunc(Properties[psWidth].GetLength(0.0, ParentWidth, EmBase, 0.0))
else if Properties[psRight].HasValue then
// right is relative to parent width
Right := Trunc(ParentWidth - Properties[psRight].GetLength(0.0, ParentWidth, EmBase, 0.0))
else
Right := Left;
end
else if Properties[psRight].HasValue then
begin
Right := Trunc(ParentWidth - Properties[psRight].GetLength(0.0, ParentWidth, EmBase, 0.0));
if Properties[psWidth].HasValue then
Left := Right - Trunc(Properties[psWidth].GetLength(0.0, ParentWidth, EmBase, 0.0))
else
Left := Right;
end
else
begin
Left := 0;
if Properties[psWidth].HasValue then
Right := Left + Trunc(Properties[psWidth].GetLength(0.0, ParentWidth, EmBase, 0.0))
else
Right := Left;
end;
if Right < Left then
Right := Left;
end;
procedure GetRelativeOffset(psLeft, psRight: TPropertySymbol; ParentWidth, EmBase: Double; out Left, Right: Integer);
begin
if Properties[psLeft].HasValue then
Left := Trunc(Properties[psLeft].GetLength(0.0, ParentWidth, EmBase, 0.0))
else
Left := 0;
if Properties[psRight].HasValue then
Right := Trunc(Properties[psRight].GetLength(0.0, ParentWidth, EmBase, 0.0))
else
Right := 0;
end;
var
ParentBox: THtmlBox;
FontInfo: ThtFontInfo;
EmBase: Integer;
Font: ThtFont;
ParentWidth, ParentHeight: Integer;
Rect: TRect;
begin
ParentBox := Box.Parent;
while ParentBox is THtmlAnonymousBox do
ParentBox := ParentBox.Parent;
if ParentBox = nil then
ParentBox := DefaultBox;
// Font
GetFontInfo(Properties, FontInfo, FDefaultFontInfo, FDefaultFontInfo);
Font := AllMyFonts.GetFontLike(FontInfo);
Box.Font := Font;
EmBase := Font.EmSize;
freeAndNil(Font);
Box.Color := Properties[BackgroundColor].GetColor(ParentBox.Color, clNone);
Box.Image := GetImage(Properties[BackgroundImage], ParentBox.Image, nil);
Box.Margins := Properties.GetLengths(MarginLeft, MarginTop, MarginRight, MarginBottom, ParentBox.Margins, NullIntegers, EmBase);
Box.Paddings := Properties.GetLengths(PaddingLeft, PaddingTop, PaddingRight, PaddingBottom, ParentBox.Paddings, NullIntegers, EmBase);
Box.BorderWidths := Properties.GetLengths(BorderLeftWidth, BorderTopWidth, BorderRightWidth, BorderBottomWidth, ParentBox.BorderWidths, NullIntegers, EmBase);
Box.BorderColors := Properties.GetColors(BorderLeftColor, BorderTopColor, BorderRightColor, BorderBottomColor, ParentBox.BorderColors, NoneColors);
Box.BorderStyles := Properties.GetStyles(BorderLeftStyle, BorderTopStyle, BorderRightStyle, BorderBottomStyle, ParentBox.BorderStyles, NoneStyles);
case Box.Display of
pdUnassigned,
pdNone:
raise EHtmlRendererException.Create('A box having "Display:' + CDisplayStyle[Box.Display] + '" is not supported.');
else
ParentWidth := ParentBox.ContentRect.Right - ParentBox.ContentRect.Left;
ParentHeight := ParentBox.ContentRect.Bottom - ParentBox.ContentRect.Top;
case Box.Position of
posStatic:
begin
GetStaticBounds(psWidth, ParentWidth, EmBase, Rect.Left, Rect.Right);
GetStaticBounds(psHeight, ParentHeight, EmBase, Rect.Top, Rect.Bottom);
case Element.Symbol of
BodySy:
begin
if Rect.Right < ParentWidth then
Rect.Right := ParentWidth;
if Rect.Bottom < ParentHeight then
Rect.Bottom := ParentHeight;
end;
end;
end;
posRelative:
begin
GetStaticBounds(psWidth, ParentWidth, EmBase, Rect.Left, Rect.Right);
GetStaticBounds(psHeight, ParentHeight, EmBase, Rect.Top, Rect.Bottom);
GetRelativeOffset(psLeft, psRight, ParentWidth, EmBase, Rect.Left, Rect.Right);
GetRelativeOffset(psTop, psBottom, ParentHeight, EmBase, Rect.Top, Rect.Bottom);
end;
posFixed:
begin
GetAbsoluteBounds(psLeft, psRight, psWidth, ParentWidth, EmBase, Rect.Left, Rect.Right);
GetAbsoluteBounds(psTop, psBottom, psHeight, ParentHeight, EmBase, Rect.Top, Rect.Bottom);
//TODO: add viewport origin to keep it at a scroll indeendent position:
end;
else
//posAbsolute:
GetAbsoluteBounds(psLeft, psRight, psWidth, ParentWidth, EmBase, Rect.Left, Rect.Right);
GetAbsoluteBounds(psTop, psBottom, psHeight, ParentHeight, EmBase, Rect.Top, Rect.Bottom);
end;
Box.BoundsRect := Rect;
end;
end;
//-- BG ---------------------------------------------------------- 04.09.2011 --
function THtmlVisualRenderer.SketchMap: TSketchMap;
begin
Result := FSketchMapStack.Top;
end;
initialization
DefaultBox := THtmlBox.Create;
finalization
DefaultBox.Free;
end.
|
unit ncaFrmTotal3;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, cxGraphics, cxControls, cxLookAndFeels, cxLookAndFeelPainters,
cxContainer, cxEdit, cxLabel, LMDControl, LMDCustomControl, LMDCustomPanel,
LMDCustomBevelPanel, LMDSimplePanel, cxTextEdit, cxMemo, dxGDIPlusClasses,
ExtCtrls, LMDBaseEdit, LMDCustomMemo, LMDMemo, ncEspecie, ImgList, ncMyImage;
type
TFrmTotal3 = class(TForm)
panTot: TLMDSimplePanel;
panValor: TLMDSimplePanel;
lbTotal: TcxLabel;
lbEditPagamento: TcxLabel;
lbEditObs: TcxLabel;
lbEditDesconto: TcxLabel;
panDesconto: TLMDSimplePanel;
panPontos: TLMDSimplePanel;
lbPontosDisp: TcxLabel;
lbPontosNec: TcxLabel;
imgs: TcxImageList;
panDesc2: TLMDSimplePanel;
lbDesconto: TcxLabel;
lbPromptDesconto: TcxLabel;
panDesc1: TLMDSimplePanel;
lbSubTotal: TcxLabel;
cxLabel3: TcxLabel;
lbObs: TcxLabel;
procedure panTotResize(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure lbEditObsClick(Sender: TObject);
procedure lbEditDescontoClick(Sender: TObject);
private
FDesconto: Currency;
FDescPorPerc : Boolean;
FDescPerc : Double;
FPontosNec: Double;
FPontosDisp: Double;
FFidResgate: Boolean;
FPagEsp : TncPagEspecies;
FOpPagto: Byte;
FRecebido: Currency;
procedure SetSubTotal(const Value: Currency);
procedure SetPontosNec(const Value: Double);
procedure SetPontosDisp(const Value: Double);
procedure SetFidResgate(const Value: Boolean);
procedure SetObs(const Value: String);
function GetObs: String;
procedure SetDesconto(const Value: Currency);
procedure SetOpPagto(const Value: Byte);
procedure SetRecebido(const Value: Currency);
function GetSubTotal: Currency;
procedure SetDescPerc(const Value: Double);
procedure SetDescPorPerc(const Value: Boolean);
{ Private declarations }
public
procedure InitVal(aPagEsp: TncPagEspecies; aSubTot, aDesconto, aPago, aRecebido : Double; aObs: String; aParent: TWinControl; aShowObs: Boolean = True);
procedure InitPontos(aNec, aDisp: Double; aObs: String; aParent: TWinControl; aShowObs: Boolean = True);
procedure InitCusto(aPagEsp: TncPagEspecies; aCusto: Double; aObs: String; aParent: TWinControl; aShowObs: Boolean = True);
procedure Atualiza;
procedure AlteraParent(aParent: TWinControl);
procedure EditObs;
procedure EditDesc;
function Total: Currency;
function calcDesconto: Currency;
function calcPerc: Double;
function EditarPagEsp: Boolean;
procedure SetPagEsp(aPagEsp: TncPagEspecies);
property SubTotal: Currency read GetSubTotal write SetSubTotal;
property Desconto: Currency read FDesconto write SetDesconto;
property DescPerc: Double read FDescPerc write SetDescPerc;
property DescPorPerc: Boolean read FDescPorPerc write SetDescPorPerc;
property PontosNec: Double read FPontosNec write SetPontosNec;
property PontosDisp: Double read FPontosDisp write SetPontosDisp;
property FidResgate: Boolean read FFidResgate write SetFidResgate;
property Recebido: Currency read FRecebido write SetRecebido;
property Obs: String read GetObs write SetObs;
property OpPagto: Byte read FOpPagto write SetOpPagto;
{ Public declarations }
end;
var
FrmTotal3: TFrmTotal3;
resourcestring
rsPontosNec = 'Pontos Necessários';
rsPontosDisp = 'Pontos Disponíveis';
rsTotal = 'Total';
rsSubTotal = 'Sub-Total';
rsDesconto = 'Desconto';
implementation
uses ncClassesBase, ncaFrmObs, ncaFrmEditObs, ncaFrmEditDesc;
{$R *.dfm}
function PontosToStr(P: Double): String;
begin
Str((Int(P*10)/10):10:1, Result);
Result := Trim(Result);
if Pos('.', Result)>0 then
while (Result>'') and (Result[Length(Result)] in ['0']) do Delete(Result, Length(Result), 1);
if Result[Length(Result)]='.' then Delete(Result, Length(Result), 1);
end;
procedure TFrmTotal3.AlteraParent(aParent: TWinControl);
begin
panTot.Parent := aParent;
aParent.Height := panTot.Height;
end;
procedure TFrmTotal3.Atualiza;
var ObsH, DescH: Integer;
begin
lbPontosNec.Caption := rsPontosNec + ' = ' + PontosToStr(FPontosNec);
lbPontosDisp.Caption := rsPontosDisp + ' = ' + PontosToStr(FPontosDisp);
if FPontosDisp>=FPontosNec then
lbPontosDisp.Style.TextColor := clGreen else
lbPontosDisp.Style.TextColor := clRed;
lbSubTotal.Caption := CurrencyToStr(SubTotal);
lbPromptDesconto.Caption := rsDesconto + ' ('+PercToStr(calcPerc)+') =';
lbDesconto.Caption := CurrencyToStr(FDesconto);
lbTotal.Caption := rsTotal + ' = ' + CurrencyToStr(Total);
// lbTotal.Caption := rsTotal + ' * ' + FloatToStrF(Total, ffCurrency, 15, CurrencyDecimals);
lbObs.Visible := (Obs>'');
lbEditObs.Visible := (Obs='');
panDesconto.Visible := (FDesconto>0.0001);
panPontos.Visible := FidResgate;
panValor.Visible := not FidResgate;
if (not FidResgate) and (FDesconto>0) then
DescH := panDesconto.Height;
DescH := 0;
panDesconto.Top := ObsH;
panValor.Top := 1000;
panPontos.Top := ObsH;
panTot.Parent.Height := panTot.Height;
end;
function TFrmTotal3.calcDesconto: Currency;
begin
if FDescPorPerc then
Result := DuasCasas(FPagEsp.TotalPagar * (FDescPerc/100)) else
Result := FDesconto;
end;
function TFrmTotal3.calcPerc: Double;
begin
if not Assigned(FPagEsp) then
Result := 0
else
if FDescPorPerc then
Result := FDescPerc
else
Result := FDesconto / FPagEsp.TotalPagar * 100;
end;
function TFrmTotal3.EditarPagEsp: Boolean;
var
P : TncPagEspecies;
C, D, Desc: Currency;
begin
{ P := TncPagEspecies.Create;
try
P.Assign(FPagEsp);
Desc := FME.Desconto;
C := FCredUsado + FCli.Credito;
if (FCredUsado>0) and (C<FCredUsado) then C := FCredUsado;
if not FNovo then
D := 0 else
D := FCli.Debito;
Result := TFrmPagEspecie.Create(Self).Editar(FNovo, P, FTot.SubTotal, C, D, Desc);
if Result then begin
FME.Desconto := Desc;
FME.PagEsp.Assign(P);
end;
finally
P.Free;
end;}
end;
procedure TFrmTotal3.EditDesc;
var
aDescPerc: Double;
aDescPorPerc: Boolean;
Desc: Currency;
begin
aDescPerc := DescPerc;
aDescPorPerc := DescPorPerc;
Desc := Desconto;
if TFrmEditDesc.Create(Self).Editar(SubTotal, Desc, aDescPerc, aDescPorPerc) then begin
Desconto := Desc;
Descperc := aDescPerc;
DescPorPerc := aDescPorPerc;
end;
end;
procedure TFrmTotal3.EditObs;
begin
Obs := TFrmEditObs.Create(Self).Editar(Obs);
end;
procedure TFrmTotal3.FormCreate(Sender: TObject);
begin
FPontosNec := 0;
FPontosDisp := 0;
FFidResgate := False;
FDesconto := 0;
FDescPerc := 0;
FDescPorPerc := False;
lbObs.Caption := '';
Atualiza;
end;
function TFrmTotal3.GetObs: String;
begin
Result := lbObs.Caption;
end;
function TFrmTotal3.GetSubTotal: Currency;
begin
if FPagEsp=nil then
Result := 0 else
Result := FPagEsp.TotalPagar;
end;
procedure TFrmTotal3.InitCusto(aPagEsp: TncPagEspecies; aCusto: Double; aObs: String;
aParent: TWinControl; aShowObs: Boolean);
begin
FPagEsp := aPagEsp;
AlteraParent(aParent);
lbEditPagamento.Visible := False;
lbEditObs.Visible := (aObs>'') or aShowObs;
Obs := aObs;
SubTotal := aCusto;
FidResgate := False;
end;
procedure TFrmTotal3.InitPontos(aNec, aDisp: Double; aObs: String;
aParent: TWinControl; aShowObs: Boolean);
begin
FPagEsp := nil;
AlteraParent(aParent);
FidResgate := True;
lbEditDesconto.Visible := False;
lbEditPagamento.Visible := False;
lbEditObs.Visible := (aObs>'') or aShowObs;
PontosNec := aNec;
PontosDisp := aDisp;
Obs := aObs;
end;
procedure TFrmTotal3.InitVal(aPagEsp: TncPagEspecies; aSubTot, aDesconto, aPago, aRecebido: Double;
aObs: String; aParent: TWinControl; aShowObs: Boolean);
begin
FPagEsp := aPagEsp;
AlteraParent(aParent);
FidResgate := False;
lbEditDesconto.Visible := True;
lbEditPagamento.Visible := True;
lbEditObs.Visible := (aObs>'') or aShowObs;
SubTotal := aSubTot;
Desconto := aDesconto;
Obs := aObs;
end;
procedure TFrmTotal3.lbEditDescontoClick(Sender: TObject);
begin
EditDesc;
end;
procedure TFrmTotal3.lbEditObsClick(Sender: TObject);
begin
EditObs;
end;
procedure TFrmTotal3.panTotResize(Sender: TObject);
begin
panTot.Parent.Height := panTot.Height;
end;
procedure TFrmTotal3.SetDesconto(const Value: Currency);
begin
FDesconto := Value;
Atualiza;
end;
procedure TFrmTotal3.SetDescPerc(const Value: Double);
begin
if Value<>FDescPerc then begin
FDescPerc := Value;
Atualiza;
end;
end;
procedure TFrmTotal3.SetDescPorPerc(const Value: Boolean);
begin
if Value<>FDescPorPerc then begin
FDescPorPerc := Value;
Atualiza;
end;
end;
procedure TFrmTotal3.SetFidResgate(const Value: Boolean);
begin
FFidResgate := Value;
Atualiza;
end;
procedure TFrmTotal3.SetObs(const Value: String);
begin
lbObs.Caption := Value;
if FPagEsp<>nil then
FPagEsp.Obs := Value;
Atualiza;
end;
procedure TFrmTotal3.SetOpPagto(const Value: Byte);
begin
FOpPagto := Value;
end;
procedure TFrmTotal3.SetPagEsp(aPagEsp: TncPagEspecies);
begin
FPagEsp := aPagEsp;
Atualiza;
end;
procedure TFrmTotal3.SetPontosDisp(const Value: Double);
begin
FPontosDisp := Value;
Atualiza;
end;
procedure TFrmTotal3.SetPontosNec(const Value: Double);
begin
FPontosNec := Value;
Atualiza;
end;
procedure TFrmTotal3.SetRecebido(const Value: Currency);
begin
FRecebido := Value;
end;
procedure TFrmTotal3.SetSubTotal(const Value: Currency);
begin
if FPagEsp<>nil then begin
FPagEsp.TotalPagar := Value;
Atualiza;
end;
end;
function TFrmTotal3.Total: Currency;
begin
if FPagEsp<>nil then
Result := FPagEsp.TotalPagar - calcDesconto else
Result := 0;
end;
end.
|
unit JAParticleSystem;
{$mode objfpc}{$H+}
interface
uses
JTypes,
JATypes, JASpatial;
type
TJAParticle = record
Position : TVec2;
Velocity : TVec2;
Rotation : Float32;
RotationVelocity : Float32;
Colour : TJColour;
Age : Float32;
Death : Float32;
end;
PJAParticle = ^TJAParticle;
TJAParticleSystem = record
Spatial : TJASpatial;
Particles : array of TJAParticle;
ParticlesCount : UInt32;
end;
PJAParticleSystem = ^TJAParticleSystem;
function JAParticleSystemCreate() : PJAParticleSystem;
function JAParticleSystemDestroy(AParticleSystem : PJAParticleSystem) : boolean;
implementation
function JAParticleSystemCreate : PJAParticleSystem;
begin
Result := JAMemGet(SizeOf(TJAParticleSystem);
Result^.Spatial := JASpatialDefault;
SetLength(Result^.Particles,0);
Result^.ParticlesCount := 0;
end;
function JAParticleSystemDestroy(AParticleSystem : PJAParticleSystem) : boolean;
begin
SetLength(Result^.Particles,0);
JAMemFree(AParticleSystem);
end;
end.
|
unit datetime_1;
interface
implementation
var
dt: DateTime;
procedure Test;
begin
dt := Now();
end;
initialization
Test();
finalization
Assert(dt <> 0);
end. |
unit uLibraries;
interface
uses ShareMem,windows, classes, SysUtils, uTypes, uErrorConst;
type
TDllInfoProc = function:TDllInfo; stdcall;
TDllTerminateProc = procedure; stdcall;
TDllRunProc = procedure; stdcall;
TDllInitializeProc = procedure; stdcall;
TDllGetErrorStrProc = function(code:byte):string; stdcall;
PLibrary = ^Tlibrary;
TLibrary = class
private
// Dll var's
FDllPath: string;
FDllHandle: THandle;
FDllInfo: TDllInfo;
FActivate: boolean;
// Dll procedure's
FLoadDllInfo: TDllInfoProc;
FRun: TDllRunProc;
FTerminate: TDllTerminateProc;
FInitialize: TDllTerminateProc;
FGetErrorStr: TDllGetErrorStrProc;
public
LAST_ERROR: integer;
constructor Create(ADllName:String; var IsValidModule:Boolean);
destructor Destroy; override;
// Call procedure's of Dll
function LoadDllInfo:TDllInfo;
procedure Run;
procedure Terminate;
procedure Initialize;
function GetErrorStr(code:byte):string;
// property's
property DllHandle : THandle read FDllHandle;
property DllPath : string read FDllPath;
property DllInfo : TDllInfo read FDllInfo;
property Activate: boolean read FActivate;
end;
implementation
{ TLibrary }
constructor TLibrary.Create(ADllName: String; var IsValidModule: Boolean);
begin
LAST_ERROR:= 0;
if not FileExists(ADllName) then
Begin
LAST_ERROR:= ERROR_DLL_NOTFOUND;
IsValidModule:= false;
exit;
End;
FDLLHandle:= LoadLibrary(PChar(ADllName));
if FDllHandle = 0 then
Begin
LAST_ERROR:= ERROR_DLL_LOAD_FAILED;
IsValidModule:= false;
exit;
End;
@FLoadDllInfo := GetProcAddress(FDllHandle,'DllInfo');
if @FLoadDllInfo = nil then
Begin
LAST_ERROR:= ERROR_DLL_NOT_VALID;
IsValidModule:= false;
exit;
End;
IsValidModule:= true;
FDllInfo:= LoadDllInfo;
end;
destructor TLibrary.Destroy;
begin
FreeLibrary(DllHandle);
inherited;
end;
function TLibrary.GetErrorStr(code: byte): string;
begin
@FGetErrorStr := GetProcAddress(DllHandle,'DllGetErrorStr');
if @FGetErrorStr = nil then
Begin
LAST_ERROR:= ERROR_DLL_FUNC_NOTFOUND;
exit;
End;
Result:= FGetErrorStr(code);
end;
procedure TLibrary.Initialize;
begin
@FInitialize := GetProcAddress(DllHandle,'DllInitialize');
if @FInitialize = nil then
Begin
LAST_ERROR:= ERROR_DLL_FUNC_NOTFOUND;
exit;
End;
FInitialize;
end;
function TLibrary.LoadDllInfo: TDllInfo;
begin
Result:= FLoadDllInfo;
end;
procedure TLibrary.Run;
begin
@FRun:= GetProcAddress(DllHandle,'DllRun');
if @FRun = nil then
Begin
LAST_ERROR:= ERROR_DLL_FUNC_NOTFOUND;
exit;
End;
FRun;
FActivate:= true;
end;
procedure TLibrary.Terminate;
begin
@FTerminate:= GetProcAddress(DllHandle,'DllTerminate');
if @FTerminate = nil then
Begin
LAST_ERROR:= ERROR_DLL_FUNC_NOTFOUND;
exit;
End;
FTerminate;
FActivate:= false;
end;
Begin
end.
|
{ Copyright (C) 1998-2018, written by Shkolnik Mike, Scalabium
E-Mail: mshkolnik@scalabium.com
mshkolnik@yahoo.com
WEB: http://www.scalabium.com
Dataware TEditTyped component
}
unit EditTypeDB;
interface
{$I SMVersion.inc}
uses
Windows, Messages, Classes, Controls, DBCtrls, DB, EditType
{$IFDEF SMForDelphi6} , MaskUtils {$ENDIF}
;
type
{$IFDEF SM_ADD_ComponentPlatformsAttribute}
[ComponentPlatformsAttribute(pidWin32 or pidWin64)]
{$ENDIF}
TDBEditTyped = class(TEditTyped)
private
{ Private declarations }
FDataLink: TFieldDataLink;
FCanvas: TControlCanvas;
FFocused: Boolean;
procedure DataChange(Sender: TObject);
procedure EditingChange(Sender: TObject);
function GetDataField: string;
function GetDataSource: TDataSource;
function GetField: TField;
procedure SetDataField(const Value: string);
procedure SetDataSource(Value: TDataSource);
procedure SetFocused(Value: Boolean);
procedure SetReadOnly(Value: Boolean);
procedure UpdateData(Sender: TObject);
procedure WMCut(var Message: TMessage); message WM_CUT;
procedure WMPaste(var Message: TMessage); message WM_PASTE;
procedure CMEnter(var Message: TCMEnter); message CM_ENTER;
procedure CMExit(var Message: TCMExit); message CM_EXIT;
procedure CMGetDataLink(var Message: TMessage); message CM_GETDATALINK;
protected
{ Protected declarations }
procedure Change; override;
function EditCanModify: Boolean; override;
function GetReadOnly: Boolean;
procedure KeyDown(var Key: Word; Shift: TShiftState); override;
procedure KeyPress(var Key: Char); override;
procedure Loaded; override;
procedure Notification(AComponent: TComponent;
Operation: TOperation); override;
procedure Reset; override;
public
{ Public declarations }
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
property Button;
property Field: TField read GetField;
published
{ Published declarations }
property DataField: string read GetDataField write SetDataField;
property DataSource: TDataSource read GetDataSource write SetDataSource;
property ReadOnly: Boolean read GetReadOnly write SetReadOnly default False;
end;
procedure Register;
implementation
uses SysUtils, Mask;
procedure Register;
begin
RegisterComponents('SMComponents', [TDBEditTyped]);
end;
procedure ResetMaxLength(DBEdit: TDBEditTyped);
var
fld: TField;
begin
with DBEdit do
if (MaxLength > 0) and
Assigned(DataSource) and
Assigned(DataSource.DataSet) then
begin
fld := DataSource.DataSet.FindField(DataField);
if Assigned(fld) and
(fld.DataType = ftString) and
(fld.Size = MaxLength) then
MaxLength := 0;
end;
end;
{ TDBEditTyped }
constructor TDBEditTyped.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
ControlStyle := ControlStyle + [csReplicatable];
inherited ReadOnly := True;
FDataLink := TFieldDataLink.Create;
FDataLink.Control := Self;
FDataLink.OnDataChange := DataChange;
FDataLink.OnEditingChange := EditingChange;
FDataLink.OnUpdateData := UpdateData;
end;
destructor TDBEditTyped.Destroy;
begin
FDataLink.Free;
FDataLink := nil;
FCanvas.Free;
inherited Destroy;
end;
procedure TDBEditTyped.Loaded;
begin
inherited Loaded;
ResetMaxLength(Self);
if (csDesigning in ComponentState) then DataChange(Self);
end;
procedure TDBEditTyped.Notification(AComponent: TComponent;
Operation: TOperation);
begin
inherited Notification(AComponent, Operation);
if (Operation = opRemove) and (FDataLink <> nil) and
(AComponent = DataSource) then DataSource := nil;
end;
procedure TDBEditTyped.KeyDown(var Key: Word; Shift: TShiftState);
begin
inherited KeyDown(Key, Shift);
if (Key = VK_DELETE) or ((Key = VK_INSERT) and (ssShift in Shift)) then
FDataLink.Edit;
end;
procedure TDBEditTyped.KeyPress(var Key: Char);
begin
inherited KeyPress(Key);
if {$IFDEF SMForDelphi2009}CharInSet{$ENDIF}(Key {$IFDEF SMForDelphi2009},{$ELSE} in {$ENDIF}[#32..#255]) and
(FDataLink.Field <> nil) and
not FDataLink.Field.IsValidChar(Key) then
begin
Key := #0;
end;
case Key of
^H, ^V, ^X, #32..#255:
FDataLink.Edit;
#27:
begin
FDataLink.Reset;
SelectAll;
Key := #0;
end;
end;
end;
function TDBEditTyped.EditCanModify: Boolean;
begin
Result := FDataLink.Edit;
end;
procedure TDBEditTyped.Reset;
begin
FDataLink.Reset;
SelectAll;
end;
procedure TDBEditTyped.SetFocused(Value: Boolean);
begin
if FFocused <> Value then
begin
FFocused := Value;
if (Alignment <> taLeftJustify) and not IsMasked then Invalidate;
FDataLink.Reset;
end;
end;
procedure TDBEditTyped.Change;
begin
FDataLink.Modified;
inherited Change;
end;
function TDBEditTyped.GetDataSource: TDataSource;
begin
Result := FDataLink.DataSource;
end;
procedure TDBEditTyped.SetDataSource(Value: TDataSource);
begin
FDataLink.DataSource := Value;
if Value <> nil then Value.FreeNotification(Self);
end;
function TDBEditTyped.GetDataField: string;
begin
Result := FDataLink.FieldName;
end;
procedure TDBEditTyped.SetDataField(const Value: string);
begin
if not (csDesigning in ComponentState) then ResetMaxLength(Self);
FDataLink.FieldName := Value;
end;
function TDBEditTyped.GetReadOnly: Boolean;
begin
Result := FDataLink.ReadOnly;
end;
procedure TDBEditTyped.SetReadOnly(Value: Boolean);
begin
FDataLink.ReadOnly := Value;
end;
function TDBEditTyped.GetField: TField;
begin
Result := FDataLink.Field;
end;
procedure TDBEditTyped.DataChange(Sender: TObject);
begin
if FDataLink.Field <> nil then
begin
if Alignment <> FDataLink.Field.Alignment then
begin
EditText := ''; {forces update}
Alignment := FDataLink.Field.Alignment;
end;
if (FDataLink.Field.EditMask <> '') then
EditMask := FDataLink.Field.EditMask;
if not (csDesigning in ComponentState) then
begin
if (FDataLink.Field.DataType = ftString) and (MaxLength = 0) then
MaxLength := FDataLink.Field.Size;
end;
if FFocused and FDataLink.CanModify then
Text := FDataLink.Field.Text
else
begin
if (EditMask = '') then
EditText := FDataLink.Field.DisplayText
else
EditText := FormatMaskText(EditMask, FDataLink.Field.DisplayText);
{if FDataLink.Editing then Modified := True;}
end;
end
else
begin
Alignment := taLeftJustify;
EditMask := '';
if csDesigning in ComponentState then
EditText := Name
else
EditText := '';
end;
end;
procedure TDBEditTyped.EditingChange(Sender: TObject);
begin
inherited ReadOnly := not FDataLink.Editing;
end;
procedure TDBEditTyped.UpdateData(Sender: TObject);
begin
ValidateEdit;
{ if (FDataLink.Field.EditMask <> '') then
FDataLink.Field.Text := Text
else
FDataLink.Field.Text := EditText;
} FDataLink.Field.Value := Value
end;
procedure TDBEditTyped.WMPaste(var Message: TMessage);
begin
FDataLink.Edit;
inherited;
end;
procedure TDBEditTyped.WMCut(var Message: TMessage);
begin
FDataLink.Edit;
inherited;
end;
procedure TDBEditTyped.CMEnter(var Message: TCMEnter);
begin
SetFocused(True);
inherited;
if SysLocale.FarEast and FDataLink.CanModify then
inherited ReadOnly := False;
end;
procedure TDBEditTyped.CMExit(var Message: TCMExit);
begin
try
FDataLink.UpdateRecord;
except
SelectAll;
if CanFocus then SetFocus;
raise;
end;
SetFocused(False);
CheckCursor;
DoExit;
end;
procedure TDBEditTyped.CMGetDataLink(var Message: TMessage);
begin
Message.Result := Integer(FDataLink);
end;
end.
|
unit CRCUnit;
{ CRC Unit }
// Cyclic Redundancy Check Algorithms : CRC32
// Copyright (c) 2015 ChrisF
// Distributed under the terms of the MIT license: see LICENSE.txt
{$IFDEF FPC}
{$MODE OBJFPC}{$H+}
// {$MODE DELPHI}
{$ENDIF}
//------------------------------------------------------------------------------
interface
{$DEFINE COMPCRCTABLES1} // Dynamically Compute CRC Tables (Instead of Static CRC Tables)
function CRC32_BE_Update(Const Data: array of Byte; Const DataLen: Longword; Const InitValue: Longword; Const XorMode: Integer): Longword;
function CRC32_LE_Update(Const Data: array of Byte; Const DataLen: Longword; Const InitValue: Longword; Const XorMode: Integer): Longword;
function CRC32(Const Data: array of Byte; Const DataLen: Longword): Longword;
//------------------------------------------------------------------------------
implementation
{$IFDEF COMPCRCTABLES}
const
CRC32_BE_POLY = $04C11DB7; // Polynomial Value To Compute CRC32 Table (Big Endian Version)
CRC32_LE_POLY = $EDB88320; // Polynomial Value To Compute CRC32 Table (Little Endian Version)
procedure CompCRC32_BE_TABLE(); forward;
procedure CompCRC32_LE_TABLE(); forward;
var
CRC32_BE_TABLE: array [0..Pred(256)] of Longword; // CRC32 Table (Big Endian Version)
CRC32_LE_TABLE: array [0..Pred(256)] of Longword; // CRC32 Table (Little Endian Version)
HasCRC32_BE_TABLE: Longbool = False; // CRC32_BE_TABLE Computed
HasCRC32_LE_TABLE: Longbool = False; // CRC32_LE_TABLE Computed
{$ELSE}
const
CRC32_BE_TABLE: array [0..Pred(256)] of Longword = ( // CRC32 Table (Big Endian Version)
$00000000, $04C11DB7, $09823B6E, $0D4326D9, $130476DC, $17C56B6B, $1A864DB2, $1E475005,
$2608EDB8, $22C9F00F, $2F8AD6D6, $2B4BCB61, $350C9B64, $31CD86D3, $3C8EA00A, $384FBDBD,
$4C11DB70, $48D0C6C7, $4593E01E, $4152FDA9, $5F15ADAC, $5BD4B01B, $569796C2, $52568B75,
$6A1936C8, $6ED82B7F, $639B0DA6, $675A1011, $791D4014, $7DDC5DA3, $709F7B7A, $745E66CD,
$9823B6E0, $9CE2AB57, $91A18D8E, $95609039, $8B27C03C, $8FE6DD8B, $82A5FB52, $8664E6E5,
$BE2B5B58, $BAEA46EF, $B7A96036, $B3687D81, $AD2F2D84, $A9EE3033, $A4AD16EA, $A06C0B5D,
$D4326D90, $D0F37027, $DDB056FE, $D9714B49, $C7361B4C, $C3F706FB, $CEB42022, $CA753D95,
$F23A8028, $F6FB9D9F, $FBB8BB46, $FF79A6F1, $E13EF6F4, $E5FFEB43, $E8BCCD9A, $EC7DD02D,
$34867077, $30476DC0, $3D044B19, $39C556AE, $278206AB, $23431B1C, $2E003DC5, $2AC12072,
$128E9DCF, $164F8078, $1B0CA6A1, $1FCDBB16, $018AEB13, $054BF6A4, $0808D07D, $0CC9CDCA,
$7897AB07, $7C56B6B0, $71159069, $75D48DDE, $6B93DDDB, $6F52C06C, $6211E6B5, $66D0FB02,
$5E9F46BF, $5A5E5B08, $571D7DD1, $53DC6066, $4D9B3063, $495A2DD4, $44190B0D, $40D816BA,
$ACA5C697, $A864DB20, $A527FDF9, $A1E6E04E, $BFA1B04B, $BB60ADFC, $B6238B25, $B2E29692,
$8AAD2B2F, $8E6C3698, $832F1041, $87EE0DF6, $99A95DF3, $9D684044, $902B669D, $94EA7B2A,
$E0B41DE7, $E4750050, $E9362689, $EDF73B3E, $F3B06B3B, $F771768C, $FA325055, $FEF34DE2,
$C6BCF05F, $C27DEDE8, $CF3ECB31, $CBFFD686, $D5B88683, $D1799B34, $DC3ABDED, $D8FBA05A,
$690CE0EE, $6DCDFD59, $608EDB80, $644FC637, $7A089632, $7EC98B85, $738AAD5C, $774BB0EB,
$4F040D56, $4BC510E1, $46863638, $42472B8F, $5C007B8A, $58C1663D, $558240E4, $51435D53,
$251D3B9E, $21DC2629, $2C9F00F0, $285E1D47, $36194D42, $32D850F5, $3F9B762C, $3B5A6B9B,
$0315D626, $07D4CB91, $0A97ED48, $0E56F0FF, $1011A0FA, $14D0BD4D, $19939B94, $1D528623,
$F12F560E, $F5EE4BB9, $F8AD6D60, $FC6C70D7, $E22B20D2, $E6EA3D65, $EBA91BBC, $EF68060B,
$D727BBB6, $D3E6A601, $DEA580D8, $DA649D6F, $C423CD6A, $C0E2D0DD, $CDA1F604, $C960EBB3,
$BD3E8D7E, $B9FF90C9, $B4BCB610, $B07DABA7, $AE3AFBA2, $AAFBE615, $A7B8C0CC, $A379DD7B,
$9B3660C6, $9FF77D71, $92B45BA8, $9675461F, $8832161A, $8CF30BAD, $81B02D74, $857130C3,
$5D8A9099, $594B8D2E, $5408ABF7, $50C9B640, $4E8EE645, $4A4FFBF2, $470CDD2B, $43CDC09C,
$7B827D21, $7F436096, $7200464F, $76C15BF8, $68860BFD, $6C47164A, $61043093, $65C52D24,
$119B4BE9, $155A565E, $18197087, $1CD86D30, $029F3D35, $065E2082, $0B1D065B, $0FDC1BEC,
$3793A651, $3352BBE6, $3E119D3F, $3AD08088, $2497D08D, $2056CD3A, $2D15EBE3, $29D4F654,
$C5A92679, $C1683BCE, $CC2B1D17, $C8EA00A0, $D6AD50A5, $D26C4D12, $DF2F6BCB, $DBEE767C,
$E3A1CBC1, $E760D676, $EA23F0AF, $EEE2ED18, $F0A5BD1D, $F464A0AA, $F9278673, $FDE69BC4,
$89B8FD09, $8D79E0BE, $803AC667, $84FBDBD0, $9ABC8BD5, $9E7D9662, $933EB0BB, $97FFAD0C,
$AFB010B1, $AB710D06, $A6322BDF, $A2F33668, $BCB4666D, $B8757BDA, $B5365D03, $B1F740B4 );
CRC32_LE_TABLE: array [0..Pred(256)] of Longword = ( // CRC32 Table (Little Endian Version)
$00000000, $77073096, $EE0E612C, $990951BA, $076DC419, $706AF48F, $E963A535, $9E6495A3,
$0EDB8832, $79DCB8A4, $E0D5E91E, $97D2D988, $09B64C2B, $7EB17CBD, $E7B82D07, $90BF1D91,
$1DB71064, $6AB020F2, $F3B97148, $84BE41DE, $1ADAD47D, $6DDDE4EB, $F4D4B551, $83D385C7,
$136C9856, $646BA8C0, $FD62F97A, $8A65C9EC, $14015C4F, $63066CD9, $FA0F3D63, $8D080DF5,
$3B6E20C8, $4C69105E, $D56041E4, $A2677172, $3C03E4D1, $4B04D447, $D20D85FD, $A50AB56B,
$35B5A8FA, $42B2986C, $DBBBC9D6, $ACBCF940, $32D86CE3, $45DF5C75, $DCD60DCF, $ABD13D59,
$26D930AC, $51DE003A, $C8D75180, $BFD06116, $21B4F4B5, $56B3C423, $CFBA9599, $B8BDA50F,
$2802B89E, $5F058808, $C60CD9B2, $B10BE924, $2F6F7C87, $58684C11, $C1611DAB, $B6662D3D,
$76DC4190, $01DB7106, $98D220BC, $EFD5102A, $71B18589, $06B6B51F, $9FBFE4A5, $E8B8D433,
$7807C9A2, $0F00F934, $9609A88E, $E10E9818, $7F6A0DBB, $086D3D2D, $91646C97, $E6635C01,
$6B6B51F4, $1C6C6162, $856530D8, $F262004E, $6C0695ED, $1B01A57B, $8208F4C1, $F50FC457,
$65B0D9C6, $12B7E950, $8BBEB8EA, $FCB9887C, $62DD1DDF, $15DA2D49, $8CD37CF3, $FBD44C65,
$4DB26158, $3AB551CE, $A3BC0074, $D4BB30E2, $4ADFA541, $3DD895D7, $A4D1C46D, $D3D6F4FB,
$4369E96A, $346ED9FC, $AD678846, $DA60B8D0, $44042D73, $33031DE5, $AA0A4C5F, $DD0D7CC9,
$5005713C, $270241AA, $BE0B1010, $C90C2086, $5768B525, $206F85B3, $B966D409, $CE61E49F,
$5EDEF90E, $29D9C998, $B0D09822, $C7D7A8B4, $59B33D17, $2EB40D81, $B7BD5C3B, $C0BA6CAD,
$EDB88320, $9ABFB3B6, $03B6E20C, $74B1D29A, $EAD54739, $9DD277AF, $04DB2615, $73DC1683,
$E3630B12, $94643B84, $0D6D6A3E, $7A6A5AA8, $E40ECF0B, $9309FF9D, $0A00AE27, $7D079EB1,
$F00F9344, $8708A3D2, $1E01F268, $6906C2FE, $F762575D, $806567CB, $196C3671, $6E6B06E7,
$FED41B76, $89D32BE0, $10DA7A5A, $67DD4ACC, $F9B9DF6F, $8EBEEFF9, $17B7BE43, $60B08ED5,
$D6D6A3E8, $A1D1937E, $38D8C2C4, $4FDFF252, $D1BB67F1, $A6BC5767, $3FB506DD, $48B2364B,
$D80D2BDA, $AF0A1B4C, $36034AF6, $41047A60, $DF60EFC3, $A867DF55, $316E8EEF, $4669BE79,
$CB61B38C, $BC66831A, $256FD2A0, $5268E236, $CC0C7795, $BB0B4703, $220216B9, $5505262F,
$C5BA3BBE, $B2BD0B28, $2BB45A92, $5CB36A04, $C2D7FFA7, $B5D0CF31, $2CD99E8B, $5BDEAE1D,
$9B64C2B0, $EC63F226, $756AA39C, $026D930A, $9C0906A9, $EB0E363F, $72076785, $05005713,
$95BF4A82, $E2B87A14, $7BB12BAE, $0CB61B38, $92D28E9B, $E5D5BE0D, $7CDCEFB7, $0BDBDF21,
$86D3D2D4, $F1D4E242, $68DDB3F8, $1FDA836E, $81BE16CD, $F6B9265B, $6FB077E1, $18B74777,
$88085AE6, $FF0F6A70, $66063BCA, $11010B5C, $8F659EFF, $F862AE69, $616BFFD3, $166CCF45,
$A00AE278, $D70DD2EE, $4E048354, $3903B3C2, $A7672661, $D06016F7, $4969474D, $3E6E77DB,
$AED16A4A, $D9D65ADC, $40DF0B66, $37D83BF0, $A9BCAE53, $DEBB9EC5, $47B2CF7F, $30B5FFE9,
$BDBDF21C, $CABAC28A, $53B39330, $24B4A3A6, $BAD03605, $CDD70693, $54DE5729, $23D967BF,
$B3667A2E, $C4614AB8, $5D681B02, $2A6F2B94, $B40BBE37, $C30C8EA1, $5A05DF1B, $2D02EF8D );
{$ENDIF}
//------------------------------------------------------------------------------
{$IFDEF COMPCRCTABLES}
//
// Compute CRC32 Table (Big Endian Version)
//
procedure CompCRC32_BE_TABLE();
var i1,i2: Integer;
var j1: Longword;
begin
for i1:=0 to Pred(256) do
begin
j1:=i1 shl 24;
for i2:=Pred(8) downto 0 do
if (j1 and $80000000)<>0 then
j1:=(j1 shl 1) xor CRC32_BE_POLY
else
j1:=j1 shl 1;
CRC32_BE_TABLE[i1]:=j1;
end;
HasCRC32_BE_TABLE:=True;
end;
//
// Compute CRC32 Table (Little Endian Version)
//
procedure CompCRC32_LE_TABLE();
var i1,i2: Integer;
var j1: Longword;
begin
for i1:=0 to Pred(256) do
begin
j1:=i1;
for i2:=0 to Pred(8) do
if (j1 and 1)<>0 then
j1:=CRC32_LE_POLY xor (j1 shr 1)
else
j1:=j1 shr 1;
CRC32_LE_TABLE[i1]:=j1;
end;
HasCRC32_LE_TABLE:=True;
end;
{$ENDIF}
//
// Full Standard Big Endian CRC32 Algorithm : Limited to (2^32)-1 Bytes per Call
// XORMode: 0=None, 1=Initial, 2=Final, 1+2=Both
//
function CRC32_BE_Update(Const Data: array of Byte; Const DataLen: Longword; Const InitValue: Longword; Const XorMode: Integer): Longword;
var i1: Longword;
var j1: Longword;
begin
{$IFDEF COMPCRCTABLES}
if (not HasCRC32_BE_TABLE) then CompCRC32_BE_TABLE();
{$ENDIF}
j1:=InitValue;
if (XorMode and 1)<>0 then j1:=(not j1);
if DataLen>0 then
for i1:=0 to Pred(DataLen) do
j1:=(j1 shl 8) xor CRC32_BE_TABLE[((j1 shr 24) xor Data[i1]) and $FF];
if (XorMode and 2)<>0 then j1:=(not j1);
CRC32_BE_Update:=j1;
end;
//
// Full Standard Little Endian CRC32 Algorithm : Limited to (2^32)-1 Bytes per Call
// XORMode: 0=None, 1=Initial, 2=Final, 1+2=Both
//
function CRC32_LE_Update(Const Data: array of Byte; Const DataLen: Longword; Const InitValue: Longword; Const XorMode: Integer): Longword;
var i1: Longword;
var j1: Longword;
begin
{$IFDEF COMPCRCTABLES}
if (not HasCRC32_LE_TABLE) then CompCRC32_LE_TABLE();
{$ENDIF}
j1:=InitValue;
if (XorMode and 1)<>0 then j1:=(not j1);
if DataLen>0 then
for i1:=0 to Pred(DataLen) do
j1:=CRC32_LE_TABLE[(j1 xor Data[i1]) and $FF] xor (j1 shr 8);
if (XorMode and 2)<>0 then j1:=(not j1);
CRC32_LE_Update:=j1;
end;
//
// Standard (Little Endian Version) CRC32 Algorithm : Limited to (2^32)-1 Bytes
//
function CRC32(Const Data: array of Byte; Const DataLen: Longword): Longword;
begin
CRC32:=CRC32_LE_Update(Data,DataLen,0,1+2);
end;
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
/// (Основная часть не_расширений - \api\GL\ )
///
///Спецификации всех версий 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);
end;
GLeglImageOES = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GLeglImageOES read default(GLeglImageOES);
end;
QueryName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: QueryName read default(QueryName);
end;
BufferName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: BufferName read default(BufferName);
end;
ShaderName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: ShaderName read default(ShaderName);
end;
ProgramName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: ProgramName read default(ProgramName);
end;
ProgramPipelineName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: ProgramPipelineName read default(ProgramPipelineName);
end;
TextureName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: TextureName read default(TextureName);
end;
SamplerName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: SamplerName read default(SamplerName);
end;
FramebufferName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: FramebufferName read default(FramebufferName);
end;
RenderbufferName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: RenderbufferName read default(RenderbufferName);
end;
VertexArrayName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: VertexArrayName read default(VertexArrayName);
end;
TransformFeedbackName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: TransformFeedbackName read default(TransformFeedbackName);
end;
GLContext = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: GLContext read default(GLContext);
end;
GDI_DC = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GDI_DC read default(GDI_DC);
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);
end;
///--
cl_event = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: cl_event read default(cl_event);
end;
// INTEL_performance_query
PerfQueryIdINTEL = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: PerfQueryIdINTEL read default(PerfQueryIdINTEL);
end;
PerfQueryHandleINTEL = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: PerfQueryHandleINTEL read default(PerfQueryHandleINTEL);
end;
//ToDo переименовать и проверить типы всего дальше:
EGLsync = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: EGLsync read default(EGLsync);
end;
EGLDisplay = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: EGLDisplay read default(EGLDisplay);
end;
ShaderBinaryFormat = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: ShaderBinaryFormat read default(ShaderBinaryFormat);
end;
ProgramResourceIndex = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: ProgramResourceIndex read default(ProgramResourceIndex);
end;
ProgramBinaryFormat = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: ProgramBinaryFormat read default(ProgramBinaryFormat);
end;
GLhandleARB = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: GLhandleARB read default(GLhandleARB);
end;
PBufferName = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: PBufferName read default(PBufferName);
end;
HPVIDEODEV = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: HPVIDEODEV read default(HPVIDEODEV);
end;
HVIDEOOUTPUTDEVICENV = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: HVIDEOOUTPUTDEVICENV read default(HVIDEOOUTPUTDEVICENV);
end;
HVIDEOINPUTDEVICENV = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: HVIDEOINPUTDEVICENV read default(HVIDEOINPUTDEVICENV);
end;
PGPU_DEVICE = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: PGPU_DEVICE read default(PGPU_DEVICE);
end;
HGPUNV = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: HGPUNV read default(HGPUNV);
end;
HPBUFFER = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: HPBUFFER read default(HPBUFFER);
end;
GLeglClientBufferEXT = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GLeglClientBufferEXT read default(GLeglClientBufferEXT);
end;
VideoOutputDeviceHandleNV = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: VideoOutputDeviceHandleNV read default(VideoOutputDeviceHandleNV);
end;
VideoInputDeviceHandleNV = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: VideoInputDeviceHandleNV read default(VideoInputDeviceHandleNV);
end;
VideoDeviceHandleNV = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: VideoDeviceHandleNV read default(VideoDeviceHandleNV);
end;
GLvdpauSurfaceNV = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GLvdpauSurfaceNV read default(GLvdpauSurfaceNV);
end;
GPUAffinityHandle = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GPUAffinityHandle read default(GPUAffinityHandle);
end;
GLXFBConfig = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GLXFBConfig read default(GLXFBConfig);
end;
GLXContextID = record
public val: UInt64;
public constructor(val: UInt64) := self.val := val;
public static property Zero: GLXContextID read default(GLXContextID);
end;
GLXPbuffer = record
public val: UInt64;
public constructor(val: UInt64) := self.val := val;
public static property Zero: GLXPbuffer read default(GLXPbuffer);
end;
GLXWindow = record
public val: UInt64;
public constructor(val: UInt64) := self.val := val;
public static property Zero: GLXWindow read default(GLXWindow);
end;
GLXPixmap = record
public val: UInt64;
public constructor(val: UInt64) := self.val := val;
public static property Zero: GLXPixmap read default(GLXPixmap);
end;
GLXColormap = record
public val: UInt64;
public constructor(val: UInt64) := self.val := val;
public static property Zero: GLXColormap read default(GLXColormap);
end;
GLXDrawable = record
public val: UInt64;
public constructor(val: UInt64) := self.val := val;
public static property Zero: GLXDrawable read default(GLXDrawable);
end;
GLXContext = record
public val: UInt64;
public constructor(val: UInt64) := self.val := val;
public static property Zero: GLXContext read default(GLXContext);
end;
GLXVideoCaptureDeviceNV = record
public val: UInt64;
public constructor(val: UInt64) := self.val := val;
public static property Zero: GLXVideoCaptureDeviceNV read default(GLXVideoCaptureDeviceNV);
end;
GLXVideoSourceSGIX = record
public val: UInt64;
public constructor(val: UInt64) := self.val := val;
public static property Zero: GLXVideoSourceSGIX read default(GLXVideoSourceSGIX);
end;
GLXVideoDeviceNV = record
public val: UInt32;
public constructor(val: UInt32) := self.val := val;
public static property Zero: GLXVideoDeviceNV read default(GLXVideoDeviceNV);
end;
GLXFuncPtr = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GLXFuncPtr read default(GLXFuncPtr);
end;
PDisplay = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: PDisplay read default(PDisplay);
end;
PXVisualInfo = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: PXVisualInfo read default(PXVisualInfo);
end;
//ToDo эти типы вообще угадывал, перепроверить
GLXDMparams = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GLXDMparams read default(GLXDMparams);
end;
GLXDMbuffer = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GLXDMbuffer read default(GLXDMbuffer);
end;
GLXVLServer = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GLXVLServer read default(GLXVLServer);
end;
GLXVLPath = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GLXVLPath read default(GLXVLPath);
end;
GLXVLNode = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GLXVLNode read default(GLXVLNode);
end;
GLXStatus = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GLXStatus read default(GLXStatus);
end;
GLUnurbs = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GLUnurbs read default(GLUnurbs);
end;
GDI_HENHMetafile = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GDI_HENHMetafile read default(GDI_HENHMetafile);
end;
GDI_LayerPlaneDescriptor = record
public val: IntPtr;
public constructor(val: IntPtr) := self.val := val;
public static property Zero: GDI_LayerPlaneDescriptor read default(GDI_LayerPlaneDescriptor);
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
var res := typeof(AccumOp).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'AccumOp[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(AlphaFunction).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'AlphaFunction[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(AtomicCounterBufferPName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'AtomicCounterBufferPName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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 := typeof(AttribMask).GetProperties.Where(prop->prop.Name.StartsWith('HAS_FLAG_') and boolean(prop.GetValue(self))).Select(prop->prop.Name.TrimStart('&')).ToList;
Result := res.Count=0?
$'AttribMask[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.JoinIntoString('+');
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
var res := typeof(AttributeType).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'AttributeType[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(BindTransformFeedbackTarget).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'BindTransformFeedbackTarget[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(BlendingFactor).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'BlendingFactor[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(BlitFramebufferFilter).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'BlitFramebufferFilter[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(Buffer).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'Buffer[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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 := typeof(BufferStorageMask).GetProperties.Where(prop->prop.Name.StartsWith('HAS_FLAG_') and boolean(prop.GetValue(self))).Select(prop->prop.Name.TrimStart('&')).ToList;
Result := res.Count=0?
$'BufferStorageMask[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.JoinIntoString('+');
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
var res := typeof(BufferStorageTarget).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'BufferStorageTarget[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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 := typeof(ClearBufferMask).GetProperties.Where(prop->prop.Name.StartsWith('HAS_FLAG_') and boolean(prop.GetValue(self))).Select(prop->prop.Name.TrimStart('&')).ToList;
Result := res.Count=0?
$'ClearBufferMask[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.JoinIntoString('+');
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 := typeof(ClientAttribMask).GetProperties.Where(prop->prop.Name.StartsWith('HAS_FLAG_') and boolean(prop.GetValue(self))).Select(prop->prop.Name.TrimStart('&')).ToList;
Result := res.Count=0?
$'ClientAttribMask[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.JoinIntoString('+');
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
var res := typeof(ClipControlDepth).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ClipControlDepth[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ClipControlOrigin).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ClipControlOrigin[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ClipPlaneName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ClipPlaneName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ColorBuffer).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ColorBuffer[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ColorMaterialParameter).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ColorMaterialParameter[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ColorPointerType).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ColorPointerType[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ColorTableTarget).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ColorTableTarget[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ConditionalRenderMode).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ConditionalRenderMode[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ConvolutionTarget).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ConvolutionTarget[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(CopyBufferSubDataTarget).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'CopyBufferSubDataTarget[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(CopyImageSubDataTarget).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'CopyImageSubDataTarget[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(CullFaceMode).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'CullFaceMode[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(DebugSeverity).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'DebugSeverity[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(DebugSource).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'DebugSource[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(DebugType).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'DebugType[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(DepthFunction).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'DepthFunction[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(DrawBufferMode).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'DrawBufferMode[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(DrawElementsType).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'DrawElementsType[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(EnableCap).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'EnableCap[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ErrorCode).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ErrorCode[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ExternalHandleType).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ExternalHandleType[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(FeedbackType).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'FeedbackType[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(FogCoordinatePointerType).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'FogCoordinatePointerType[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(FogParameter).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'FogParameter[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(FogPName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'FogPName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(FramebufferAttachment).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'FramebufferAttachment[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(FramebufferAttachmentParameterName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'FramebufferAttachmentParameterName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(FramebufferParameterName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'FramebufferParameterName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(FramebufferStatus).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'FramebufferStatus[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(FramebufferTarget).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'FramebufferTarget[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(FrontFaceDirection).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'FrontFaceDirection[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(GetFramebufferParameter).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'GetFramebufferParameter[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(GetMapQuery).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'GetMapQuery[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(GetPName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'GetPName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(GetPointervPName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'GetPointervPName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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);
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 function ToString: string; override;
begin
var res := typeof(GetTextureParameter).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'GetTextureParameter[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(GlslTypeToken).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'GlslTypeToken[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(GraphicsResetStatus).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'GraphicsResetStatus[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(HintMode).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'HintMode[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(HintTarget).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'HintTarget[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(IndexPointerType).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'IndexPointerType[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(InterleavedArrayFormat).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'InterleavedArrayFormat[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(InternalFormat).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'InternalFormat[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(InternalFormatPName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'InternalFormatPName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(InvalidateFramebufferAttachment).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'InvalidateFramebufferAttachment[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(LightModelParameter).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'LightModelParameter[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(LightName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'LightName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(LightParameter).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'LightParameter[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ListMode).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ListMode[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ListNameType).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ListNameType[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ListParameterName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ListParameterName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(LogicOp).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'LogicOp[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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 := typeof(MapBufferAccessMask).GetProperties.Where(prop->prop.Name.StartsWith('HAS_FLAG_') and boolean(prop.GetValue(self))).Select(prop->prop.Name.TrimStart('&')).ToList;
Result := res.Count=0?
$'MapBufferAccessMask[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.JoinIntoString('+');
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
var res := typeof(MapQuery).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'MapQuery[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(MapTarget).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'MapTarget[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(MaterialParameter).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'MaterialParameter[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(MatrixMode).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'MatrixMode[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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 := typeof(MemoryBarrierMask).GetProperties.Where(prop->prop.Name.StartsWith('HAS_FLAG_') and boolean(prop.GetValue(self))).Select(prop->prop.Name.TrimStart('&')).ToList;
Result := res.Count=0?
$'MemoryBarrierMask[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.JoinIntoString('+');
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
var res := typeof(MemoryObjectParameterName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'MemoryObjectParameterName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(MeshMode1).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'MeshMode1[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(MeshMode2).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'MeshMode2[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(NormalPointerType).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'NormalPointerType[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ObjectIdentifier).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ObjectIdentifier[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PatchParameterName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PatchParameterName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PathColor).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PathColor[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PathColorFormat).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PathColorFormat[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PathCoordType).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PathCoordType[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PathCoverMode).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PathCoverMode[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PathElementType).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PathElementType[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PathFillMode).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PathFillMode[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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 := typeof(PathFontStyle).GetProperties.Where(prop->prop.Name.StartsWith('HAS_FLAG_') and boolean(prop.GetValue(self))).Select(prop->prop.Name.TrimStart('&')).ToList;
Result := res.Count=0?
$'PathFontStyle[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.JoinIntoString('+');
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
var res := typeof(PathFontTarget).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PathFontTarget[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PathGenMode).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PathGenMode[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PathHandleMissingGlyphs).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PathHandleMissingGlyphs[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PathListMode).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PathListMode[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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 := typeof(PathMetricMask).GetProperties.Where(prop->prop.Name.StartsWith('HAS_FLAG_') and boolean(prop.GetValue(self))).Select(prop->prop.Name.TrimStart('&')).ToList;
Result := res.Count=0?
$'PathMetricMask[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.JoinIntoString('+');
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
var res := typeof(PathParameter).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PathParameter[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PathStringFormat).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PathStringFormat[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PathTransformType).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PathTransformType[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PipelineParameterName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PipelineParameterName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PixelCopyType).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PixelCopyType[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PixelFormat).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PixelFormat[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PixelMap).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PixelMap[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PixelStoreParameter).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PixelStoreParameter[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PixelTransferParameter).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PixelTransferParameter[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PixelType).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PixelType[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PolygonMode).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PolygonMode[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PrecisionType).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PrecisionType[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PrimitiveType).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PrimitiveType[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ProgramFormat).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ProgramFormat[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ProgramInterface).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ProgramInterface[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ProgramInterfacePName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ProgramInterfacePName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ProgramParameterPName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ProgramParameterPName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ProgramResourceProperty).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ProgramResourceProperty[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ProgramStagePName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ProgramStagePName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ProgramStringProperty).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ProgramStringProperty[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ProgramTarget).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ProgramTarget[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(QueryCounterTarget).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'QueryCounterTarget[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(QueryObjectParameterName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'QueryObjectParameterName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(QueryParameterName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'QueryParameterName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(QueryTarget).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'QueryTarget[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ReadBufferMode).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ReadBufferMode[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(RenderbufferParameterName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'RenderbufferParameterName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(RenderbufferTarget).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'RenderbufferTarget[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(RenderingMode).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'RenderingMode[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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);
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 function ToString: string; override;
begin
var res := typeof(SamplerParameterF).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'SamplerParameterF[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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);
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 function ToString: string; override;
begin
var res := typeof(SamplerParameterI).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'SamplerParameterI[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ScalarType).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ScalarType[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(SemaphoreParameterName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'SemaphoreParameterName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ShaderParameterName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ShaderParameterName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ShaderType).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ShaderType[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ShadingModel).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ShadingModel[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(StencilFaceDirection).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'StencilFaceDirection[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(StencilFunction).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'StencilFunction[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(StencilOp).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'StencilOp[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(StringName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'StringName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(SubroutineParameterName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'SubroutineParameterName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(SyncCondition).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'SyncCondition[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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 := typeof(SyncObjectMask).GetProperties.Where(prop->prop.Name.StartsWith('HAS_FLAG_') and boolean(prop.GetValue(self))).Select(prop->prop.Name.TrimStart('&')).ToList;
Result := res.Count=0?
$'SyncObjectMask[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.JoinIntoString('+');
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
var res := typeof(SyncParameterName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'SyncParameterName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(SyncStatus).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'SyncStatus[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(TexCoordPointerType).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'TexCoordPointerType[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(TextureCoordName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'TextureCoordName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(TextureEnvParameter).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'TextureEnvParameter[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(TextureEnvTarget).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'TextureEnvTarget[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(TextureGenParameter).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'TextureGenParameter[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(TextureLayout).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'TextureLayout[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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 _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 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
var res := typeof(TextureParameterName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'TextureParameterName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(TextureTarget).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'TextureTarget[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(TextureUnit).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'TextureUnit[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(TransformFeedbackBufferMode).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'TransformFeedbackBufferMode[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(TransformFeedbackPName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'TransformFeedbackPName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(UniformBlockPName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'UniformBlockPName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(UniformPName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'UniformPName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(UniformType).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'UniformType[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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 := typeof(UseProgramStageMask).GetProperties.Where(prop->prop.Name.StartsWith('HAS_FLAG_') and boolean(prop.GetValue(self))).Select(prop->prop.Name.TrimStart('&')).ToList;
Result := res.Count=0?
$'UseProgramStageMask[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.JoinIntoString('+');
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
var res := typeof(VertexArrayPName).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'VertexArrayPName[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(VertexAttribEnum).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'VertexAttribEnum[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(VertexAttribIType).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'VertexAttribIType[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(VertexAttribLType).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'VertexAttribLType[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(VertexAttribPointerType).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'VertexAttribPointerType[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(VertexAttribType).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'VertexAttribType[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(VertexBufferObjectParameter).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'VertexBufferObjectParameter[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(VertexBufferObjectUsage).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'VertexBufferObjectUsage[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(VertexPointerType).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'VertexPointerType[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(VertexProvokingMode).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'VertexProvokingMode[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(VertexShaderTextureUnitParameter).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'VertexShaderTextureUnitParameter[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(BufferAccessARB).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'BufferAccessARB[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(BufferPNameARB).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'BufferPNameARB[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(BufferPointerNameARB).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'BufferPointerNameARB[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(BufferTargetARB).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'BufferTargetARB[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(BufferUsageARB).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'BufferUsageARB[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ClampColorModeARB).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ClampColorModeARB[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ClampColorTargetARB).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ClampColorTargetARB[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(MatrixIndexPointerTypeARB).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'MatrixIndexPointerTypeARB[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PointParameterNameARB).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PointParameterNameARB[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ProgramPropertyARB).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ProgramPropertyARB[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(VertexAttribPointerPropertyARB).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'VertexAttribPointerPropertyARB[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(VertexAttribPropertyARB).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'VertexAttribPropertyARB[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(WeightPointerTypeARB).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'WeightPointerTypeARB[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(BinormalPointerTypeEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'BinormalPointerTypeEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(BlendEquationModeEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'BlendEquationModeEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ConvolutionParameterEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ConvolutionParameterEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ConvolutionTargetEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ConvolutionTargetEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(CullParameterEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'CullParameterEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(DataTypeEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'DataTypeEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(FogPointerTypeEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'FogPointerTypeEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(GetHistogramParameterPNameEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'GetHistogramParameterPNameEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(GetMinmaxParameterPNameEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'GetMinmaxParameterPNameEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(GetVariantValueEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'GetVariantValueEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(HistogramTargetEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'HistogramTargetEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(IndexFunctionEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'IndexFunctionEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(IndexMaterialParameterEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'IndexMaterialParameterEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(LightTextureModeEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'LightTextureModeEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(LightTexturePNameEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'LightTexturePNameEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(MinmaxTargetEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'MinmaxTargetEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ParameterRangeEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ParameterRangeEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PixelTransformPNameEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PixelTransformPNameEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PixelTransformTargetEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PixelTransformTargetEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(SamplePatternEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'SamplePatternEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(SeparableTargetEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'SeparableTargetEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(TangentPointerTypeEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'TangentPointerTypeEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(TextureNormalModeEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'TextureNormalModeEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(VariantCapEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'VariantCapEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(VertexShaderCoordOutEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'VertexShaderCoordOutEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(VertexShaderOpEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'VertexShaderOpEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(VertexShaderParameterEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'VertexShaderParameterEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(VertexShaderStorageTypeEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'VertexShaderStorageTypeEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(VertexShaderWriteMaskEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'VertexShaderWriteMaskEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(VertexWeightPointerTypeEXT).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'VertexWeightPointerTypeEXT[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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 := typeof(TextureStorageMaskAMD).GetProperties.Where(prop->prop.Name.StartsWith('HAS_FLAG_') and boolean(prop.GetValue(self))).Select(prop->prop.Name.TrimStart('&')).ToList;
Result := res.Count=0?
$'TextureStorageMaskAMD[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.JoinIntoString('+');
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
var res := typeof(ObjectTypeAPPLE).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ObjectTypeAPPLE[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(VertexArrayPNameAPPLE).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'VertexArrayPNameAPPLE[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ArrayObjectPNameATI).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ArrayObjectPNameATI[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ArrayObjectUsageATI).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ArrayObjectUsageATI[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ElementPointerTypeATI).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ElementPointerTypeATI[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(FragmentOpATI).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'FragmentOpATI[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(GetTexBumpParameterATI).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'GetTexBumpParameterATI[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PNTrianglesPNameATI).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PNTrianglesPNameATI[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PreserveModeATI).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PreserveModeATI[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(SwizzleOpATI).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'SwizzleOpATI[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(VertexStreamATI).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'VertexStreamATI[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PixelDataTypeGDI).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PixelDataTypeGDI[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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 := typeof(PixelFormatFlagsGDI).GetProperties.Where(prop->prop.Name.StartsWith('HAS_FLAG_') and boolean(prop.GetValue(self))).Select(prop->prop.Name.TrimStart('&')).ToList;
Result := res.Count=0?
$'PixelFormatFlagsGDI[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.JoinIntoString('+');
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
var res := typeof(ImageTransformPNameHP).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ImageTransformPNameHP[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ImageTransformTargetHP).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ImageTransformTargetHP[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(FogPointerTypeIBM).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'FogPointerTypeIBM[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(SecondaryColorPointerTypeIBM).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'SecondaryColorPointerTypeIBM[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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 := typeof(PerfQueryCapFlagsINTEL).GetProperties.Where(prop->prop.Name.StartsWith('HAS_FLAG_') and boolean(prop.GetValue(self))).Select(prop->prop.Name.TrimStart('&')).ToList;
Result := res.Count=0?
$'PerfQueryCapFlagsINTEL[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.JoinIntoString('+');
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
var res := typeof(PerfQueryDataFlagsINTEL).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PerfQueryDataFlagsINTEL[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(CombinerBiasNV).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'CombinerBiasNV[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(CombinerComponentUsageNV).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'CombinerComponentUsageNV[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(CombinerMappingNV).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'CombinerMappingNV[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(CombinerParameterNV).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'CombinerParameterNV[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(CombinerPortionNV).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'CombinerPortionNV[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(CombinerRegisterNV).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'CombinerRegisterNV[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(CombinerScaleNV).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'CombinerScaleNV[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(CombinerStageNV).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'CombinerStageNV[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(CombinerVariableNV).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'CombinerVariableNV[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(EvalMapsModeNV).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'EvalMapsModeNV[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(EvalTargetNV).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'EvalTargetNV[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(FenceConditionNV).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'FenceConditionNV[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(FenceParameterNameNV).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'FenceParameterNameNV[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(GetMultisamplePNameNV).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'GetMultisamplePNameNV[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(MapAttribParameterNV).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'MapAttribParameterNV[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(MapParameterNV).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'MapParameterNV[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(MapTypeNV).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'MapTypeNV[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(OcclusionQueryParameterNameNV).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'OcclusionQueryParameterNameNV[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PixelDataRangeTargetNV).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PixelDataRangeTargetNV[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(VertexAttribEnumNV).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'VertexAttribEnumNV[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(HintTargetPGI).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'HintTargetPGI[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
end;
end;
{$endregion PGI}
{$region SGI}
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
var res := typeof(ColorTableTargetSGI).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ColorTableTargetSGI[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(GetColorTableParameterPNameSGI).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'GetColorTableParameterPNameSGI[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PixelTexGenParameterNameSGIS).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PixelTexGenParameterNameSGIS[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(SamplePatternSGIS).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'SamplePatternSGIS[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(TextureFilterSGIS).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'TextureFilterSGIS[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
end;
end;
{$endregion SGIS}
{$region SGIX}
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
var res := typeof(FfdTargetSGIX).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'FfdTargetSGIX[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(FragmentLightModelParameterSGIX).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'FragmentLightModelParameterSGIX[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(FragmentLightNameSGIX).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'FragmentLightNameSGIX[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(FragmentLightParameterSGIX).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'FragmentLightParameterSGIX[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(LightEnvParameterSGIX).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'LightEnvParameterSGIX[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(PixelTexGenModeSGIX).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'PixelTexGenModeSGIX[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(SpriteParameterNameSGIX).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'SpriteParameterNameSGIX[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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
var res := typeof(ReplacementCodeTypeSUN).GetProperties(System.Reflection.BindingFlags.Static or System.Reflection.BindingFlags.Public).FirstOrDefault(prop->UInt32(prop.GetValue(self))=self.val);
Result := res=nil?
$'ReplacementCodeTypeSUN[{ self.val=0 ? ''NONE'' : self.val.ToString(''X'') }]':
res.Name.TrimStart('&');
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}
[StructLayout(LayoutKind.&Explicit)]
IntFloatUnion = record
public [FieldOffset(0)] i: integer;
public [FieldOffset(0)] f: single;
public constructor(i: integer) := self.i := i;
public constructor(f: single) := self.f := f;
end;
[StructLayout(LayoutKind.&Explicit)]
GDI_COLORREF = record
public [FieldOffset(1)] b: byte;
public [FieldOffset(2)] g: byte;
public [FieldOffset(3)] r: byte;
end;
[StructLayout(LayoutKind.&Explicit)]
GPU_Device_Affinity_Info = record
public [FieldOffset(0)] cb: UInt32;
public [FieldOffset(4)] DeviceName: byte;
// ANSI строка на 32 символа (но конец сроки обозначается сиволом #0, поэтому помещается 31)
public [FieldOffset(36)] DeviceString: byte;
// ANSI строка на 128 символов (но конец сроки обозначается сиволом #0, поэтому помещается 127)
public [FieldOffset(164)] Flags: UInt32;
public [FieldOffset(168)] rcVirtualScreen_x1: Int32;
public [FieldOffset(172)] rcVirtualScreen_y1: Int32;
public [FieldOffset(176)] rcVirtualScreen_x2: Int32;
public [FieldOffset(180)] rcVirtualScreen_y2: Int32;
public property SDeviceName: string
read Marshal.PtrToStringAnsi(IntPtr(pointer(@self.DeviceName)))
write
begin
if value.Length > 31 then raise new ArgumentException('Строка не может иметь больше 31 символа');
var HStr := Marshal.StringToHGlobalAnsi(value);
var l: UInt32 := value.Length+1;
System.Buffer.MemoryCopy(pointer(HStr), @self.DeviceName, l,l);
Marshal.FreeHGlobal(HStr);
end;
public property SDeviceString: string
read Marshal.PtrToStringAnsi(IntPtr(pointer(@self.DeviceString)))
write
begin
if value.Length > 127 then raise new ArgumentException('Строка не может иметь больше 127 символов');
var HStr := Marshal.StringToHGlobalAnsi(value);
var l: UInt32 := value.Length+1;
System.Buffer.MemoryCopy(pointer(HStr), @self.DeviceString, l,l);
Marshal.FreeHGlobal(HStr);
end;
end;
[StructLayout(LayoutKind.&Explicit)]
GLXHyperpipeNetworkSGIX = record
public [FieldOffset(0)] pipeName: byte;
// ANSI строка на 80 символа (но конец сроки обозначается сиволом #0, поэтому помещается 79)
public [FieldOffset(80)] networkId: Int32;
public property SPipeName: string
read Marshal.PtrToStringAnsi(IntPtr(pointer(@self.pipeName)))
write
begin
if value.Length > 79 then raise new ArgumentException('Строка не может иметь больше 79 символов');
var HStr := Marshal.StringToHGlobalAnsi(value);
var l: UInt32 := value.Length+1;
System.Buffer.MemoryCopy(pointer(HStr), @self.pipeName, l,l);
Marshal.FreeHGlobal(HStr);
end;
end;
[StructLayout(LayoutKind.&Explicit)]
GLXHyperpipeConfigDataSGIX = record
public [FieldOffset(0)] pipeName: byte;
// ANSI строка на 80 символа (но конец сроки обозначается сиволом #0, поэтому помещается 79)
public [FieldOffset(80)] channel: Int32;
public [FieldOffset(84)] participationType: UInt32;
public [FieldOffset(88)] timeSlice: Int32;
public property SPipeName: string
read Marshal.PtrToStringAnsi(IntPtr(pointer(@self.pipeName)))
write
begin
if value.Length > 79 then raise new ArgumentException('Строка не может иметь больше 79 символов');
var HStr := Marshal.StringToHGlobalAnsi(value);
var l: UInt32 := value.Length+1;
System.Buffer.MemoryCopy(pointer(HStr), @self.pipeName, l,l);
Marshal.FreeHGlobal(HStr);
end;
end;
[StructLayout(LayoutKind.&Explicit)]
GLXPipeRect = record
public [FieldOffset(0)] pipeName: byte;
// ANSI строка на 80 символа (но конец сроки обозначается сиволом #0, поэтому помещается 79)
public [FieldOffset(80)] srcXOrigin: Int32;
public [FieldOffset(84)] srcYOrigin: Int32;
public [FieldOffset(88)] srcWidth: Int32;
public [FieldOffset(92)] srcHeight: Int32;
public [FieldOffset(96)] destXOrigin: Int32;
public [FieldOffset(100)] destYOrigin: Int32;
public [FieldOffset(104)] destWidth: Int32;
public [FieldOffset(108)] destHeight: Int32;
public property SPipeName: string
read Marshal.PtrToStringAnsi(IntPtr(pointer(@self.pipeName)))
write
begin
if value.Length > 79 then raise new ArgumentException('Строка не может иметь больше 79 символов');
var HStr := Marshal.StringToHGlobalAnsi(value);
var l: UInt32 := value.Length+1;
System.Buffer.MemoryCopy(pointer(HStr), @self.pipeName, l,l);
Marshal.FreeHGlobal(HStr);
end;
end;
[StructLayout(LayoutKind.&Explicit)]
GLXPipeRectLimits = record
public [FieldOffset(0)] pipeName: byte;
// ANSI строка на 80 символа (но конец сроки обозначается сиволом #0, поэтому помещается 79)
public [FieldOffset(80)] XOrigin: Int32;
public [FieldOffset(84)] YOrigin: Int32;
public [FieldOffset(88)] maxHeight: Int32;
public [FieldOffset(92)] maxWidth: Int32;
public property SPipeName: string
read Marshal.PtrToStringAnsi(IntPtr(pointer(@self.pipeName)))
write
begin
if value.Length > 79 then raise new ArgumentException('Строка не может иметь больше 79 символов');
var HStr := Marshal.StringToHGlobalAnsi(value);
var l: UInt32 := value.Length+1;
System.Buffer.MemoryCopy(pointer(HStr), @self.pipeName, l,l);
Marshal.FreeHGlobal(HStr);
end;
end;
DrawArraysIndirectCommand = record
public count: UInt32;
public instanceCount: UInt32;
public first: UInt32;
public baseInstance: UInt32;
public constructor(count, instanceCount, first, baseInstance: UInt32);
begin
self.count := count;
self.instanceCount := instanceCount;
self.first := first;
self.baseInstance := baseInstance;
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, gmfBlackBoxY, gmfptGlyphOriginX, gmfptGlyphOriginY, gmfCellIncX, gmfCellIncY: single);
begin
self.gmfBlackBoxX := gmfBlackBoxX;
self.gmfBlackBoxY := gmfBlackBoxY;
self.gmfptGlyphOriginX := gmfptGlyphOriginX;
self.gmfptGlyphOriginY := gmfptGlyphOriginY;
self.gmfCellIncX := gmfCellIncX;
self.gmfCellIncY := gmfCellIncY;
end;
end;
//ToDo функции принемающие single - бывает, принимают и fixed
fixed = record
{private} val: UInt32;
//ToDo реализовать простейшие операции, с инкапсуляцией но разрешить обращатся к val через свойство
end;
half = record
{private} val: UInt16;
//ToDo реализовать простейшие операции, с инкапсуляцией но разрешить обращатся к val через свойство
end;
GDI_PixelFormatDescriptor = record
nSize: UInt16 := sizeof(GDI_PixelFormatDescriptor);
nVersion: UInt16 := 1;
dwFlags: PixelFormatFlagsGDI;
iPixelType: PixelDataTypeGDI;
cColorBits: Byte; // кол-во битов для R+G+B
cRedBits: Byte; // похоже, если оставить нулями - их автоматом заполнит
cRedShift: Byte;
cGreenBits: Byte;
cGreenShift: Byte;
cBlueBits: Byte;
cBlueShift: Byte;
cAlphaBits: Byte; // последние 2 не работают на Windows
cAlphaShift: Byte;
cAccumBits: Byte;
cAccumRedBits: Byte;
cAccumGreenBits: Byte;
cAccumBlueBits: Byte;
cAccumAlphaBits: Byte;
cDepthBits: Byte;
cStencilBits: Byte;
cAuxBuffers: Byte; // устарело
iLayerType: Byte; // устарело
bLayersSize: Byte; // разделено на 2 числа по 4 бита, и бесполезно без iLayerType, то есть оно тоже устарело
// не смог найти нормального описания последних 3, но все присваивают им нолики
dwLayerMask: UInt32;
dwVisibleMask: UInt32;
dwDamageMask: UInt32;
end;
{$endregion Misc}
{$endregion Записи}
type
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
public z_ActiveShaderProgram_adr := GetFuncAdr('glActiveShaderProgram');
public z_ActiveShaderProgram_ovr_0 := GetFuncOrNil&<procedure(pipeline: ProgramPipelineName; &program: ProgramName)>(z_ActiveShaderProgram_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ActiveShaderProgram(pipeline: ProgramPipelineName; &program: ProgramName);
begin
z_ActiveShaderProgram_ovr_0(pipeline, &program);
end;
// added in gl1.3
public z_ActiveTexture_adr := GetFuncAdr('glActiveTexture');
public z_ActiveTexture_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit)>(z_ActiveTexture_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ActiveTexture(texture: TextureUnit);
begin
z_ActiveTexture_ovr_0(texture);
end;
// added in gl2.0
public z_AttachShader_adr := GetFuncAdr('glAttachShader');
public z_AttachShader_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; shader: ShaderName)>(z_AttachShader_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure AttachShader(&program: ProgramName; shader: ShaderName);
begin
z_AttachShader_ovr_0(&program, shader);
end;
// added in gl3.0
public z_BeginConditionalRender_adr := GetFuncAdr('glBeginConditionalRender');
public z_BeginConditionalRender_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; mode: ConditionalRenderMode)>(z_BeginConditionalRender_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginConditionalRender(id: UInt32; mode: ConditionalRenderMode);
begin
z_BeginConditionalRender_ovr_0(id, mode);
end;
// added in gl1.5
public z_BeginQuery_adr := GetFuncAdr('glBeginQuery');
public z_BeginQuery_ovr_0 := GetFuncOrNil&<procedure(target: QueryTarget; id: QueryName)>(z_BeginQuery_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginQuery(target: QueryTarget; id: QueryName);
begin
z_BeginQuery_ovr_0(target, id);
end;
// added in gl4.0
public z_BeginQueryIndexed_adr := GetFuncAdr('glBeginQueryIndexed');
public 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);
begin
z_BeginQueryIndexed_ovr_0(target, index, id);
end;
// added in gl3.0
public z_BeginTransformFeedback_adr := GetFuncAdr('glBeginTransformFeedback');
public z_BeginTransformFeedback_ovr_0 := GetFuncOrNil&<procedure(primitiveMode: PrimitiveType)>(z_BeginTransformFeedback_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginTransformFeedback(primitiveMode: PrimitiveType);
begin
z_BeginTransformFeedback_ovr_0(primitiveMode);
end;
// added in gl2.0
public z_BindAttribLocation_adr := GetFuncAdr('glBindAttribLocation');
public 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);
begin
z_BindAttribLocation_ovr_0(&program, index, name);
end;
// added in gl1.5
public z_BindBuffer_adr := GetFuncAdr('glBindBuffer');
public z_BindBuffer_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; buffer: BufferName)>(z_BindBuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffer(target: BufferTargetARB; buffer: BufferName);
begin
z_BindBuffer_ovr_0(target, buffer);
end;
// added in gl3.1
public z_BindBufferBase_adr := GetFuncAdr('glBindBufferBase');
public 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);
begin
z_BindBufferBase_ovr_0(target, index, buffer);
end;
// added in gl3.1
public z_BindBufferRange_adr := GetFuncAdr('glBindBufferRange');
public 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);
begin
z_BindBufferRange_ovr_0(target, index, buffer, offset, size);
end;
// added in gl4.4
public z_BindBuffersBase_adr := GetFuncAdr('glBindBuffersBase');
public z_BindBuffersBase_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32)>(z_BindBuffersBase_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersBase(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of UInt32);
begin
z_BindBuffersBase_ovr_0(target, first, count, buffers[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersBase(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32);
begin
z_BindBuffersBase_ovr_0(target, first, count, buffers);
end;
public 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);
begin
z_BindBuffersBase_ovr_2(target, first, count, buffers);
end;
// added in gl4.4
public z_BindBuffersRange_adr := GetFuncAdr('glBindBuffersRange');
public z_BindBuffersRange_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; 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; offsets: array of IntPtr; sizes: array of IntPtr);
begin
z_BindBuffersRange_ovr_0(target, first, count, buffers[0], offsets[0], sizes[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of UInt32; offsets: array of IntPtr; var sizes: IntPtr);
begin
z_BindBuffersRange_ovr_0(target, first, count, buffers[0], offsets[0], sizes);
end;
public z_BindBuffersRange_ovr_2 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; var 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);
begin
z_BindBuffersRange_ovr_2(target, first, count, buffers[0], offsets[0], sizes);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of UInt32; var offsets: IntPtr; sizes: array of IntPtr);
begin
z_BindBuffersRange_ovr_0(target, first, count, buffers[0], offsets, sizes[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of UInt32; var offsets: IntPtr; var sizes: IntPtr);
begin
z_BindBuffersRange_ovr_0(target, first, count, buffers[0], offsets, sizes);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of UInt32; var offsets: IntPtr; sizes: pointer);
begin
z_BindBuffersRange_ovr_2(target, first, count, buffers[0], offsets, sizes);
end;
public z_BindBuffersRange_ovr_6 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; 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; sizes: array of IntPtr);
begin
z_BindBuffersRange_ovr_6(target, first, count, buffers[0], offsets, sizes[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of UInt32; offsets: pointer; var sizes: IntPtr);
begin
z_BindBuffersRange_ovr_6(target, first, count, buffers[0], offsets, sizes);
end;
public z_BindBuffersRange_ovr_8 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; 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);
begin
z_BindBuffersRange_ovr_8(target, first, count, buffers[0], offsets, sizes);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: array of IntPtr; sizes: array of IntPtr);
begin
z_BindBuffersRange_ovr_0(target, first, count, buffers, offsets[0], sizes[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: array of IntPtr; var sizes: IntPtr);
begin
z_BindBuffersRange_ovr_0(target, first, count, buffers, offsets[0], sizes);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: array of IntPtr; sizes: pointer);
begin
z_BindBuffersRange_ovr_2(target, first, count, buffers, offsets[0], sizes);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; sizes: array of IntPtr);
begin
z_BindBuffersRange_ovr_0(target, first, count, buffers, offsets, sizes[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; var sizes: IntPtr);
begin
z_BindBuffersRange_ovr_0(target, first, count, buffers, offsets, sizes);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; sizes: pointer);
begin
z_BindBuffersRange_ovr_2(target, first, count, buffers, offsets, sizes);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; sizes: array of IntPtr);
begin
z_BindBuffersRange_ovr_6(target, first, count, buffers, offsets, sizes[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; var sizes: IntPtr);
begin
z_BindBuffersRange_ovr_6(target, first, count, buffers, offsets, sizes);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; sizes: pointer);
begin
z_BindBuffersRange_ovr_8(target, first, count, buffers, offsets, sizes);
end;
public z_BindBuffersRange_ovr_18 := 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: IntPtr; offsets: array of IntPtr; sizes: array of IntPtr);
begin
z_BindBuffersRange_ovr_18(target, first, count, buffers, offsets[0], sizes[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; var sizes: IntPtr);
begin
z_BindBuffersRange_ovr_18(target, first, count, buffers, offsets[0], sizes);
end;
public z_BindBuffersRange_ovr_20 := 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: IntPtr; offsets: array of IntPtr; sizes: pointer);
begin
z_BindBuffersRange_ovr_20(target, first, count, buffers, offsets[0], sizes);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: array of IntPtr);
begin
z_BindBuffersRange_ovr_18(target, first, count, buffers, offsets, sizes[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr);
begin
z_BindBuffersRange_ovr_18(target, first, count, buffers, offsets, sizes);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: pointer);
begin
z_BindBuffersRange_ovr_20(target, first, count, buffers, offsets, sizes);
end;
public z_BindBuffersRange_ovr_24 := 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: IntPtr; offsets: pointer; sizes: array of IntPtr);
begin
z_BindBuffersRange_ovr_24(target, first, count, buffers, offsets, sizes[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var sizes: IntPtr);
begin
z_BindBuffersRange_ovr_24(target, first, count, buffers, offsets, sizes);
end;
public 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);
begin
z_BindBuffersRange_ovr_26(target, first, count, buffers, offsets, sizes);
end;
// added in gl3.0
public z_BindFragDataLocation_adr := GetFuncAdr('glBindFragDataLocation');
public 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);
begin
z_BindFragDataLocation_ovr_0(&program, color, name);
end;
// added in gl3.3
public z_BindFragDataLocationIndexed_adr := GetFuncAdr('glBindFragDataLocationIndexed');
public 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);
begin
z_BindFragDataLocationIndexed_ovr_0(&program, colorNumber, index, name);
end;
// added in gl3.0
public z_BindFramebuffer_adr := GetFuncAdr('glBindFramebuffer');
public z_BindFramebuffer_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; framebuffer: FramebufferName)>(z_BindFramebuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindFramebuffer(target: FramebufferTarget; framebuffer: FramebufferName);
begin
z_BindFramebuffer_ovr_0(target, framebuffer);
end;
// added in gl4.2
public z_BindImageTexture_adr := GetFuncAdr('glBindImageTexture');
public 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);
begin
z_BindImageTexture_ovr_0(&unit, texture, level, layered, layer, access, format);
end;
// added in gl4.4
public z_BindImageTextures_adr := GetFuncAdr('glBindImageTextures');
public z_BindImageTextures_ovr_0 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var textures: UInt32)>(z_BindImageTextures_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindImageTextures(first: UInt32; count: Int32; textures: array of UInt32);
begin
z_BindImageTextures_ovr_0(first, count, textures[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindImageTextures(first: UInt32; count: Int32; var textures: UInt32);
begin
z_BindImageTextures_ovr_0(first, count, textures);
end;
public 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);
begin
z_BindImageTextures_ovr_2(first, count, textures);
end;
// added in gl4.1
public z_BindProgramPipeline_adr := GetFuncAdr('glBindProgramPipeline');
public z_BindProgramPipeline_ovr_0 := GetFuncOrNil&<procedure(pipeline: ProgramPipelineName)>(z_BindProgramPipeline_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindProgramPipeline(pipeline: ProgramPipelineName);
begin
z_BindProgramPipeline_ovr_0(pipeline);
end;
// added in gl3.0
public z_BindRenderbuffer_adr := GetFuncAdr('glBindRenderbuffer');
public z_BindRenderbuffer_ovr_0 := GetFuncOrNil&<procedure(target: RenderbufferTarget; renderbuffer: RenderbufferName)>(z_BindRenderbuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindRenderbuffer(target: RenderbufferTarget; renderbuffer: RenderbufferName);
begin
z_BindRenderbuffer_ovr_0(target, renderbuffer);
end;
// added in gl3.3
public z_BindSampler_adr := GetFuncAdr('glBindSampler');
public z_BindSampler_ovr_0 := GetFuncOrNil&<procedure(&unit: UInt32; sampler: SamplerName)>(z_BindSampler_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindSampler(&unit: UInt32; sampler: SamplerName);
begin
z_BindSampler_ovr_0(&unit, sampler);
end;
// added in gl4.4
public z_BindSamplers_adr := GetFuncAdr('glBindSamplers');
public z_BindSamplers_ovr_0 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var samplers: UInt32)>(z_BindSamplers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindSamplers(first: UInt32; count: Int32; samplers: array of UInt32);
begin
z_BindSamplers_ovr_0(first, count, samplers[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindSamplers(first: UInt32; count: Int32; var samplers: UInt32);
begin
z_BindSamplers_ovr_0(first, count, samplers);
end;
public 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);
begin
z_BindSamplers_ovr_2(first, count, samplers);
end;
// added in gl1.1
private static procedure _z_BindTexture_ovr0(target: TextureTarget; texture: TextureName);
external 'opengl32.dll' name 'glBindTexture';
public static z_BindTexture_ovr0 := _z_BindTexture_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindTexture(target: TextureTarget; texture: TextureName) := z_BindTexture_ovr0(target, texture);
// added in gl4.4
public z_BindTextures_adr := GetFuncAdr('glBindTextures');
public z_BindTextures_ovr_0 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var textures: UInt32)>(z_BindTextures_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindTextures(first: UInt32; count: Int32; textures: array of UInt32);
begin
z_BindTextures_ovr_0(first, count, textures[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindTextures(first: UInt32; count: Int32; var textures: UInt32);
begin
z_BindTextures_ovr_0(first, count, textures);
end;
public 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);
begin
z_BindTextures_ovr_2(first, count, textures);
end;
// added in gl4.5
public z_BindTextureUnit_adr := GetFuncAdr('glBindTextureUnit');
public z_BindTextureUnit_ovr_0 := GetFuncOrNil&<procedure(&unit: UInt32; texture: TextureName)>(z_BindTextureUnit_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindTextureUnit(&unit: UInt32; texture: TextureName);
begin
z_BindTextureUnit_ovr_0(&unit, texture);
end;
// added in gl4.0
public z_BindTransformFeedback_adr := GetFuncAdr('glBindTransformFeedback');
public z_BindTransformFeedback_ovr_0 := GetFuncOrNil&<procedure(target: BindTransformFeedbackTarget; id: TransformFeedbackName)>(z_BindTransformFeedback_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindTransformFeedback(target: BindTransformFeedbackTarget; id: TransformFeedbackName);
begin
z_BindTransformFeedback_ovr_0(target, id);
end;
// added in gl3.0
public z_BindVertexArray_adr := GetFuncAdr('glBindVertexArray');
public z_BindVertexArray_ovr_0 := GetFuncOrNil&<procedure(&array: VertexArrayName)>(z_BindVertexArray_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexArray(&array: VertexArrayName);
begin
z_BindVertexArray_ovr_0(&array);
end;
// added in gl4.3
public z_BindVertexBuffer_adr := GetFuncAdr('glBindVertexBuffer');
public 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);
begin
z_BindVertexBuffer_ovr_0(bindingindex, buffer, offset, stride);
end;
// added in gl4.4
public z_BindVertexBuffers_adr := GetFuncAdr('glBindVertexBuffers');
public z_BindVertexBuffers_ovr_0 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var buffers: UInt32; var 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; strides: array of Int32);
begin
z_BindVertexBuffers_ovr_0(first, count, buffers[0], offsets[0], strides[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: array of UInt32; offsets: array of IntPtr; var strides: Int32);
begin
z_BindVertexBuffers_ovr_0(first, count, buffers[0], offsets[0], strides);
end;
public z_BindVertexBuffers_ovr_2 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var buffers: UInt32; var 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);
begin
z_BindVertexBuffers_ovr_2(first, count, buffers[0], offsets[0], strides);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: array of UInt32; var offsets: IntPtr; strides: array of Int32);
begin
z_BindVertexBuffers_ovr_0(first, count, buffers[0], offsets, strides[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: array of UInt32; var offsets: IntPtr; var strides: Int32);
begin
z_BindVertexBuffers_ovr_0(first, count, buffers[0], offsets, strides);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: array of UInt32; var offsets: IntPtr; strides: IntPtr);
begin
z_BindVertexBuffers_ovr_2(first, count, buffers[0], offsets, strides);
end;
public z_BindVertexBuffers_ovr_6 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; var strides: Int32)>(z_BindVertexBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: array of UInt32; offsets: pointer; strides: array of Int32);
begin
z_BindVertexBuffers_ovr_6(first, count, buffers[0], offsets, strides[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: array of UInt32; offsets: pointer; var strides: Int32);
begin
z_BindVertexBuffers_ovr_6(first, count, buffers[0], offsets, strides);
end;
public z_BindVertexBuffers_ovr_8 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var buffers: UInt32; 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);
begin
z_BindVertexBuffers_ovr_8(first, count, buffers[0], offsets, strides);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; var buffers: UInt32; offsets: array of IntPtr; strides: array of Int32);
begin
z_BindVertexBuffers_ovr_0(first, count, buffers, offsets[0], strides[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; var buffers: UInt32; offsets: array of IntPtr; var strides: Int32);
begin
z_BindVertexBuffers_ovr_0(first, count, buffers, offsets[0], strides);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; var buffers: UInt32; offsets: array of IntPtr; strides: IntPtr);
begin
z_BindVertexBuffers_ovr_2(first, count, buffers, offsets[0], strides);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; strides: array of Int32);
begin
z_BindVertexBuffers_ovr_0(first, count, buffers, offsets, strides[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; var strides: Int32);
begin
z_BindVertexBuffers_ovr_0(first, count, buffers, offsets, strides);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; strides: IntPtr);
begin
z_BindVertexBuffers_ovr_2(first, count, buffers, offsets, strides);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; strides: array of Int32);
begin
z_BindVertexBuffers_ovr_6(first, count, buffers, offsets, strides[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; var strides: Int32);
begin
z_BindVertexBuffers_ovr_6(first, count, buffers, offsets, strides);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; strides: IntPtr);
begin
z_BindVertexBuffers_ovr_8(first, count, buffers, offsets, strides);
end;
public z_BindVertexBuffers_ovr_18 := 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: IntPtr; offsets: array of IntPtr; strides: array of Int32);
begin
z_BindVertexBuffers_ovr_18(first, count, buffers, offsets[0], strides[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; var strides: Int32);
begin
z_BindVertexBuffers_ovr_18(first, count, buffers, offsets[0], strides);
end;
public z_BindVertexBuffers_ovr_20 := 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: IntPtr; offsets: array of IntPtr; strides: IntPtr);
begin
z_BindVertexBuffers_ovr_20(first, count, buffers, offsets[0], strides);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: array of Int32);
begin
z_BindVertexBuffers_ovr_18(first, count, buffers, offsets, strides[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var strides: Int32);
begin
z_BindVertexBuffers_ovr_18(first, count, buffers, offsets, strides);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr);
begin
z_BindVertexBuffers_ovr_20(first, count, buffers, offsets, strides);
end;
public z_BindVertexBuffers_ovr_24 := 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: IntPtr; offsets: pointer; strides: array of Int32);
begin
z_BindVertexBuffers_ovr_24(first, count, buffers, offsets, strides[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexBuffers(first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var strides: Int32);
begin
z_BindVertexBuffers_ovr_24(first, count, buffers, offsets, strides);
end;
public 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);
begin
z_BindVertexBuffers_ovr_26(first, count, buffers, offsets, strides);
end;
// added in gl1.4
public z_BlendColor_adr := GetFuncAdr('glBlendColor');
public 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);
begin
z_BlendColor_ovr_0(red, green, blue, alpha);
end;
// added in gl1.4
public z_BlendEquation_adr := GetFuncAdr('glBlendEquation');
public z_BlendEquation_ovr_0 := GetFuncOrNil&<procedure(mode: BlendEquationModeEXT)>(z_BlendEquation_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendEquation(mode: BlendEquationModeEXT);
begin
z_BlendEquation_ovr_0(mode);
end;
// added in gl4.0
public z_BlendEquationi_adr := GetFuncAdr('glBlendEquationi');
public z_BlendEquationi_ovr_0 := GetFuncOrNil&<procedure(buf: UInt32; mode: BlendEquationModeEXT)>(z_BlendEquationi_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendEquationi(buf: UInt32; mode: BlendEquationModeEXT);
begin
z_BlendEquationi_ovr_0(buf, mode);
end;
// added in gl2.0
public z_BlendEquationSeparate_adr := GetFuncAdr('glBlendEquationSeparate');
public z_BlendEquationSeparate_ovr_0 := GetFuncOrNil&<procedure(modeRGB: BlendEquationModeEXT; modeAlpha: BlendEquationModeEXT)>(z_BlendEquationSeparate_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendEquationSeparate(modeRGB: BlendEquationModeEXT; modeAlpha: BlendEquationModeEXT);
begin
z_BlendEquationSeparate_ovr_0(modeRGB, modeAlpha);
end;
// added in gl4.0
public z_BlendEquationSeparatei_adr := GetFuncAdr('glBlendEquationSeparatei');
public 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);
begin
z_BlendEquationSeparatei_ovr_0(buf, modeRGB, modeAlpha);
end;
// added in gl1.0
private static procedure _z_BlendFunc_ovr0(sfactor: BlendingFactor; dfactor: BlendingFactor);
external 'opengl32.dll' name 'glBlendFunc';
public static z_BlendFunc_ovr0 := _z_BlendFunc_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendFunc(sfactor: BlendingFactor; dfactor: BlendingFactor) := z_BlendFunc_ovr0(sfactor, dfactor);
// added in gl4.0
public z_BlendFunci_adr := GetFuncAdr('glBlendFunci');
public 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);
begin
z_BlendFunci_ovr_0(buf, src, dst);
end;
// added in gl1.4
public z_BlendFuncSeparate_adr := GetFuncAdr('glBlendFuncSeparate');
public 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);
begin
z_BlendFuncSeparate_ovr_0(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
end;
// added in gl4.0
public z_BlendFuncSeparatei_adr := GetFuncAdr('glBlendFuncSeparatei');
public 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);
begin
z_BlendFuncSeparatei_ovr_0(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
end;
// added in gl3.0
public z_BlitFramebuffer_adr := GetFuncAdr('glBlitFramebuffer');
public 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);
begin
z_BlitFramebuffer_ovr_0(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
end;
// added in gl4.5
public z_BlitNamedFramebuffer_adr := GetFuncAdr('glBlitNamedFramebuffer');
public 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);
begin
z_BlitNamedFramebuffer_ovr_0(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
end;
// added in gl1.5
public z_BufferData_adr := GetFuncAdr('glBufferData');
public 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);
begin
z_BufferData_ovr_0(target, size, data, usage);
end;
// added in gl4.4
public z_BufferStorage_adr := GetFuncAdr('glBufferStorage');
public 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);
begin
z_BufferStorage_ovr_0(target, size, data, flags);
end;
// added in gl1.5
public z_BufferSubData_adr := GetFuncAdr('glBufferSubData');
public 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);
begin
z_BufferSubData_ovr_0(target, offset, size, data);
end;
// added in gl3.0
public z_CheckFramebufferStatus_adr := GetFuncAdr('glCheckFramebufferStatus');
public z_CheckFramebufferStatus_ovr_0 := GetFuncOrNil&<function(target: FramebufferTarget): FramebufferStatus>(z_CheckFramebufferStatus_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CheckFramebufferStatus(target: FramebufferTarget): FramebufferStatus;
begin
Result := z_CheckFramebufferStatus_ovr_0(target);
end;
// added in gl4.5
public z_CheckNamedFramebufferStatus_adr := GetFuncAdr('glCheckNamedFramebufferStatus');
public 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;
begin
Result := z_CheckNamedFramebufferStatus_ovr_0(framebuffer, target);
end;
// added in gl3.0
public z_ClampColor_adr := GetFuncAdr('glClampColor');
public z_ClampColor_ovr_0 := GetFuncOrNil&<procedure(target: ClampColorTargetARB; clamp: ClampColorModeARB)>(z_ClampColor_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClampColor(target: ClampColorTargetARB; clamp: ClampColorModeARB);
begin
z_ClampColor_ovr_0(target, clamp);
end;
// added in gl1.0
private static procedure _z_Clear_ovr0(mask: ClearBufferMask);
external 'opengl32.dll' name 'glClear';
public static z_Clear_ovr0 := _z_Clear_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Clear(mask: ClearBufferMask) := z_Clear_ovr0(mask);
// added in gl4.3
public z_ClearBufferData_adr := GetFuncAdr('glClearBufferData');
public 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);
begin
z_ClearBufferData_ovr_0(target, _internalformat, format, &type, data);
end;
// added in gl3.0
public z_ClearBufferfi_adr := GetFuncAdr('glClearBufferfi');
public 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);
begin
z_ClearBufferfi_ovr_0(_buffer, drawbuffer, depth, stencil);
end;
// added in gl3.0
public z_ClearBufferfv_adr := GetFuncAdr('glClearBufferfv');
public z_ClearBufferfv_ovr_0 := GetFuncOrNil&<procedure(_buffer: Buffer; drawbuffer: Int32; var value: single)>(z_ClearBufferfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearBufferfv(_buffer: Buffer; drawbuffer: Int32; value: array of single);
begin
z_ClearBufferfv_ovr_0(_buffer, drawbuffer, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearBufferfv(_buffer: Buffer; drawbuffer: Int32; var value: single);
begin
z_ClearBufferfv_ovr_0(_buffer, drawbuffer, value);
end;
public 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);
begin
z_ClearBufferfv_ovr_2(_buffer, drawbuffer, value);
end;
// added in gl3.0
public z_ClearBufferiv_adr := GetFuncAdr('glClearBufferiv');
public z_ClearBufferiv_ovr_0 := GetFuncOrNil&<procedure(_buffer: Buffer; drawbuffer: Int32; var value: Int32)>(z_ClearBufferiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearBufferiv(_buffer: Buffer; drawbuffer: Int32; value: array of Int32);
begin
z_ClearBufferiv_ovr_0(_buffer, drawbuffer, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearBufferiv(_buffer: Buffer; drawbuffer: Int32; var value: Int32);
begin
z_ClearBufferiv_ovr_0(_buffer, drawbuffer, value);
end;
public 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);
begin
z_ClearBufferiv_ovr_2(_buffer, drawbuffer, value);
end;
// added in gl4.3
public z_ClearBufferSubData_adr := GetFuncAdr('glClearBufferSubData');
public 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);
begin
z_ClearBufferSubData_ovr_0(target, _internalformat, offset, size, format, &type, data);
end;
// added in gl3.0
public z_ClearBufferuiv_adr := GetFuncAdr('glClearBufferuiv');
public z_ClearBufferuiv_ovr_0 := GetFuncOrNil&<procedure(_buffer: Buffer; drawbuffer: Int32; var value: UInt32)>(z_ClearBufferuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearBufferuiv(_buffer: Buffer; drawbuffer: Int32; value: array of UInt32);
begin
z_ClearBufferuiv_ovr_0(_buffer, drawbuffer, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearBufferuiv(_buffer: Buffer; drawbuffer: Int32; var value: UInt32);
begin
z_ClearBufferuiv_ovr_0(_buffer, drawbuffer, value);
end;
public 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);
begin
z_ClearBufferuiv_ovr_2(_buffer, drawbuffer, value);
end;
// added in gl1.0
private static procedure _z_ClearColor_ovr0(red: single; green: single; blue: single; alpha: single);
external 'opengl32.dll' name 'glClearColor';
public static z_ClearColor_ovr0 := _z_ClearColor_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearColor(red: single; green: single; blue: single; alpha: single) := z_ClearColor_ovr0(red, green, blue, alpha);
// added in gl1.0
private static procedure _z_ClearDepth_ovr0(depth: real);
external 'opengl32.dll' name 'glClearDepth';
public static z_ClearDepth_ovr0 := _z_ClearDepth_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearDepth(depth: real) := z_ClearDepth_ovr0(depth);
// added in gl4.1
public z_ClearDepthf_adr := GetFuncAdr('glClearDepthf');
public z_ClearDepthf_ovr_0 := GetFuncOrNil&<procedure(d: single)>(z_ClearDepthf_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearDepthf(d: single);
begin
z_ClearDepthf_ovr_0(d);
end;
// added in gl4.5
public z_ClearNamedBufferData_adr := GetFuncAdr('glClearNamedBufferData');
public 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);
begin
z_ClearNamedBufferData_ovr_0(buffer, _internalformat, format, &type, data);
end;
// added in gl4.5
public z_ClearNamedBufferSubData_adr := GetFuncAdr('glClearNamedBufferSubData');
public 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);
begin
z_ClearNamedBufferSubData_ovr_0(buffer, _internalformat, offset, size, format, &type, data);
end;
// added in gl4.5
public z_ClearNamedFramebufferfi_adr := GetFuncAdr('glClearNamedFramebufferfi');
public 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);
begin
z_ClearNamedFramebufferfi_ovr_0(framebuffer, _buffer, drawbuffer, depth, stencil);
end;
// added in gl4.5
public z_ClearNamedFramebufferfv_adr := GetFuncAdr('glClearNamedFramebufferfv');
public z_ClearNamedFramebufferfv_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; var value: single)>(z_ClearNamedFramebufferfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedFramebufferfv(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; value: array of single);
begin
z_ClearNamedFramebufferfv_ovr_0(framebuffer, _buffer, drawbuffer, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedFramebufferfv(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; var value: single);
begin
z_ClearNamedFramebufferfv_ovr_0(framebuffer, _buffer, drawbuffer, value);
end;
public 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);
begin
z_ClearNamedFramebufferfv_ovr_2(framebuffer, _buffer, drawbuffer, value);
end;
// added in gl4.5
public z_ClearNamedFramebufferiv_adr := GetFuncAdr('glClearNamedFramebufferiv');
public z_ClearNamedFramebufferiv_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; var value: Int32)>(z_ClearNamedFramebufferiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedFramebufferiv(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; value: array of Int32);
begin
z_ClearNamedFramebufferiv_ovr_0(framebuffer, _buffer, drawbuffer, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedFramebufferiv(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; var value: Int32);
begin
z_ClearNamedFramebufferiv_ovr_0(framebuffer, _buffer, drawbuffer, value);
end;
public 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);
begin
z_ClearNamedFramebufferiv_ovr_2(framebuffer, _buffer, drawbuffer, value);
end;
// added in gl4.5
public z_ClearNamedFramebufferuiv_adr := GetFuncAdr('glClearNamedFramebufferuiv');
public z_ClearNamedFramebufferuiv_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; var value: UInt32)>(z_ClearNamedFramebufferuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedFramebufferuiv(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; value: array of UInt32);
begin
z_ClearNamedFramebufferuiv_ovr_0(framebuffer, _buffer, drawbuffer, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedFramebufferuiv(framebuffer: UInt32; _buffer: Buffer; drawbuffer: Int32; var value: UInt32);
begin
z_ClearNamedFramebufferuiv_ovr_0(framebuffer, _buffer, drawbuffer, value);
end;
public 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);
begin
z_ClearNamedFramebufferuiv_ovr_2(framebuffer, _buffer, drawbuffer, value);
end;
// added in gl1.0
private static procedure _z_ClearStencil_ovr0(s: Int32);
external 'opengl32.dll' name 'glClearStencil';
public static z_ClearStencil_ovr0 := _z_ClearStencil_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearStencil(s: Int32) := z_ClearStencil_ovr0(s);
// added in gl4.4
public z_ClearTexImage_adr := GetFuncAdr('glClearTexImage');
public 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);
begin
z_ClearTexImage_ovr_0(texture, level, format, &type, data);
end;
// added in gl4.4
public z_ClearTexSubImage_adr := GetFuncAdr('glClearTexSubImage');
public 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);
begin
z_ClearTexSubImage_ovr_0(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, &type, data);
end;
// added in gl3.2
public z_ClientWaitSync_adr := GetFuncAdr('glClientWaitSync');
public 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;
begin
Result := z_ClientWaitSync_ovr_0(sync, flags, timeout);
end;
// added in gl4.5
public z_ClipControl_adr := GetFuncAdr('glClipControl');
public z_ClipControl_ovr_0 := GetFuncOrNil&<procedure(origin: ClipControlOrigin; depth: ClipControlDepth)>(z_ClipControl_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClipControl(origin: ClipControlOrigin; depth: ClipControlDepth);
begin
z_ClipControl_ovr_0(origin, depth);
end;
// added in gl1.0
private static procedure _z_ColorMask_ovr0(red: boolean; green: boolean; blue: boolean; alpha: boolean);
external 'opengl32.dll' name 'glColorMask';
public static z_ColorMask_ovr0 := _z_ColorMask_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorMask(red: boolean; green: boolean; blue: boolean; alpha: boolean) := z_ColorMask_ovr0(red, green, blue, alpha);
// added in gl3.0
public z_ColorMaski_adr := GetFuncAdr('glColorMaski');
public 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);
begin
z_ColorMaski_ovr_0(index, r, g, b, a);
end;
// added in gl3.3
public z_ColorP3ui_adr := GetFuncAdr('glColorP3ui');
public z_ColorP3ui_ovr_0 := GetFuncOrNil&<procedure(&type: ColorPointerType; color: UInt32)>(z_ColorP3ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorP3ui(&type: ColorPointerType; color: UInt32);
begin
z_ColorP3ui_ovr_0(&type, color);
end;
// added in gl3.3
public z_ColorP3uiv_adr := GetFuncAdr('glColorP3uiv');
public z_ColorP3uiv_ovr_0 := GetFuncOrNil&<procedure(&type: ColorPointerType; var color: UInt32)>(z_ColorP3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorP3uiv(&type: ColorPointerType; color: array of UInt32);
begin
z_ColorP3uiv_ovr_0(&type, color[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorP3uiv(&type: ColorPointerType; var color: UInt32);
begin
z_ColorP3uiv_ovr_0(&type, color);
end;
public z_ColorP3uiv_ovr_2 := GetFuncOrNil&<procedure(&type: ColorPointerType; color: IntPtr)>(z_ColorP3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorP3uiv(&type: ColorPointerType; color: IntPtr);
begin
z_ColorP3uiv_ovr_2(&type, color);
end;
// added in gl3.3
public z_ColorP4ui_adr := GetFuncAdr('glColorP4ui');
public z_ColorP4ui_ovr_0 := GetFuncOrNil&<procedure(&type: ColorPointerType; color: UInt32)>(z_ColorP4ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorP4ui(&type: ColorPointerType; color: UInt32);
begin
z_ColorP4ui_ovr_0(&type, color);
end;
// added in gl3.3
public z_ColorP4uiv_adr := GetFuncAdr('glColorP4uiv');
public z_ColorP4uiv_ovr_0 := GetFuncOrNil&<procedure(&type: ColorPointerType; var color: UInt32)>(z_ColorP4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorP4uiv(&type: ColorPointerType; color: array of UInt32);
begin
z_ColorP4uiv_ovr_0(&type, color[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorP4uiv(&type: ColorPointerType; var color: UInt32);
begin
z_ColorP4uiv_ovr_0(&type, color);
end;
public z_ColorP4uiv_ovr_2 := GetFuncOrNil&<procedure(&type: ColorPointerType; color: IntPtr)>(z_ColorP4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorP4uiv(&type: ColorPointerType; color: IntPtr);
begin
z_ColorP4uiv_ovr_2(&type, color);
end;
// added in gl2.0
public z_CompileShader_adr := GetFuncAdr('glCompileShader');
public z_CompileShader_ovr_0 := GetFuncOrNil&<procedure(shader: ShaderName)>(z_CompileShader_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompileShader(shader: ShaderName);
begin
z_CompileShader_ovr_0(shader);
end;
// added in gl1.3
public z_CompressedTexImage1D_adr := GetFuncAdr('glCompressedTexImage1D');
public 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);
begin
z_CompressedTexImage1D_ovr_0(target, level, _internalformat, width, border, imageSize, data);
end;
// added in gl1.3
public z_CompressedTexImage2D_adr := GetFuncAdr('glCompressedTexImage2D');
public 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);
begin
z_CompressedTexImage2D_ovr_0(target, level, _internalformat, width, height, border, imageSize, data);
end;
// added in gl1.3
public z_CompressedTexImage3D_adr := GetFuncAdr('glCompressedTexImage3D');
public 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);
begin
z_CompressedTexImage3D_ovr_0(target, level, _internalformat, width, height, depth, border, imageSize, data);
end;
// added in gl1.3
public z_CompressedTexSubImage1D_adr := GetFuncAdr('glCompressedTexSubImage1D');
public 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);
begin
z_CompressedTexSubImage1D_ovr_0(target, level, xoffset, width, format, imageSize, data);
end;
// added in gl1.3
public z_CompressedTexSubImage2D_adr := GetFuncAdr('glCompressedTexSubImage2D');
public 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);
begin
z_CompressedTexSubImage2D_ovr_0(target, level, xoffset, yoffset, width, height, format, imageSize, data);
end;
// added in gl1.3
public z_CompressedTexSubImage3D_adr := GetFuncAdr('glCompressedTexSubImage3D');
public 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);
begin
z_CompressedTexSubImage3D_ovr_0(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
end;
// added in gl4.5
public z_CompressedTextureSubImage1D_adr := GetFuncAdr('glCompressedTextureSubImage1D');
public 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);
begin
z_CompressedTextureSubImage1D_ovr_0(texture, level, xoffset, width, format, imageSize, data);
end;
// added in gl4.5
public z_CompressedTextureSubImage2D_adr := GetFuncAdr('glCompressedTextureSubImage2D');
public 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);
begin
z_CompressedTextureSubImage2D_ovr_0(texture, level, xoffset, yoffset, width, height, format, imageSize, data);
end;
// added in gl4.5
public z_CompressedTextureSubImage3D_adr := GetFuncAdr('glCompressedTextureSubImage3D');
public 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);
begin
z_CompressedTextureSubImage3D_ovr_0(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
end;
// added in gl3.1
public z_CopyBufferSubData_adr := GetFuncAdr('glCopyBufferSubData');
public 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);
begin
z_CopyBufferSubData_ovr_0(readTarget, writeTarget, readOffset, writeOffset, size);
end;
// added in gl4.3
public z_CopyImageSubData_adr := GetFuncAdr('glCopyImageSubData');
public 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);
begin
z_CopyImageSubData_ovr_0(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
end;
// added in gl4.5
public z_CopyNamedBufferSubData_adr := GetFuncAdr('glCopyNamedBufferSubData');
public 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);
begin
z_CopyNamedBufferSubData_ovr_0(readBuffer, writeBuffer, readOffset, writeOffset, size);
end;
// added in gl1.1
private static procedure _z_CopyTexImage1D_ovr0(target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; border: Int32);
external 'opengl32.dll' name 'glCopyTexImage1D';
public static z_CopyTexImage1D_ovr0 := _z_CopyTexImage1D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTexImage1D(target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; border: Int32) := z_CopyTexImage1D_ovr0(target, level, _internalformat, x, y, width, border);
// added in gl1.1
private static procedure _z_CopyTexImage2D_ovr0(target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; height: Int32; border: Int32);
external 'opengl32.dll' name 'glCopyTexImage2D';
public static z_CopyTexImage2D_ovr0 := _z_CopyTexImage2D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTexImage2D(target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; height: Int32; border: Int32) := z_CopyTexImage2D_ovr0(target, level, _internalformat, x, y, width, height, border);
// added in gl1.1
private static procedure _z_CopyTexSubImage1D_ovr0(target: TextureTarget; level: Int32; xoffset: Int32; x: Int32; y: Int32; width: Int32);
external 'opengl32.dll' name 'glCopyTexSubImage1D';
public static z_CopyTexSubImage1D_ovr0 := _z_CopyTexSubImage1D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTexSubImage1D(target: TextureTarget; level: Int32; xoffset: Int32; x: Int32; y: Int32; width: Int32) := z_CopyTexSubImage1D_ovr0(target, level, xoffset, x, y, width);
// added in gl1.1
private static procedure _z_CopyTexSubImage2D_ovr0(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32);
external 'opengl32.dll' name 'glCopyTexSubImage2D';
public static z_CopyTexSubImage2D_ovr0 := _z_CopyTexSubImage2D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTexSubImage2D(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32) := z_CopyTexSubImage2D_ovr0(target, level, xoffset, yoffset, x, y, width, height);
// added in gl1.2
public z_CopyTexSubImage3D_adr := GetFuncAdr('glCopyTexSubImage3D');
public 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);
begin
z_CopyTexSubImage3D_ovr_0(target, level, xoffset, yoffset, zoffset, x, y, width, height);
end;
// added in gl4.5
public z_CopyTextureSubImage1D_adr := GetFuncAdr('glCopyTextureSubImage1D');
public 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);
begin
z_CopyTextureSubImage1D_ovr_0(texture, level, xoffset, x, y, width);
end;
// added in gl4.5
public z_CopyTextureSubImage2D_adr := GetFuncAdr('glCopyTextureSubImage2D');
public 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);
begin
z_CopyTextureSubImage2D_ovr_0(texture, level, xoffset, yoffset, x, y, width, height);
end;
// added in gl4.5
public z_CopyTextureSubImage3D_adr := GetFuncAdr('glCopyTextureSubImage3D');
public 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);
begin
z_CopyTextureSubImage3D_ovr_0(texture, level, xoffset, yoffset, zoffset, x, y, width, height);
end;
// added in gl4.5
public z_CreateBuffers_adr := GetFuncAdr('glCreateBuffers');
public z_CreateBuffers_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var buffers: BufferName)>(z_CreateBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateBuffers(n: Int32; buffers: array of BufferName);
begin
z_CreateBuffers_ovr_0(n, buffers[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateBuffers(n: Int32; var buffers: BufferName);
begin
z_CreateBuffers_ovr_0(n, buffers);
end;
public z_CreateBuffers_ovr_2 := GetFuncOrNil&<procedure(n: Int32; buffers: IntPtr)>(z_CreateBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateBuffers(n: Int32; buffers: IntPtr);
begin
z_CreateBuffers_ovr_2(n, buffers);
end;
// added in gl4.5
public z_CreateFramebuffers_adr := GetFuncAdr('glCreateFramebuffers');
public z_CreateFramebuffers_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var framebuffers: UInt32)>(z_CreateFramebuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateFramebuffers(n: Int32; framebuffers: array of UInt32);
begin
z_CreateFramebuffers_ovr_0(n, framebuffers[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateFramebuffers(n: Int32; var framebuffers: UInt32);
begin
z_CreateFramebuffers_ovr_0(n, framebuffers);
end;
public z_CreateFramebuffers_ovr_2 := GetFuncOrNil&<procedure(n: Int32; framebuffers: IntPtr)>(z_CreateFramebuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateFramebuffers(n: Int32; framebuffers: IntPtr);
begin
z_CreateFramebuffers_ovr_2(n, framebuffers);
end;
// added in gl2.0
public z_CreateProgram_adr := GetFuncAdr('glCreateProgram');
public z_CreateProgram_ovr_0 := GetFuncOrNil&<function: ProgramName>(z_CreateProgram_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateProgram: ProgramName;
begin
Result := z_CreateProgram_ovr_0;
end;
// added in gl4.5
public z_CreateProgramPipelines_adr := GetFuncAdr('glCreateProgramPipelines');
public z_CreateProgramPipelines_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var pipelines: UInt32)>(z_CreateProgramPipelines_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateProgramPipelines(n: Int32; pipelines: array of UInt32);
begin
z_CreateProgramPipelines_ovr_0(n, pipelines[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateProgramPipelines(n: Int32; var pipelines: UInt32);
begin
z_CreateProgramPipelines_ovr_0(n, pipelines);
end;
public z_CreateProgramPipelines_ovr_2 := GetFuncOrNil&<procedure(n: Int32; pipelines: IntPtr)>(z_CreateProgramPipelines_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateProgramPipelines(n: Int32; pipelines: IntPtr);
begin
z_CreateProgramPipelines_ovr_2(n, pipelines);
end;
// added in gl4.5
public z_CreateQueries_adr := GetFuncAdr('glCreateQueries');
public z_CreateQueries_ovr_0 := GetFuncOrNil&<procedure(target: QueryTarget; n: Int32; var ids: UInt32)>(z_CreateQueries_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateQueries(target: QueryTarget; n: Int32; ids: array of UInt32);
begin
z_CreateQueries_ovr_0(target, n, ids[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateQueries(target: QueryTarget; n: Int32; var ids: UInt32);
begin
z_CreateQueries_ovr_0(target, n, ids);
end;
public 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);
begin
z_CreateQueries_ovr_2(target, n, ids);
end;
// added in gl4.5
public z_CreateRenderbuffers_adr := GetFuncAdr('glCreateRenderbuffers');
public z_CreateRenderbuffers_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var renderbuffers: UInt32)>(z_CreateRenderbuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateRenderbuffers(n: Int32; renderbuffers: array of UInt32);
begin
z_CreateRenderbuffers_ovr_0(n, renderbuffers[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateRenderbuffers(n: Int32; var renderbuffers: UInt32);
begin
z_CreateRenderbuffers_ovr_0(n, renderbuffers);
end;
public z_CreateRenderbuffers_ovr_2 := GetFuncOrNil&<procedure(n: Int32; renderbuffers: IntPtr)>(z_CreateRenderbuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateRenderbuffers(n: Int32; renderbuffers: IntPtr);
begin
z_CreateRenderbuffers_ovr_2(n, renderbuffers);
end;
// added in gl4.5
public z_CreateSamplers_adr := GetFuncAdr('glCreateSamplers');
public z_CreateSamplers_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var samplers: UInt32)>(z_CreateSamplers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateSamplers(n: Int32; samplers: array of UInt32);
begin
z_CreateSamplers_ovr_0(n, samplers[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateSamplers(n: Int32; var samplers: UInt32);
begin
z_CreateSamplers_ovr_0(n, samplers);
end;
public z_CreateSamplers_ovr_2 := GetFuncOrNil&<procedure(n: Int32; samplers: IntPtr)>(z_CreateSamplers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateSamplers(n: Int32; samplers: IntPtr);
begin
z_CreateSamplers_ovr_2(n, samplers);
end;
// added in gl2.0
public z_CreateShader_adr := GetFuncAdr('glCreateShader');
public z_CreateShader_ovr_0 := GetFuncOrNil&<function(&type: ShaderType): ShaderName>(z_CreateShader_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateShader(&type: ShaderType): ShaderName;
begin
Result := z_CreateShader_ovr_0(&type);
end;
// added in gl4.1
public z_CreateShaderProgramv_adr := GetFuncAdr('glCreateShaderProgramv');
public z_CreateShaderProgramv_ovr_0 := GetFuncOrNil&<function(&type: ShaderType; count: Int32; var 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));
Result := z_CreateShaderProgramv_ovr_0(&type, count, par_3_str_ptr[0]);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateShaderProgramv(&type: ShaderType; count: Int32; strings: array of IntPtr): ProgramName;
begin
Result := z_CreateShaderProgramv_ovr_0(&type, count, strings[0]);
end;
public 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;
begin
Result := z_CreateShaderProgramv_ovr_2(&type, count, strings);
end;
// added in gl4.5
public z_CreateTextures_adr := GetFuncAdr('glCreateTextures');
public z_CreateTextures_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; n: Int32; var textures: UInt32)>(z_CreateTextures_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateTextures(target: TextureTarget; n: Int32; textures: array of UInt32);
begin
z_CreateTextures_ovr_0(target, n, textures[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateTextures(target: TextureTarget; n: Int32; var textures: UInt32);
begin
z_CreateTextures_ovr_0(target, n, textures);
end;
public 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);
begin
z_CreateTextures_ovr_2(target, n, textures);
end;
// added in gl4.5
public z_CreateTransformFeedbacks_adr := GetFuncAdr('glCreateTransformFeedbacks');
public z_CreateTransformFeedbacks_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var ids: UInt32)>(z_CreateTransformFeedbacks_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateTransformFeedbacks(n: Int32; ids: array of UInt32);
begin
z_CreateTransformFeedbacks_ovr_0(n, ids[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateTransformFeedbacks(n: Int32; var ids: UInt32);
begin
z_CreateTransformFeedbacks_ovr_0(n, ids);
end;
public z_CreateTransformFeedbacks_ovr_2 := GetFuncOrNil&<procedure(n: Int32; ids: IntPtr)>(z_CreateTransformFeedbacks_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateTransformFeedbacks(n: Int32; ids: IntPtr);
begin
z_CreateTransformFeedbacks_ovr_2(n, ids);
end;
// added in gl4.5
public z_CreateVertexArrays_adr := GetFuncAdr('glCreateVertexArrays');
public z_CreateVertexArrays_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var arrays: UInt32)>(z_CreateVertexArrays_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateVertexArrays(n: Int32; arrays: array of UInt32);
begin
z_CreateVertexArrays_ovr_0(n, arrays[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateVertexArrays(n: Int32; var arrays: UInt32);
begin
z_CreateVertexArrays_ovr_0(n, arrays);
end;
public z_CreateVertexArrays_ovr_2 := GetFuncOrNil&<procedure(n: Int32; arrays: IntPtr)>(z_CreateVertexArrays_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateVertexArrays(n: Int32; arrays: IntPtr);
begin
z_CreateVertexArrays_ovr_2(n, arrays);
end;
// added in gl1.0
private static procedure _z_CullFace_ovr0(mode: CullFaceMode);
external 'opengl32.dll' name 'glCullFace';
public static z_CullFace_ovr0 := _z_CullFace_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CullFace(mode: CullFaceMode) := z_CullFace_ovr0(mode);
// added in gl4.3
public z_DebugMessageCallback_adr := GetFuncAdr('glDebugMessageCallback');
public z_DebugMessageCallback_ovr_0 := GetFuncOrNil&<procedure(callback: GLDEBUGPROC; userParam: IntPtr)>(z_DebugMessageCallback_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageCallback(callback: GLDEBUGPROC; userParam: IntPtr);
begin
z_DebugMessageCallback_ovr_0(callback, userParam);
end;
// added in gl4.3
public z_DebugMessageControl_adr := GetFuncAdr('glDebugMessageControl');
public z_DebugMessageControl_ovr_0 := GetFuncOrNil&<procedure(source: DebugSource; &type: DebugType; severity: DebugSeverity; count: Int32; var ids: UInt32; 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);
begin
z_DebugMessageControl_ovr_0(source, &type, severity, count, ids[0], enabled);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageControl(source: DebugSource; &type: DebugType; severity: DebugSeverity; count: Int32; var ids: UInt32; enabled: boolean);
begin
z_DebugMessageControl_ovr_0(source, &type, severity, count, ids, enabled);
end;
public 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);
begin
z_DebugMessageControl_ovr_2(source, &type, severity, count, ids, enabled);
end;
// added in gl4.3
public z_DebugMessageInsert_adr := GetFuncAdr('glDebugMessageInsert');
public 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);
begin
z_DebugMessageInsert_ovr_0(source, &type, id, severity, length, buf);
end;
// added in gl1.5
public z_DeleteBuffers_adr := GetFuncAdr('glDeleteBuffers');
public z_DeleteBuffers_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var buffers: UInt32)>(z_DeleteBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteBuffers(n: Int32; buffers: array of UInt32);
begin
z_DeleteBuffers_ovr_0(n, buffers[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteBuffers(n: Int32; var buffers: UInt32);
begin
z_DeleteBuffers_ovr_0(n, buffers);
end;
public z_DeleteBuffers_ovr_2 := GetFuncOrNil&<procedure(n: Int32; buffers: IntPtr)>(z_DeleteBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteBuffers(n: Int32; buffers: IntPtr);
begin
z_DeleteBuffers_ovr_2(n, buffers);
end;
// added in gl3.0
public z_DeleteFramebuffers_adr := GetFuncAdr('glDeleteFramebuffers');
public z_DeleteFramebuffers_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var framebuffers: UInt32)>(z_DeleteFramebuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFramebuffers(n: Int32; framebuffers: array of UInt32);
begin
z_DeleteFramebuffers_ovr_0(n, framebuffers[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFramebuffers(n: Int32; var framebuffers: UInt32);
begin
z_DeleteFramebuffers_ovr_0(n, framebuffers);
end;
public z_DeleteFramebuffers_ovr_2 := GetFuncOrNil&<procedure(n: Int32; framebuffers: IntPtr)>(z_DeleteFramebuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFramebuffers(n: Int32; framebuffers: IntPtr);
begin
z_DeleteFramebuffers_ovr_2(n, framebuffers);
end;
// added in gl2.0
public z_DeleteProgram_adr := GetFuncAdr('glDeleteProgram');
public z_DeleteProgram_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName)>(z_DeleteProgram_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgram(&program: ProgramName);
begin
z_DeleteProgram_ovr_0(&program);
end;
// added in gl4.1
public z_DeleteProgramPipelines_adr := GetFuncAdr('glDeleteProgramPipelines');
public z_DeleteProgramPipelines_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var pipelines: UInt32)>(z_DeleteProgramPipelines_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgramPipelines(n: Int32; pipelines: array of UInt32);
begin
z_DeleteProgramPipelines_ovr_0(n, pipelines[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgramPipelines(n: Int32; var pipelines: UInt32);
begin
z_DeleteProgramPipelines_ovr_0(n, pipelines);
end;
public z_DeleteProgramPipelines_ovr_2 := GetFuncOrNil&<procedure(n: Int32; pipelines: IntPtr)>(z_DeleteProgramPipelines_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgramPipelines(n: Int32; pipelines: IntPtr);
begin
z_DeleteProgramPipelines_ovr_2(n, pipelines);
end;
// added in gl1.5
public z_DeleteQueries_adr := GetFuncAdr('glDeleteQueries');
public z_DeleteQueries_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var ids: UInt32)>(z_DeleteQueries_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteQueries(n: Int32; ids: array of UInt32);
begin
z_DeleteQueries_ovr_0(n, ids[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteQueries(n: Int32; var ids: UInt32);
begin
z_DeleteQueries_ovr_0(n, ids);
end;
public z_DeleteQueries_ovr_2 := GetFuncOrNil&<procedure(n: Int32; ids: IntPtr)>(z_DeleteQueries_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteQueries(n: Int32; ids: IntPtr);
begin
z_DeleteQueries_ovr_2(n, ids);
end;
// added in gl3.0
public z_DeleteRenderbuffers_adr := GetFuncAdr('glDeleteRenderbuffers');
public z_DeleteRenderbuffers_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var renderbuffers: UInt32)>(z_DeleteRenderbuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteRenderbuffers(n: Int32; renderbuffers: array of UInt32);
begin
z_DeleteRenderbuffers_ovr_0(n, renderbuffers[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteRenderbuffers(n: Int32; var renderbuffers: UInt32);
begin
z_DeleteRenderbuffers_ovr_0(n, renderbuffers);
end;
public z_DeleteRenderbuffers_ovr_2 := GetFuncOrNil&<procedure(n: Int32; renderbuffers: IntPtr)>(z_DeleteRenderbuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteRenderbuffers(n: Int32; renderbuffers: IntPtr);
begin
z_DeleteRenderbuffers_ovr_2(n, renderbuffers);
end;
// added in gl3.3
public z_DeleteSamplers_adr := GetFuncAdr('glDeleteSamplers');
public z_DeleteSamplers_ovr_0 := GetFuncOrNil&<procedure(count: Int32; var samplers: UInt32)>(z_DeleteSamplers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteSamplers(count: Int32; samplers: array of UInt32);
begin
z_DeleteSamplers_ovr_0(count, samplers[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteSamplers(count: Int32; var samplers: UInt32);
begin
z_DeleteSamplers_ovr_0(count, samplers);
end;
public z_DeleteSamplers_ovr_2 := GetFuncOrNil&<procedure(count: Int32; samplers: IntPtr)>(z_DeleteSamplers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteSamplers(count: Int32; samplers: IntPtr);
begin
z_DeleteSamplers_ovr_2(count, samplers);
end;
// added in gl2.0
public z_DeleteShader_adr := GetFuncAdr('glDeleteShader');
public z_DeleteShader_ovr_0 := GetFuncOrNil&<procedure(shader: ShaderName)>(z_DeleteShader_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteShader(shader: ShaderName);
begin
z_DeleteShader_ovr_0(shader);
end;
// added in gl3.2
public z_DeleteSync_adr := GetFuncAdr('glDeleteSync');
public z_DeleteSync_ovr_0 := GetFuncOrNil&<procedure(sync: GLsync)>(z_DeleteSync_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteSync(sync: GLsync);
begin
z_DeleteSync_ovr_0(sync);
end;
// added in gl1.1
private static procedure _z_DeleteTextures_ovr0(n: Int32; [MarshalAs(UnmanagedType.LPArray)] textures: array of UInt32);
external 'opengl32.dll' name 'glDeleteTextures';
public static z_DeleteTextures_ovr0 := _z_DeleteTextures_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteTextures(n: Int32; textures: array of UInt32) := z_DeleteTextures_ovr0(n, textures);
private static procedure _z_DeleteTextures_ovr1(n: Int32; var textures: UInt32);
external 'opengl32.dll' name 'glDeleteTextures';
public static z_DeleteTextures_ovr1 := _z_DeleteTextures_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteTextures(n: Int32; var textures: UInt32) := z_DeleteTextures_ovr1(n, textures);
private static procedure _z_DeleteTextures_ovr2(n: Int32; textures: IntPtr);
external 'opengl32.dll' name 'glDeleteTextures';
public static z_DeleteTextures_ovr2 := _z_DeleteTextures_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteTextures(n: Int32; textures: IntPtr) := z_DeleteTextures_ovr2(n, textures);
// added in gl4.0
public z_DeleteTransformFeedbacks_adr := GetFuncAdr('glDeleteTransformFeedbacks');
public z_DeleteTransformFeedbacks_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var ids: UInt32)>(z_DeleteTransformFeedbacks_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteTransformFeedbacks(n: Int32; ids: array of UInt32);
begin
z_DeleteTransformFeedbacks_ovr_0(n, ids[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteTransformFeedbacks(n: Int32; var ids: UInt32);
begin
z_DeleteTransformFeedbacks_ovr_0(n, ids);
end;
public z_DeleteTransformFeedbacks_ovr_2 := GetFuncOrNil&<procedure(n: Int32; ids: IntPtr)>(z_DeleteTransformFeedbacks_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteTransformFeedbacks(n: Int32; ids: IntPtr);
begin
z_DeleteTransformFeedbacks_ovr_2(n, ids);
end;
// added in gl3.0
public z_DeleteVertexArrays_adr := GetFuncAdr('glDeleteVertexArrays');
public z_DeleteVertexArrays_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var arrays: UInt32)>(z_DeleteVertexArrays_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteVertexArrays(n: Int32; arrays: array of UInt32);
begin
z_DeleteVertexArrays_ovr_0(n, arrays[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteVertexArrays(n: Int32; var arrays: UInt32);
begin
z_DeleteVertexArrays_ovr_0(n, arrays);
end;
public z_DeleteVertexArrays_ovr_2 := GetFuncOrNil&<procedure(n: Int32; arrays: IntPtr)>(z_DeleteVertexArrays_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteVertexArrays(n: Int32; arrays: IntPtr);
begin
z_DeleteVertexArrays_ovr_2(n, arrays);
end;
// added in gl1.0
private static procedure _z_DepthFunc_ovr0(func: DepthFunction);
external 'opengl32.dll' name 'glDepthFunc';
public static z_DepthFunc_ovr0 := _z_DepthFunc_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthFunc(func: DepthFunction) := z_DepthFunc_ovr0(func);
// added in gl1.0
private static procedure _z_DepthMask_ovr0(flag: boolean);
external 'opengl32.dll' name 'glDepthMask';
public static z_DepthMask_ovr0 := _z_DepthMask_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthMask(flag: boolean) := z_DepthMask_ovr0(flag);
// added in gl1.0
private static procedure _z_DepthRange_ovr0(n: real; f: real);
external 'opengl32.dll' name 'glDepthRange';
public static z_DepthRange_ovr0 := _z_DepthRange_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthRange(n: real; f: real) := z_DepthRange_ovr0(n, f);
// added in gl4.1
public z_DepthRangeArrayv_adr := GetFuncAdr('glDepthRangeArrayv');
public z_DepthRangeArrayv_ovr_0 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var v: real)>(z_DepthRangeArrayv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthRangeArrayv(first: UInt32; count: Int32; v: array of real);
begin
z_DepthRangeArrayv_ovr_0(first, count, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthRangeArrayv(first: UInt32; count: Int32; var v: real);
begin
z_DepthRangeArrayv_ovr_0(first, count, v);
end;
public 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);
begin
z_DepthRangeArrayv_ovr_2(first, count, v);
end;
// added in gl4.1
public z_DepthRangef_adr := GetFuncAdr('glDepthRangef');
public z_DepthRangef_ovr_0 := GetFuncOrNil&<procedure(n: single; f: single)>(z_DepthRangef_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthRangef(n: single; f: single);
begin
z_DepthRangef_ovr_0(n, f);
end;
// added in gl4.1
public z_DepthRangeIndexed_adr := GetFuncAdr('glDepthRangeIndexed');
public 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);
begin
z_DepthRangeIndexed_ovr_0(index, n, f);
end;
// added in gl2.0
public z_DetachShader_adr := GetFuncAdr('glDetachShader');
public z_DetachShader_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; shader: ShaderName)>(z_DetachShader_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DetachShader(&program: ProgramName; shader: ShaderName);
begin
z_DetachShader_ovr_0(&program, shader);
end;
// added in gl1.0
private static procedure _z_Disable_ovr0(cap: EnableCap);
external 'opengl32.dll' name 'glDisable';
public static z_Disable_ovr0 := _z_Disable_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Disable(cap: EnableCap) := z_Disable_ovr0(cap);
// added in gl3.0
public z_Disablei_adr := GetFuncAdr('glDisablei');
public z_Disablei_ovr_0 := GetFuncOrNil&<procedure(target: EnableCap; index: UInt32)>(z_Disablei_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Disablei(target: EnableCap; index: UInt32);
begin
z_Disablei_ovr_0(target, index);
end;
// added in gl4.5
public z_DisableVertexArrayAttrib_adr := GetFuncAdr('glDisableVertexArrayAttrib');
public z_DisableVertexArrayAttrib_ovr_0 := GetFuncOrNil&<procedure(vaobj: VertexArrayName; index: UInt32)>(z_DisableVertexArrayAttrib_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DisableVertexArrayAttrib(vaobj: VertexArrayName; index: UInt32);
begin
z_DisableVertexArrayAttrib_ovr_0(vaobj, index);
end;
// added in gl2.0
public z_DisableVertexAttribArray_adr := GetFuncAdr('glDisableVertexAttribArray');
public z_DisableVertexAttribArray_ovr_0 := GetFuncOrNil&<procedure(index: UInt32)>(z_DisableVertexAttribArray_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DisableVertexAttribArray(index: UInt32);
begin
z_DisableVertexAttribArray_ovr_0(index);
end;
// added in gl4.3
public z_DispatchCompute_adr := GetFuncAdr('glDispatchCompute');
public 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);
begin
z_DispatchCompute_ovr_0(num_groups_x, num_groups_y, num_groups_z);
end;
// added in gl4.3
public z_DispatchComputeIndirect_adr := GetFuncAdr('glDispatchComputeIndirect');
public z_DispatchComputeIndirect_ovr_0 := GetFuncOrNil&<procedure(indirect: IntPtr)>(z_DispatchComputeIndirect_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DispatchComputeIndirect(indirect: IntPtr);
begin
z_DispatchComputeIndirect_ovr_0(indirect);
end;
// added in gl1.1
private static procedure _z_DrawArrays_ovr0(mode: PrimitiveType; first: Int32; count: Int32);
external 'opengl32.dll' name 'glDrawArrays';
public static z_DrawArrays_ovr0 := _z_DrawArrays_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawArrays(mode: PrimitiveType; first: Int32; count: Int32) := z_DrawArrays_ovr0(mode, first, count);
// added in gl4.0
public z_DrawArraysIndirect_adr := GetFuncAdr('glDrawArraysIndirect');
public z_DrawArraysIndirect_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; indirect: IntPtr)>(z_DrawArraysIndirect_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawArraysIndirect(mode: PrimitiveType; indirect: IntPtr);
begin
z_DrawArraysIndirect_ovr_0(mode, indirect);
end;
// added in gl3.1
public z_DrawArraysInstanced_adr := GetFuncAdr('glDrawArraysInstanced');
public 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);
begin
z_DrawArraysInstanced_ovr_0(mode, first, count, instancecount);
end;
// added in gl4.2
public z_DrawArraysInstancedBaseInstance_adr := GetFuncAdr('glDrawArraysInstancedBaseInstance');
public 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);
begin
z_DrawArraysInstancedBaseInstance_ovr_0(mode, first, count, instancecount, baseinstance);
end;
// added in gl1.0
private static procedure _z_DrawBuffer_ovr0(buf: DrawBufferMode);
external 'opengl32.dll' name 'glDrawBuffer';
public static z_DrawBuffer_ovr0 := _z_DrawBuffer_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawBuffer(buf: DrawBufferMode) := z_DrawBuffer_ovr0(buf);
// added in gl2.0
public z_DrawBuffers_adr := GetFuncAdr('glDrawBuffers');
public z_DrawBuffers_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var bufs: DrawBufferMode)>(z_DrawBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawBuffers(n: Int32; bufs: array of DrawBufferMode);
begin
z_DrawBuffers_ovr_0(n, bufs[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawBuffers(n: Int32; var bufs: DrawBufferMode);
begin
z_DrawBuffers_ovr_0(n, bufs);
end;
public z_DrawBuffers_ovr_2 := GetFuncOrNil&<procedure(n: Int32; bufs: IntPtr)>(z_DrawBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawBuffers(n: Int32; bufs: IntPtr);
begin
z_DrawBuffers_ovr_2(n, bufs);
end;
// added in gl1.1
private static procedure _z_DrawElements_ovr0(mode: PrimitiveType; count: Int32; &type: DrawElementsType; indices: IntPtr);
external 'opengl32.dll' name 'glDrawElements';
public static z_DrawElements_ovr0 := _z_DrawElements_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawElements(mode: PrimitiveType; count: Int32; &type: DrawElementsType; indices: IntPtr) := z_DrawElements_ovr0(mode, count, &type, indices);
// added in gl3.2
public z_DrawElementsBaseVertex_adr := GetFuncAdr('glDrawElementsBaseVertex');
public 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);
begin
z_DrawElementsBaseVertex_ovr_0(mode, count, &type, indices, basevertex);
end;
// added in gl4.0
public z_DrawElementsIndirect_adr := GetFuncAdr('glDrawElementsIndirect');
public 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);
begin
z_DrawElementsIndirect_ovr_0(mode, &type, indirect);
end;
// added in gl3.1
public z_DrawElementsInstanced_adr := GetFuncAdr('glDrawElementsInstanced');
public 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);
begin
z_DrawElementsInstanced_ovr_0(mode, count, &type, indices, instancecount);
end;
// added in gl4.2
public z_DrawElementsInstancedBaseInstance_adr := GetFuncAdr('glDrawElementsInstancedBaseInstance');
public 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);
begin
z_DrawElementsInstancedBaseInstance_ovr_0(mode, count, &type, indices, instancecount, baseinstance);
end;
// added in gl3.2
public z_DrawElementsInstancedBaseVertex_adr := GetFuncAdr('glDrawElementsInstancedBaseVertex');
public 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);
begin
z_DrawElementsInstancedBaseVertex_ovr_0(mode, count, &type, indices, instancecount, basevertex);
end;
// added in gl4.2
public z_DrawElementsInstancedBaseVertexBaseInstance_adr := GetFuncAdr('glDrawElementsInstancedBaseVertexBaseInstance');
public 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);
begin
z_DrawElementsInstancedBaseVertexBaseInstance_ovr_0(mode, count, &type, indices, instancecount, basevertex, baseinstance);
end;
// added in gl1.2
public z_DrawRangeElements_adr := GetFuncAdr('glDrawRangeElements');
public 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);
begin
z_DrawRangeElements_ovr_0(mode, start, &end, count, &type, indices);
end;
// added in gl3.2
public z_DrawRangeElementsBaseVertex_adr := GetFuncAdr('glDrawRangeElementsBaseVertex');
public 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);
begin
z_DrawRangeElementsBaseVertex_ovr_0(mode, start, &end, count, &type, indices, basevertex);
end;
// added in gl4.0
public z_DrawTransformFeedback_adr := GetFuncAdr('glDrawTransformFeedback');
public z_DrawTransformFeedback_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; id: TransformFeedbackName)>(z_DrawTransformFeedback_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawTransformFeedback(mode: PrimitiveType; id: TransformFeedbackName);
begin
z_DrawTransformFeedback_ovr_0(mode, id);
end;
// added in gl4.2
public z_DrawTransformFeedbackInstanced_adr := GetFuncAdr('glDrawTransformFeedbackInstanced');
public 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);
begin
z_DrawTransformFeedbackInstanced_ovr_0(mode, id, instancecount);
end;
// added in gl4.0
public z_DrawTransformFeedbackStream_adr := GetFuncAdr('glDrawTransformFeedbackStream');
public 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);
begin
z_DrawTransformFeedbackStream_ovr_0(mode, id, stream);
end;
// added in gl4.2
public z_DrawTransformFeedbackStreamInstanced_adr := GetFuncAdr('glDrawTransformFeedbackStreamInstanced');
public 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);
begin
z_DrawTransformFeedbackStreamInstanced_ovr_0(mode, id, stream, instancecount);
end;
// added in gl1.0
private static procedure _z_Enable_ovr0(cap: EnableCap);
external 'opengl32.dll' name 'glEnable';
public static z_Enable_ovr0 := _z_Enable_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Enable(cap: EnableCap) := z_Enable_ovr0(cap);
// added in gl3.0
public z_Enablei_adr := GetFuncAdr('glEnablei');
public z_Enablei_ovr_0 := GetFuncOrNil&<procedure(target: EnableCap; index: UInt32)>(z_Enablei_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Enablei(target: EnableCap; index: UInt32);
begin
z_Enablei_ovr_0(target, index);
end;
// added in gl4.5
public z_EnableVertexArrayAttrib_adr := GetFuncAdr('glEnableVertexArrayAttrib');
public z_EnableVertexArrayAttrib_ovr_0 := GetFuncOrNil&<procedure(vaobj: VertexArrayName; index: UInt32)>(z_EnableVertexArrayAttrib_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EnableVertexArrayAttrib(vaobj: VertexArrayName; index: UInt32);
begin
z_EnableVertexArrayAttrib_ovr_0(vaobj, index);
end;
// added in gl2.0
public z_EnableVertexAttribArray_adr := GetFuncAdr('glEnableVertexAttribArray');
public z_EnableVertexAttribArray_ovr_0 := GetFuncOrNil&<procedure(index: UInt32)>(z_EnableVertexAttribArray_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EnableVertexAttribArray(index: UInt32);
begin
z_EnableVertexAttribArray_ovr_0(index);
end;
// added in gl3.0
public z_EndConditionalRender_adr := GetFuncAdr('glEndConditionalRender');
public z_EndConditionalRender_ovr_0 := GetFuncOrNil&<procedure>(z_EndConditionalRender_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndConditionalRender;
begin
z_EndConditionalRender_ovr_0;
end;
// added in gl1.5
public z_EndQuery_adr := GetFuncAdr('glEndQuery');
public z_EndQuery_ovr_0 := GetFuncOrNil&<procedure(target: QueryTarget)>(z_EndQuery_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndQuery(target: QueryTarget);
begin
z_EndQuery_ovr_0(target);
end;
// added in gl4.0
public z_EndQueryIndexed_adr := GetFuncAdr('glEndQueryIndexed');
public z_EndQueryIndexed_ovr_0 := GetFuncOrNil&<procedure(target: QueryTarget; index: UInt32)>(z_EndQueryIndexed_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndQueryIndexed(target: QueryTarget; index: UInt32);
begin
z_EndQueryIndexed_ovr_0(target, index);
end;
// added in gl3.0
public z_EndTransformFeedback_adr := GetFuncAdr('glEndTransformFeedback');
public z_EndTransformFeedback_ovr_0 := GetFuncOrNil&<procedure>(z_EndTransformFeedback_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndTransformFeedback;
begin
z_EndTransformFeedback_ovr_0;
end;
// added in gl3.2
public z_FenceSync_adr := GetFuncAdr('glFenceSync');
public 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;
begin
Result := z_FenceSync_ovr_0(condition, flags);
end;
// added in gl1.0
private static procedure _z_Finish_ovr0;
external 'opengl32.dll' name 'glFinish';
public static z_Finish_ovr0 := _z_Finish_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Finish := z_Finish_ovr0;
// added in gl1.0
private static procedure _z_Flush_ovr0;
external 'opengl32.dll' name 'glFlush';
public static z_Flush_ovr0 := _z_Flush_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Flush := z_Flush_ovr0;
// added in gl3.0
public z_FlushMappedBufferRange_adr := GetFuncAdr('glFlushMappedBufferRange');
public 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);
begin
z_FlushMappedBufferRange_ovr_0(target, offset, length);
end;
// added in gl4.5
public z_FlushMappedNamedBufferRange_adr := GetFuncAdr('glFlushMappedNamedBufferRange');
public 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);
begin
z_FlushMappedNamedBufferRange_ovr_0(buffer, offset, length);
end;
// added in gl4.3
public z_FramebufferParameteri_adr := GetFuncAdr('glFramebufferParameteri');
public 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);
begin
z_FramebufferParameteri_ovr_0(target, pname, param);
end;
// added in gl3.0
public z_FramebufferRenderbuffer_adr := GetFuncAdr('glFramebufferRenderbuffer');
public 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);
begin
z_FramebufferRenderbuffer_ovr_0(target, attachment, _renderbuffertarget, renderbuffer);
end;
// added in gl3.2
public z_FramebufferTexture_adr := GetFuncAdr('glFramebufferTexture');
public 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);
begin
z_FramebufferTexture_ovr_0(target, attachment, texture, level);
end;
// added in gl3.0
public z_FramebufferTexture1D_adr := GetFuncAdr('glFramebufferTexture1D');
public 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);
begin
z_FramebufferTexture1D_ovr_0(target, attachment, textarget, texture, level);
end;
// added in gl3.0
public z_FramebufferTexture2D_adr := GetFuncAdr('glFramebufferTexture2D');
public 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);
begin
z_FramebufferTexture2D_ovr_0(target, attachment, textarget, texture, level);
end;
// added in gl3.0
public z_FramebufferTexture3D_adr := GetFuncAdr('glFramebufferTexture3D');
public 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);
begin
z_FramebufferTexture3D_ovr_0(target, attachment, textarget, texture, level, zoffset);
end;
// added in gl3.0
public z_FramebufferTextureLayer_adr := GetFuncAdr('glFramebufferTextureLayer');
public 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);
begin
z_FramebufferTextureLayer_ovr_0(target, attachment, texture, level, layer);
end;
// added in gl1.0
private static procedure _z_FrontFace_ovr0(mode: FrontFaceDirection);
external 'opengl32.dll' name 'glFrontFace';
public static z_FrontFace_ovr0 := _z_FrontFace_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FrontFace(mode: FrontFaceDirection) := z_FrontFace_ovr0(mode);
// added in gl1.5
public z_GenBuffers_adr := GetFuncAdr('glGenBuffers');
public z_GenBuffers_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var buffers: BufferName)>(z_GenBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenBuffers(n: Int32; buffers: array of BufferName);
begin
z_GenBuffers_ovr_0(n, buffers[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenBuffers(n: Int32; var buffers: BufferName);
begin
z_GenBuffers_ovr_0(n, buffers);
end;
public z_GenBuffers_ovr_2 := GetFuncOrNil&<procedure(n: Int32; buffers: IntPtr)>(z_GenBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenBuffers(n: Int32; buffers: IntPtr);
begin
z_GenBuffers_ovr_2(n, buffers);
end;
// added in gl3.0
public z_GenerateMipmap_adr := GetFuncAdr('glGenerateMipmap');
public z_GenerateMipmap_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget)>(z_GenerateMipmap_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenerateMipmap(target: TextureTarget);
begin
z_GenerateMipmap_ovr_0(target);
end;
// added in gl4.5
public z_GenerateTextureMipmap_adr := GetFuncAdr('glGenerateTextureMipmap');
public z_GenerateTextureMipmap_ovr_0 := GetFuncOrNil&<procedure(texture: TextureName)>(z_GenerateTextureMipmap_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenerateTextureMipmap(texture: TextureName);
begin
z_GenerateTextureMipmap_ovr_0(texture);
end;
// added in gl3.0
public z_GenFramebuffers_adr := GetFuncAdr('glGenFramebuffers');
public z_GenFramebuffers_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var framebuffers: UInt32)>(z_GenFramebuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenFramebuffers(n: Int32; framebuffers: array of UInt32);
begin
z_GenFramebuffers_ovr_0(n, framebuffers[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenFramebuffers(n: Int32; var framebuffers: UInt32);
begin
z_GenFramebuffers_ovr_0(n, framebuffers);
end;
public z_GenFramebuffers_ovr_2 := GetFuncOrNil&<procedure(n: Int32; framebuffers: IntPtr)>(z_GenFramebuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenFramebuffers(n: Int32; framebuffers: IntPtr);
begin
z_GenFramebuffers_ovr_2(n, framebuffers);
end;
// added in gl4.1
public z_GenProgramPipelines_adr := GetFuncAdr('glGenProgramPipelines');
public z_GenProgramPipelines_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var pipelines: UInt32)>(z_GenProgramPipelines_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenProgramPipelines(n: Int32; pipelines: array of UInt32);
begin
z_GenProgramPipelines_ovr_0(n, pipelines[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenProgramPipelines(n: Int32; var pipelines: UInt32);
begin
z_GenProgramPipelines_ovr_0(n, pipelines);
end;
public z_GenProgramPipelines_ovr_2 := GetFuncOrNil&<procedure(n: Int32; pipelines: IntPtr)>(z_GenProgramPipelines_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenProgramPipelines(n: Int32; pipelines: IntPtr);
begin
z_GenProgramPipelines_ovr_2(n, pipelines);
end;
// added in gl1.5
public z_GenQueries_adr := GetFuncAdr('glGenQueries');
public z_GenQueries_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var ids: UInt32)>(z_GenQueries_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenQueries(n: Int32; ids: array of UInt32);
begin
z_GenQueries_ovr_0(n, ids[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenQueries(n: Int32; var ids: UInt32);
begin
z_GenQueries_ovr_0(n, ids);
end;
public z_GenQueries_ovr_2 := GetFuncOrNil&<procedure(n: Int32; ids: IntPtr)>(z_GenQueries_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenQueries(n: Int32; ids: IntPtr);
begin
z_GenQueries_ovr_2(n, ids);
end;
// added in gl3.0
public z_GenRenderbuffers_adr := GetFuncAdr('glGenRenderbuffers');
public z_GenRenderbuffers_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var renderbuffers: UInt32)>(z_GenRenderbuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenRenderbuffers(n: Int32; renderbuffers: array of UInt32);
begin
z_GenRenderbuffers_ovr_0(n, renderbuffers[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenRenderbuffers(n: Int32; var renderbuffers: UInt32);
begin
z_GenRenderbuffers_ovr_0(n, renderbuffers);
end;
public z_GenRenderbuffers_ovr_2 := GetFuncOrNil&<procedure(n: Int32; renderbuffers: IntPtr)>(z_GenRenderbuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenRenderbuffers(n: Int32; renderbuffers: IntPtr);
begin
z_GenRenderbuffers_ovr_2(n, renderbuffers);
end;
// added in gl3.3
public z_GenSamplers_adr := GetFuncAdr('glGenSamplers');
public z_GenSamplers_ovr_0 := GetFuncOrNil&<procedure(count: Int32; var samplers: UInt32)>(z_GenSamplers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenSamplers(count: Int32; samplers: array of UInt32);
begin
z_GenSamplers_ovr_0(count, samplers[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenSamplers(count: Int32; var samplers: UInt32);
begin
z_GenSamplers_ovr_0(count, samplers);
end;
public z_GenSamplers_ovr_2 := GetFuncOrNil&<procedure(count: Int32; samplers: IntPtr)>(z_GenSamplers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenSamplers(count: Int32; samplers: IntPtr);
begin
z_GenSamplers_ovr_2(count, samplers);
end;
// added in gl1.1
private static procedure _z_GenTextures_ovr0(n: Int32; [MarshalAs(UnmanagedType.LPArray)] textures: array of UInt32);
external 'opengl32.dll' name 'glGenTextures';
public static z_GenTextures_ovr0 := _z_GenTextures_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenTextures(n: Int32; textures: array of UInt32) := z_GenTextures_ovr0(n, textures);
private static procedure _z_GenTextures_ovr1(n: Int32; var textures: UInt32);
external 'opengl32.dll' name 'glGenTextures';
public static z_GenTextures_ovr1 := _z_GenTextures_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenTextures(n: Int32; var textures: UInt32) := z_GenTextures_ovr1(n, textures);
private static procedure _z_GenTextures_ovr2(n: Int32; textures: IntPtr);
external 'opengl32.dll' name 'glGenTextures';
public static z_GenTextures_ovr2 := _z_GenTextures_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenTextures(n: Int32; textures: IntPtr) := z_GenTextures_ovr2(n, textures);
// added in gl4.0
public z_GenTransformFeedbacks_adr := GetFuncAdr('glGenTransformFeedbacks');
public z_GenTransformFeedbacks_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var ids: UInt32)>(z_GenTransformFeedbacks_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenTransformFeedbacks(n: Int32; ids: array of UInt32);
begin
z_GenTransformFeedbacks_ovr_0(n, ids[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenTransformFeedbacks(n: Int32; var ids: UInt32);
begin
z_GenTransformFeedbacks_ovr_0(n, ids);
end;
public z_GenTransformFeedbacks_ovr_2 := GetFuncOrNil&<procedure(n: Int32; ids: IntPtr)>(z_GenTransformFeedbacks_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenTransformFeedbacks(n: Int32; ids: IntPtr);
begin
z_GenTransformFeedbacks_ovr_2(n, ids);
end;
// added in gl3.0
public z_GenVertexArrays_adr := GetFuncAdr('glGenVertexArrays');
public z_GenVertexArrays_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var arrays: UInt32)>(z_GenVertexArrays_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenVertexArrays(n: Int32; arrays: array of UInt32);
begin
z_GenVertexArrays_ovr_0(n, arrays[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenVertexArrays(n: Int32; var arrays: UInt32);
begin
z_GenVertexArrays_ovr_0(n, arrays);
end;
public z_GenVertexArrays_ovr_2 := GetFuncOrNil&<procedure(n: Int32; arrays: IntPtr)>(z_GenVertexArrays_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenVertexArrays(n: Int32; arrays: IntPtr);
begin
z_GenVertexArrays_ovr_2(n, arrays);
end;
// added in gl4.2
public z_GetActiveAtomicCounterBufferiv_adr := GetFuncAdr('glGetActiveAtomicCounterBufferiv');
public z_GetActiveAtomicCounterBufferiv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; bufferIndex: UInt32; pname: AtomicCounterBufferPName; var ¶ms: Int32)>(z_GetActiveAtomicCounterBufferiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAtomicCounterBufferiv(&program: UInt32; bufferIndex: UInt32; pname: AtomicCounterBufferPName; ¶ms: array of Int32);
begin
z_GetActiveAtomicCounterBufferiv_ovr_0(&program, bufferIndex, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAtomicCounterBufferiv(&program: UInt32; bufferIndex: UInt32; pname: AtomicCounterBufferPName; var ¶ms: Int32);
begin
z_GetActiveAtomicCounterBufferiv_ovr_0(&program, bufferIndex, pname, ¶ms);
end;
public 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);
begin
z_GetActiveAtomicCounterBufferiv_ovr_2(&program, bufferIndex, pname, ¶ms);
end;
// added in gl2.0
public z_GetActiveAttrib_adr := GetFuncAdr('glGetActiveAttrib');
public 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);
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);
begin
z_GetActiveAttrib_ovr_0(&program, index, bufSize, length[0], size[0], &type[0], name);
end;
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);
begin
z_GetActiveAttrib_ovr_0(&program, index, bufSize, length[0], size[0], &type, name);
end;
public 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);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: array of Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveAttrib_ovr_2(&program, index, bufSize, length[0], size[0], &type, name);
end;
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);
begin
z_GetActiveAttrib_ovr_0(&program, index, bufSize, length[0], size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; var size: Int32; var &type: AttributeType; name: IntPtr);
begin
z_GetActiveAttrib_ovr_0(&program, index, bufSize, length[0], size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; var size: Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveAttrib_ovr_2(&program, index, bufSize, length[0], size, &type, name);
end;
public 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);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: IntPtr; &type: array of AttributeType; name: IntPtr);
begin
z_GetActiveAttrib_ovr_6(&program, index, bufSize, length[0], size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: IntPtr; var &type: AttributeType; name: IntPtr);
begin
z_GetActiveAttrib_ovr_6(&program, index, bufSize, length[0], size, &type, name);
end;
public z_GetActiveAttrib_ovr_8 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; 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);
begin
z_GetActiveAttrib_ovr_8(&program, index, bufSize, length[0], size, &type, name);
end;
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);
begin
z_GetActiveAttrib_ovr_0(&program, index, bufSize, length, size[0], &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: array of Int32; var &type: AttributeType; name: IntPtr);
begin
z_GetActiveAttrib_ovr_0(&program, index, bufSize, length, size[0], &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: array of Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveAttrib_ovr_2(&program, index, bufSize, length, size[0], &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: array of AttributeType; name: IntPtr);
begin
z_GetActiveAttrib_ovr_0(&program, index, bufSize, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; var &type: AttributeType; name: IntPtr);
begin
z_GetActiveAttrib_ovr_0(&program, index, bufSize, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveAttrib_ovr_2(&program, index, bufSize, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: array of AttributeType; name: IntPtr);
begin
z_GetActiveAttrib_ovr_6(&program, index, bufSize, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; var &type: AttributeType; name: IntPtr);
begin
z_GetActiveAttrib_ovr_6(&program, index, bufSize, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr);
begin
z_GetActiveAttrib_ovr_8(&program, index, bufSize, length, size, &type, name);
end;
public 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);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: array of Int32; &type: array of AttributeType; name: IntPtr);
begin
z_GetActiveAttrib_ovr_18(&program, index, bufSize, length, size[0], &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: array of Int32; var &type: AttributeType; name: IntPtr);
begin
z_GetActiveAttrib_ovr_18(&program, index, bufSize, length, size[0], &type, name);
end;
public z_GetActiveAttrib_ovr_20 := 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: IntPtr; size: array of Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveAttrib_ovr_20(&program, index, bufSize, length, size[0], &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: array of AttributeType; name: IntPtr);
begin
z_GetActiveAttrib_ovr_18(&program, index, bufSize, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: AttributeType; name: IntPtr);
begin
z_GetActiveAttrib_ovr_18(&program, index, bufSize, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveAttrib_ovr_20(&program, index, bufSize, length, size, &type, name);
end;
public z_GetActiveAttrib_ovr_24 := 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: IntPtr; &type: array of AttributeType; name: IntPtr);
begin
z_GetActiveAttrib_ovr_24(&program, index, bufSize, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttrib(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: AttributeType; name: IntPtr);
begin
z_GetActiveAttrib_ovr_24(&program, index, bufSize, length, size, &type, name);
end;
public 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);
begin
z_GetActiveAttrib_ovr_26(&program, index, bufSize, length, size, &type, name);
end;
// added in gl4.0
public z_GetActiveSubroutineName_adr := GetFuncAdr('glGetActiveSubroutineName');
public z_GetActiveSubroutineName_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; var length: Int32; 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);
begin
z_GetActiveSubroutineName_ovr_0(&program, _shadertype, index, bufSize, length[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveSubroutineName(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; var length: Int32; name: IntPtr);
begin
z_GetActiveSubroutineName_ovr_0(&program, _shadertype, index, bufSize, length, name);
end;
public 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);
begin
z_GetActiveSubroutineName_ovr_2(&program, _shadertype, index, bufSize, length, name);
end;
// added in gl4.0
public z_GetActiveSubroutineUniformiv_adr := GetFuncAdr('glGetActiveSubroutineUniformiv');
public z_GetActiveSubroutineUniformiv_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; _shadertype: ShaderType; index: UInt32; pname: SubroutineParameterName; var values: Int32)>(z_GetActiveSubroutineUniformiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveSubroutineUniformiv(&program: ProgramName; _shadertype: ShaderType; index: UInt32; pname: SubroutineParameterName; values: array of Int32);
begin
z_GetActiveSubroutineUniformiv_ovr_0(&program, _shadertype, index, pname, values[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveSubroutineUniformiv(&program: ProgramName; _shadertype: ShaderType; index: UInt32; pname: SubroutineParameterName; var values: Int32);
begin
z_GetActiveSubroutineUniformiv_ovr_0(&program, _shadertype, index, pname, values);
end;
public 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);
begin
z_GetActiveSubroutineUniformiv_ovr_2(&program, _shadertype, index, pname, values);
end;
// added in gl4.0
public z_GetActiveSubroutineUniformName_adr := GetFuncAdr('glGetActiveSubroutineUniformName');
public z_GetActiveSubroutineUniformName_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; var length: Int32; 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);
begin
z_GetActiveSubroutineUniformName_ovr_0(&program, _shadertype, index, bufSize, length[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveSubroutineUniformName(&program: UInt32; _shadertype: ShaderType; index: UInt32; bufSize: Int32; var length: Int32; name: IntPtr);
begin
z_GetActiveSubroutineUniformName_ovr_0(&program, _shadertype, index, bufSize, length, name);
end;
public 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);
begin
z_GetActiveSubroutineUniformName_ovr_2(&program, _shadertype, index, bufSize, length, name);
end;
// added in gl2.0
public z_GetActiveUniform_adr := GetFuncAdr('glGetActiveUniform');
public 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);
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);
begin
z_GetActiveUniform_ovr_0(&program, index, bufSize, length[0], size[0], &type[0], name);
end;
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);
begin
z_GetActiveUniform_ovr_0(&program, index, bufSize, length[0], size[0], &type, name);
end;
public 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);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: array of Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveUniform_ovr_2(&program, index, bufSize, length[0], size[0], &type, name);
end;
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);
begin
z_GetActiveUniform_ovr_0(&program, index, bufSize, length[0], size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; var size: Int32; var &type: UniformType; name: IntPtr);
begin
z_GetActiveUniform_ovr_0(&program, index, bufSize, length[0], size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; var size: Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveUniform_ovr_2(&program, index, bufSize, length[0], size, &type, name);
end;
public 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);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: IntPtr; &type: array of UniformType; name: IntPtr);
begin
z_GetActiveUniform_ovr_6(&program, index, bufSize, length[0], size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: IntPtr; var &type: UniformType; name: IntPtr);
begin
z_GetActiveUniform_ovr_6(&program, index, bufSize, length[0], size, &type, name);
end;
public z_GetActiveUniform_ovr_8 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; 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);
begin
z_GetActiveUniform_ovr_8(&program, index, bufSize, length[0], size, &type, name);
end;
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);
begin
z_GetActiveUniform_ovr_0(&program, index, bufSize, length, size[0], &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: array of Int32; var &type: UniformType; name: IntPtr);
begin
z_GetActiveUniform_ovr_0(&program, index, bufSize, length, size[0], &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: array of Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveUniform_ovr_2(&program, index, bufSize, length, size[0], &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: array of UniformType; name: IntPtr);
begin
z_GetActiveUniform_ovr_0(&program, index, bufSize, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; var &type: UniformType; name: IntPtr);
begin
z_GetActiveUniform_ovr_0(&program, index, bufSize, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveUniform_ovr_2(&program, index, bufSize, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: array of UniformType; name: IntPtr);
begin
z_GetActiveUniform_ovr_6(&program, index, bufSize, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; var &type: UniformType; name: IntPtr);
begin
z_GetActiveUniform_ovr_6(&program, index, bufSize, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr);
begin
z_GetActiveUniform_ovr_8(&program, index, bufSize, length, size, &type, name);
end;
public 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);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: array of Int32; &type: array of UniformType; name: IntPtr);
begin
z_GetActiveUniform_ovr_18(&program, index, bufSize, length, size[0], &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: array of Int32; var &type: UniformType; name: IntPtr);
begin
z_GetActiveUniform_ovr_18(&program, index, bufSize, length, size[0], &type, name);
end;
public z_GetActiveUniform_ovr_20 := 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: IntPtr; size: array of Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveUniform_ovr_20(&program, index, bufSize, length, size[0], &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: array of UniformType; name: IntPtr);
begin
z_GetActiveUniform_ovr_18(&program, index, bufSize, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: UniformType; name: IntPtr);
begin
z_GetActiveUniform_ovr_18(&program, index, bufSize, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveUniform_ovr_20(&program, index, bufSize, length, size, &type, name);
end;
public z_GetActiveUniform_ovr_24 := 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: IntPtr; &type: array of UniformType; name: IntPtr);
begin
z_GetActiveUniform_ovr_24(&program, index, bufSize, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniform(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: UniformType; name: IntPtr);
begin
z_GetActiveUniform_ovr_24(&program, index, bufSize, length, size, &type, name);
end;
public 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);
begin
z_GetActiveUniform_ovr_26(&program, index, bufSize, length, size, &type, name);
end;
// added in gl3.1
public z_GetActiveUniformBlockiv_adr := GetFuncAdr('glGetActiveUniformBlockiv');
public z_GetActiveUniformBlockiv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; uniformBlockIndex: UInt32; pname: UniformBlockPName; var ¶ms: Int32)>(z_GetActiveUniformBlockiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformBlockiv(&program: UInt32; uniformBlockIndex: UInt32; pname: UniformBlockPName; ¶ms: array of Int32);
begin
z_GetActiveUniformBlockiv_ovr_0(&program, uniformBlockIndex, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformBlockiv(&program: UInt32; uniformBlockIndex: UInt32; pname: UniformBlockPName; var ¶ms: Int32);
begin
z_GetActiveUniformBlockiv_ovr_0(&program, uniformBlockIndex, pname, ¶ms);
end;
public 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);
begin
z_GetActiveUniformBlockiv_ovr_2(&program, uniformBlockIndex, pname, ¶ms);
end;
// added in gl3.1
public z_GetActiveUniformBlockName_adr := GetFuncAdr('glGetActiveUniformBlockName');
public z_GetActiveUniformBlockName_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; uniformBlockIndex: UInt32; bufSize: Int32; var length: Int32; uniformBlockName: IntPtr)>(z_GetActiveUniformBlockName_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformBlockName(&program: UInt32; uniformBlockIndex: UInt32; bufSize: Int32; length: array of Int32; uniformBlockName: IntPtr);
begin
z_GetActiveUniformBlockName_ovr_0(&program, uniformBlockIndex, bufSize, length[0], uniformBlockName);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformBlockName(&program: UInt32; uniformBlockIndex: UInt32; bufSize: Int32; var length: Int32; uniformBlockName: IntPtr);
begin
z_GetActiveUniformBlockName_ovr_0(&program, uniformBlockIndex, bufSize, length, uniformBlockName);
end;
public 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);
begin
z_GetActiveUniformBlockName_ovr_2(&program, uniformBlockIndex, bufSize, length, uniformBlockName);
end;
// added in gl3.1
public z_GetActiveUniformName_adr := GetFuncAdr('glGetActiveUniformName');
public z_GetActiveUniformName_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; uniformIndex: UInt32; bufSize: Int32; var length: Int32; uniformName: IntPtr)>(z_GetActiveUniformName_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformName(&program: UInt32; uniformIndex: UInt32; bufSize: Int32; length: array of Int32; uniformName: IntPtr);
begin
z_GetActiveUniformName_ovr_0(&program, uniformIndex, bufSize, length[0], uniformName);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformName(&program: UInt32; uniformIndex: UInt32; bufSize: Int32; var length: Int32; uniformName: IntPtr);
begin
z_GetActiveUniformName_ovr_0(&program, uniformIndex, bufSize, length, uniformName);
end;
public 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);
begin
z_GetActiveUniformName_ovr_2(&program, uniformIndex, bufSize, length, uniformName);
end;
// added in gl3.1
public z_GetActiveUniformsiv_adr := GetFuncAdr('glGetActiveUniformsiv');
public z_GetActiveUniformsiv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; uniformCount: Int32; var uniformIndices: UInt32; pname: UniformPName; var ¶ms: Int32)>(z_GetActiveUniformsiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformsiv(&program: UInt32; uniformCount: Int32; uniformIndices: array of UInt32; pname: UniformPName; ¶ms: array of Int32);
begin
z_GetActiveUniformsiv_ovr_0(&program, uniformCount, uniformIndices[0], pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformsiv(&program: UInt32; uniformCount: Int32; uniformIndices: array of UInt32; pname: UniformPName; var ¶ms: Int32);
begin
z_GetActiveUniformsiv_ovr_0(&program, uniformCount, uniformIndices[0], pname, ¶ms);
end;
public z_GetActiveUniformsiv_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; uniformCount: Int32; var uniformIndices: UInt32; 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);
begin
z_GetActiveUniformsiv_ovr_2(&program, uniformCount, uniformIndices[0], pname, ¶ms);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformsiv(&program: UInt32; uniformCount: Int32; var uniformIndices: UInt32; pname: UniformPName; ¶ms: array of Int32);
begin
z_GetActiveUniformsiv_ovr_0(&program, uniformCount, uniformIndices, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformsiv(&program: UInt32; uniformCount: Int32; var uniformIndices: UInt32; pname: UniformPName; var ¶ms: Int32);
begin
z_GetActiveUniformsiv_ovr_0(&program, uniformCount, uniformIndices, pname, ¶ms);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformsiv(&program: UInt32; uniformCount: Int32; var uniformIndices: UInt32; pname: UniformPName; ¶ms: IntPtr);
begin
z_GetActiveUniformsiv_ovr_2(&program, uniformCount, uniformIndices, pname, ¶ms);
end;
public z_GetActiveUniformsiv_ovr_6 := 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: IntPtr; pname: UniformPName; ¶ms: array of Int32);
begin
z_GetActiveUniformsiv_ovr_6(&program, uniformCount, uniformIndices, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformsiv(&program: UInt32; uniformCount: Int32; uniformIndices: IntPtr; pname: UniformPName; var ¶ms: Int32);
begin
z_GetActiveUniformsiv_ovr_6(&program, uniformCount, uniformIndices, pname, ¶ms);
end;
public 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);
begin
z_GetActiveUniformsiv_ovr_8(&program, uniformCount, uniformIndices, pname, ¶ms);
end;
// added in gl2.0
public z_GetAttachedShaders_adr := GetFuncAdr('glGetAttachedShaders');
public z_GetAttachedShaders_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; maxCount: Int32; var count: Int32; var shaders: UInt32)>(z_GetAttachedShaders_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedShaders(&program: UInt32; maxCount: Int32; count: array of Int32; shaders: array of UInt32);
begin
z_GetAttachedShaders_ovr_0(&program, maxCount, count[0], shaders[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedShaders(&program: UInt32; maxCount: Int32; count: array of Int32; var shaders: UInt32);
begin
z_GetAttachedShaders_ovr_0(&program, maxCount, count[0], shaders);
end;
public z_GetAttachedShaders_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; maxCount: Int32; var count: Int32; shaders: IntPtr)>(z_GetAttachedShaders_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedShaders(&program: UInt32; maxCount: Int32; count: array of Int32; shaders: IntPtr);
begin
z_GetAttachedShaders_ovr_2(&program, maxCount, count[0], shaders);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedShaders(&program: UInt32; maxCount: Int32; var count: Int32; shaders: array of UInt32);
begin
z_GetAttachedShaders_ovr_0(&program, maxCount, count, shaders[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedShaders(&program: UInt32; maxCount: Int32; var count: Int32; var shaders: UInt32);
begin
z_GetAttachedShaders_ovr_0(&program, maxCount, count, shaders);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedShaders(&program: UInt32; maxCount: Int32; var count: Int32; shaders: IntPtr);
begin
z_GetAttachedShaders_ovr_2(&program, maxCount, count, shaders);
end;
public z_GetAttachedShaders_ovr_6 := 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: IntPtr; shaders: array of UInt32);
begin
z_GetAttachedShaders_ovr_6(&program, maxCount, count, shaders[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedShaders(&program: UInt32; maxCount: Int32; count: IntPtr; var shaders: UInt32);
begin
z_GetAttachedShaders_ovr_6(&program, maxCount, count, shaders);
end;
public 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);
begin
z_GetAttachedShaders_ovr_8(&program, maxCount, count, shaders);
end;
// added in gl2.0
public z_GetAttribLocation_adr := GetFuncAdr('glGetAttribLocation');
public 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;
begin
Result := z_GetAttribLocation_ovr_0(&program, name);
end;
// added in gl3.0
public z_GetBooleani_v_adr := GetFuncAdr('glGetBooleani_v');
public z_GetBooleani_v_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; var data: boolean)>(z_GetBooleani_v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleani_v(target: BufferTargetARB; index: UInt32; data: array of boolean);
begin
z_GetBooleani_v_ovr_0(target, index, data[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleani_v(target: BufferTargetARB; index: UInt32; var data: boolean);
begin
z_GetBooleani_v_ovr_0(target, index, data);
end;
public 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);
begin
z_GetBooleani_v_ovr_2(target, index, data);
end;
// added in gl1.0
private static procedure _z_GetBooleanv_ovr0(pname: GetPName; [MarshalAs(UnmanagedType.LPArray)] data: array of boolean);
external 'opengl32.dll' name 'glGetBooleanv';
public static z_GetBooleanv_ovr0 := _z_GetBooleanv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanv(pname: GetPName; data: array of boolean) := z_GetBooleanv_ovr0(pname, data);
private static procedure _z_GetBooleanv_ovr1(pname: GetPName; var data: boolean);
external 'opengl32.dll' name 'glGetBooleanv';
public static z_GetBooleanv_ovr1 := _z_GetBooleanv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanv(pname: GetPName; var data: boolean) := z_GetBooleanv_ovr1(pname, data);
private static procedure _z_GetBooleanv_ovr2(pname: GetPName; data: IntPtr);
external 'opengl32.dll' name 'glGetBooleanv';
public static z_GetBooleanv_ovr2 := _z_GetBooleanv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanv(pname: GetPName; data: IntPtr) := z_GetBooleanv_ovr2(pname, data);
// added in gl3.2
public z_GetBufferParameteri64v_adr := GetFuncAdr('glGetBufferParameteri64v');
public z_GetBufferParameteri64v_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPNameARB; var ¶ms: Int64)>(z_GetBufferParameteri64v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameteri64v(target: BufferTargetARB; pname: BufferPNameARB; ¶ms: array of Int64);
begin
z_GetBufferParameteri64v_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameteri64v(target: BufferTargetARB; pname: BufferPNameARB; var ¶ms: Int64);
begin
z_GetBufferParameteri64v_ovr_0(target, pname, ¶ms);
end;
public 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);
begin
z_GetBufferParameteri64v_ovr_2(target, pname, ¶ms);
end;
// added in gl1.5
public z_GetBufferParameteriv_adr := GetFuncAdr('glGetBufferParameteriv');
public z_GetBufferParameteriv_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPNameARB; var ¶ms: Int32)>(z_GetBufferParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameteriv(target: BufferTargetARB; pname: BufferPNameARB; ¶ms: array of Int32);
begin
z_GetBufferParameteriv_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameteriv(target: BufferTargetARB; pname: BufferPNameARB; var ¶ms: Int32);
begin
z_GetBufferParameteriv_ovr_0(target, pname, ¶ms);
end;
public 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);
begin
z_GetBufferParameteriv_ovr_2(target, pname, ¶ms);
end;
// added in gl1.5
public z_GetBufferPointerv_adr := GetFuncAdr('glGetBufferPointerv');
public z_GetBufferPointerv_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPointerNameARB; var ¶ms: IntPtr)>(z_GetBufferPointerv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferPointerv(target: BufferTargetARB; pname: BufferPointerNameARB; ¶ms: array of IntPtr);
begin
z_GetBufferPointerv_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferPointerv(target: BufferTargetARB; pname: BufferPointerNameARB; var ¶ms: IntPtr);
begin
z_GetBufferPointerv_ovr_0(target, pname, ¶ms);
end;
public 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);
begin
z_GetBufferPointerv_ovr_2(target, pname, ¶ms);
end;
// added in gl1.5
public z_GetBufferSubData_adr := GetFuncAdr('glGetBufferSubData');
public 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);
begin
z_GetBufferSubData_ovr_0(target, offset, size, data);
end;
// added in gl1.3
public z_GetCompressedTexImage_adr := GetFuncAdr('glGetCompressedTexImage');
public 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);
begin
z_GetCompressedTexImage_ovr_0(target, level, img);
end;
// added in gl4.5
public z_GetCompressedTextureImage_adr := GetFuncAdr('glGetCompressedTextureImage');
public 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);
begin
z_GetCompressedTextureImage_ovr_0(texture, level, bufSize, pixels);
end;
// added in gl4.5
public z_GetCompressedTextureSubImage_adr := GetFuncAdr('glGetCompressedTextureSubImage');
public 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);
begin
z_GetCompressedTextureSubImage_ovr_0(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels);
end;
// added in gl4.3
public z_GetDebugMessageLog_adr := GetFuncAdr('glGetDebugMessageLog');
public 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;
begin
Result := z_GetDebugMessageLog_ovr_0(count, bufSize, sources, types, ids, severities, lengths, messageLog);
end;
public 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;
begin
Result := z_GetDebugMessageLog_ovr_1(count, bufSize, sources, types, ids, severities, lengths, messageLog);
end;
// added in gl4.1
public z_GetDoublei_v_adr := GetFuncAdr('glGetDoublei_v');
public z_GetDoublei_v_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; var data: real)>(z_GetDoublei_v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDoublei_v(target: DummyEnum; index: UInt32; data: array of real);
begin
z_GetDoublei_v_ovr_0(target, index, data[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDoublei_v(target: DummyEnum; index: UInt32; var data: real);
begin
z_GetDoublei_v_ovr_0(target, index, data);
end;
public 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);
begin
z_GetDoublei_v_ovr_2(target, index, data);
end;
// added in gl1.0
private static procedure _z_GetDoublev_ovr0(pname: GetPName; [MarshalAs(UnmanagedType.LPArray)] data: array of real);
external 'opengl32.dll' name 'glGetDoublev';
public static z_GetDoublev_ovr0 := _z_GetDoublev_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDoublev(pname: GetPName; data: array of real) := z_GetDoublev_ovr0(pname, data);
private static procedure _z_GetDoublev_ovr1(pname: GetPName; var data: real);
external 'opengl32.dll' name 'glGetDoublev';
public static z_GetDoublev_ovr1 := _z_GetDoublev_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDoublev(pname: GetPName; var data: real) := z_GetDoublev_ovr1(pname, data);
private static procedure _z_GetDoublev_ovr2(pname: GetPName; data: IntPtr);
external 'opengl32.dll' name 'glGetDoublev';
public static z_GetDoublev_ovr2 := _z_GetDoublev_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDoublev(pname: GetPName; data: IntPtr) := z_GetDoublev_ovr2(pname, data);
// added in gl1.0
private static function _z_GetError_ovr0: ErrorCode;
external 'opengl32.dll' name 'glGetError';
public static z_GetError_ovr0: function: ErrorCode := _z_GetError_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetError: ErrorCode := z_GetError_ovr0;
// added in gl4.1
public z_GetFloati_v_adr := GetFuncAdr('glGetFloati_v');
public z_GetFloati_v_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; var data: single)>(z_GetFloati_v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFloati_v(target: DummyEnum; index: UInt32; data: array of single);
begin
z_GetFloati_v_ovr_0(target, index, data[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFloati_v(target: DummyEnum; index: UInt32; var data: single);
begin
z_GetFloati_v_ovr_0(target, index, data);
end;
public 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);
begin
z_GetFloati_v_ovr_2(target, index, data);
end;
// added in gl1.0
private static procedure _z_GetFloatv_ovr0(pname: GetPName; [MarshalAs(UnmanagedType.LPArray)] data: array of single);
external 'opengl32.dll' name 'glGetFloatv';
public static z_GetFloatv_ovr0 := _z_GetFloatv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFloatv(pname: GetPName; data: array of single) := z_GetFloatv_ovr0(pname, data);
private static procedure _z_GetFloatv_ovr1(pname: GetPName; var data: single);
external 'opengl32.dll' name 'glGetFloatv';
public static z_GetFloatv_ovr1 := _z_GetFloatv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFloatv(pname: GetPName; var data: single) := z_GetFloatv_ovr1(pname, data);
private static procedure _z_GetFloatv_ovr2(pname: GetPName; data: IntPtr);
external 'opengl32.dll' name 'glGetFloatv';
public static z_GetFloatv_ovr2 := _z_GetFloatv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFloatv(pname: GetPName; data: IntPtr) := z_GetFloatv_ovr2(pname, data);
// added in gl3.3
public z_GetFragDataIndex_adr := GetFuncAdr('glGetFragDataIndex');
public 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;
begin
Result := z_GetFragDataIndex_ovr_0(&program, name);
end;
// added in gl3.0
public z_GetFragDataLocation_adr := GetFuncAdr('glGetFragDataLocation');
public 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;
begin
Result := z_GetFragDataLocation_ovr_0(&program, name);
end;
// added in gl3.0
public z_GetFramebufferAttachmentParameteriv_adr := GetFuncAdr('glGetFramebufferAttachmentParameteriv');
public z_GetFramebufferAttachmentParameteriv_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; var ¶ms: Int32)>(z_GetFramebufferAttachmentParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferAttachmentParameteriv(target: FramebufferTarget; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: array of Int32);
begin
z_GetFramebufferAttachmentParameteriv_ovr_0(target, attachment, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferAttachmentParameteriv(target: FramebufferTarget; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; var ¶ms: Int32);
begin
z_GetFramebufferAttachmentParameteriv_ovr_0(target, attachment, pname, ¶ms);
end;
public 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);
begin
z_GetFramebufferAttachmentParameteriv_ovr_2(target, attachment, pname, ¶ms);
end;
// added in gl4.3
public z_GetFramebufferParameteriv_adr := GetFuncAdr('glGetFramebufferParameteriv');
public z_GetFramebufferParameteriv_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; var ¶ms: Int32)>(z_GetFramebufferParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferParameteriv(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; ¶ms: array of Int32);
begin
z_GetFramebufferParameteriv_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferParameteriv(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; var ¶ms: Int32);
begin
z_GetFramebufferParameteriv_ovr_0(target, pname, ¶ms);
end;
public 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);
begin
z_GetFramebufferParameteriv_ovr_2(target, pname, ¶ms);
end;
// added in gl4.5
public z_GetGraphicsResetStatus_adr := GetFuncAdr('glGetGraphicsResetStatus');
public z_GetGraphicsResetStatus_ovr_0 := GetFuncOrNil&<function: GraphicsResetStatus>(z_GetGraphicsResetStatus_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetGraphicsResetStatus: GraphicsResetStatus;
begin
Result := z_GetGraphicsResetStatus_ovr_0;
end;
// added in gl3.2
public z_GetInteger64i_v_adr := GetFuncAdr('glGetInteger64i_v');
public z_GetInteger64i_v_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; var data: Int64)>(z_GetInteger64i_v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInteger64i_v(target: DummyEnum; index: UInt32; data: array of Int64);
begin
z_GetInteger64i_v_ovr_0(target, index, data[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInteger64i_v(target: DummyEnum; index: UInt32; var data: Int64);
begin
z_GetInteger64i_v_ovr_0(target, index, data);
end;
public 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);
begin
z_GetInteger64i_v_ovr_2(target, index, data);
end;
// added in gl3.2
public z_GetInteger64v_adr := GetFuncAdr('glGetInteger64v');
public z_GetInteger64v_ovr_0 := GetFuncOrNil&<procedure(pname: GetPName; var data: Int64)>(z_GetInteger64v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInteger64v(pname: GetPName; data: array of Int64);
begin
z_GetInteger64v_ovr_0(pname, data[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInteger64v(pname: GetPName; var data: Int64);
begin
z_GetInteger64v_ovr_0(pname, data);
end;
public z_GetInteger64v_ovr_2 := GetFuncOrNil&<procedure(pname: GetPName; data: IntPtr)>(z_GetInteger64v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInteger64v(pname: GetPName; data: IntPtr);
begin
z_GetInteger64v_ovr_2(pname, data);
end;
// added in gl3.1
public z_GetIntegeri_v_adr := GetFuncAdr('glGetIntegeri_v');
public z_GetIntegeri_v_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; var data: Int32)>(z_GetIntegeri_v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegeri_v(target: DummyEnum; index: UInt32; data: array of Int32);
begin
z_GetIntegeri_v_ovr_0(target, index, data[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegeri_v(target: DummyEnum; index: UInt32; var data: Int32);
begin
z_GetIntegeri_v_ovr_0(target, index, data);
end;
public 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);
begin
z_GetIntegeri_v_ovr_2(target, index, data);
end;
// added in gl1.0
private static procedure _z_GetIntegerv_ovr0(pname: GetPName; [MarshalAs(UnmanagedType.LPArray)] data: array of Int32);
external 'opengl32.dll' name 'glGetIntegerv';
public static z_GetIntegerv_ovr0 := _z_GetIntegerv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerv(pname: GetPName; data: array of Int32) := z_GetIntegerv_ovr0(pname, data);
private static procedure _z_GetIntegerv_ovr1(pname: GetPName; var data: Int32);
external 'opengl32.dll' name 'glGetIntegerv';
public static z_GetIntegerv_ovr1 := _z_GetIntegerv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerv(pname: GetPName; var data: Int32) := z_GetIntegerv_ovr1(pname, data);
private static procedure _z_GetIntegerv_ovr2(pname: GetPName; data: IntPtr);
external 'opengl32.dll' name 'glGetIntegerv';
public static z_GetIntegerv_ovr2 := _z_GetIntegerv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerv(pname: GetPName; data: IntPtr) := z_GetIntegerv_ovr2(pname, data);
// added in gl4.3
public z_GetInternalformati64v_adr := GetFuncAdr('glGetInternalformati64v');
public z_GetInternalformati64v_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; var ¶ms: Int64)>(z_GetInternalformati64v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInternalformati64v(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; ¶ms: array of Int64);
begin
z_GetInternalformati64v_ovr_0(target, _internalformat, pname, count, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInternalformati64v(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; var ¶ms: Int64);
begin
z_GetInternalformati64v_ovr_0(target, _internalformat, pname, count, ¶ms);
end;
public 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);
begin
z_GetInternalformati64v_ovr_2(target, _internalformat, pname, count, ¶ms);
end;
// added in gl4.2
public z_GetInternalformativ_adr := GetFuncAdr('glGetInternalformativ');
public z_GetInternalformativ_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; var ¶ms: Int32)>(z_GetInternalformativ_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInternalformativ(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; ¶ms: array of Int32);
begin
z_GetInternalformativ_ovr_0(target, _internalformat, pname, count, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInternalformativ(target: TextureTarget; _internalformat: InternalFormat; pname: InternalFormatPName; count: Int32; var ¶ms: Int32);
begin
z_GetInternalformativ_ovr_0(target, _internalformat, pname, count, ¶ms);
end;
public 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);
begin
z_GetInternalformativ_ovr_2(target, _internalformat, pname, count, ¶ms);
end;
// added in gl3.2
public z_GetMultisamplefv_adr := GetFuncAdr('glGetMultisamplefv');
public z_GetMultisamplefv_ovr_0 := GetFuncOrNil&<procedure(pname: GetMultisamplePNameNV; index: UInt32; var val: single)>(z_GetMultisamplefv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultisamplefv(pname: GetMultisamplePNameNV; index: UInt32; val: array of single);
begin
z_GetMultisamplefv_ovr_0(pname, index, val[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultisamplefv(pname: GetMultisamplePNameNV; index: UInt32; var val: single);
begin
z_GetMultisamplefv_ovr_0(pname, index, val);
end;
public 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);
begin
z_GetMultisamplefv_ovr_2(pname, index, val);
end;
// added in gl4.5
public z_GetNamedBufferParameteri64v_adr := GetFuncAdr('glGetNamedBufferParameteri64v');
public z_GetNamedBufferParameteri64v_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: Int64)>(z_GetNamedBufferParameteri64v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameteri64v(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: array of Int64);
begin
z_GetNamedBufferParameteri64v_ovr_0(buffer, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameteri64v(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: Int64);
begin
z_GetNamedBufferParameteri64v_ovr_0(buffer, pname, ¶ms);
end;
public 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);
begin
z_GetNamedBufferParameteri64v_ovr_2(buffer, pname, ¶ms);
end;
// added in gl4.5
public z_GetNamedBufferParameteriv_adr := GetFuncAdr('glGetNamedBufferParameteriv');
public z_GetNamedBufferParameteriv_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: Int32)>(z_GetNamedBufferParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameteriv(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: array of Int32);
begin
z_GetNamedBufferParameteriv_ovr_0(buffer, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameteriv(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: Int32);
begin
z_GetNamedBufferParameteriv_ovr_0(buffer, pname, ¶ms);
end;
public 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);
begin
z_GetNamedBufferParameteriv_ovr_2(buffer, pname, ¶ms);
end;
// added in gl4.5
public z_GetNamedBufferPointerv_adr := GetFuncAdr('glGetNamedBufferPointerv');
public z_GetNamedBufferPointerv_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: IntPtr)>(z_GetNamedBufferPointerv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferPointerv(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: array of IntPtr);
begin
z_GetNamedBufferPointerv_ovr_0(buffer, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferPointerv(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: IntPtr);
begin
z_GetNamedBufferPointerv_ovr_0(buffer, pname, ¶ms);
end;
public 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);
begin
z_GetNamedBufferPointerv_ovr_2(buffer, pname, ¶ms);
end;
// added in gl4.5
public z_GetNamedBufferSubData_adr := GetFuncAdr('glGetNamedBufferSubData');
public 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);
begin
z_GetNamedBufferSubData_ovr_0(buffer, offset, size, data);
end;
// added in gl4.5
public z_GetNamedFramebufferAttachmentParameteriv_adr := GetFuncAdr('glGetNamedFramebufferAttachmentParameteriv');
public z_GetNamedFramebufferAttachmentParameteriv_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; var ¶ms: Int32)>(z_GetNamedFramebufferAttachmentParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferAttachmentParameteriv(framebuffer: UInt32; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: array of Int32);
begin
z_GetNamedFramebufferAttachmentParameteriv_ovr_0(framebuffer, attachment, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferAttachmentParameteriv(framebuffer: UInt32; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; var ¶ms: Int32);
begin
z_GetNamedFramebufferAttachmentParameteriv_ovr_0(framebuffer, attachment, pname, ¶ms);
end;
public 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);
begin
z_GetNamedFramebufferAttachmentParameteriv_ovr_2(framebuffer, attachment, pname, ¶ms);
end;
// added in gl4.5
public z_GetNamedFramebufferParameteriv_adr := GetFuncAdr('glGetNamedFramebufferParameteriv');
public z_GetNamedFramebufferParameteriv_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; pname: GetFramebufferParameter; var param: Int32)>(z_GetNamedFramebufferParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferParameteriv(framebuffer: UInt32; pname: GetFramebufferParameter; param: array of Int32);
begin
z_GetNamedFramebufferParameteriv_ovr_0(framebuffer, pname, param[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferParameteriv(framebuffer: UInt32; pname: GetFramebufferParameter; var param: Int32);
begin
z_GetNamedFramebufferParameteriv_ovr_0(framebuffer, pname, param);
end;
public 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);
begin
z_GetNamedFramebufferParameteriv_ovr_2(framebuffer, pname, param);
end;
// added in gl4.5
public z_GetNamedRenderbufferParameteriv_adr := GetFuncAdr('glGetNamedRenderbufferParameteriv');
public z_GetNamedRenderbufferParameteriv_ovr_0 := GetFuncOrNil&<procedure(renderbuffer: UInt32; pname: RenderbufferParameterName; var ¶ms: Int32)>(z_GetNamedRenderbufferParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedRenderbufferParameteriv(renderbuffer: UInt32; pname: RenderbufferParameterName; ¶ms: array of Int32);
begin
z_GetNamedRenderbufferParameteriv_ovr_0(renderbuffer, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedRenderbufferParameteriv(renderbuffer: UInt32; pname: RenderbufferParameterName; var ¶ms: Int32);
begin
z_GetNamedRenderbufferParameteriv_ovr_0(renderbuffer, pname, ¶ms);
end;
public 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);
begin
z_GetNamedRenderbufferParameteriv_ovr_2(renderbuffer, pname, ¶ms);
end;
// added in gl4.5
public z_GetnColorTable_adr := GetFuncAdr('glGetnColorTable');
public 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);
begin
z_GetnColorTable_ovr_0(target, format, &type, bufSize, table);
end;
// added in gl4.5
public z_GetnCompressedTexImage_adr := GetFuncAdr('glGetnCompressedTexImage');
public 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);
begin
z_GetnCompressedTexImage_ovr_0(target, lod, bufSize, pixels);
end;
// added in gl4.5
public z_GetnConvolutionFilter_adr := GetFuncAdr('glGetnConvolutionFilter');
public 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);
begin
z_GetnConvolutionFilter_ovr_0(target, format, &type, bufSize, image);
end;
// added in gl4.5
public z_GetnHistogram_adr := GetFuncAdr('glGetnHistogram');
public 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);
begin
z_GetnHistogram_ovr_0(target, reset, format, &type, bufSize, values);
end;
// added in gl4.5
public z_GetnMapdv_adr := GetFuncAdr('glGetnMapdv');
public z_GetnMapdv_ovr_0 := GetFuncOrNil&<procedure(target: MapTarget; query: MapQuery; bufSize: Int32; var v: real)>(z_GetnMapdv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapdv(target: MapTarget; query: MapQuery; bufSize: Int32; v: array of real);
begin
z_GetnMapdv_ovr_0(target, query, bufSize, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapdv(target: MapTarget; query: MapQuery; bufSize: Int32; var v: real);
begin
z_GetnMapdv_ovr_0(target, query, bufSize, v);
end;
public 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);
begin
z_GetnMapdv_ovr_2(target, query, bufSize, v);
end;
// added in gl4.5
public z_GetnMapfv_adr := GetFuncAdr('glGetnMapfv');
public z_GetnMapfv_ovr_0 := GetFuncOrNil&<procedure(target: MapTarget; query: MapQuery; bufSize: Int32; var v: single)>(z_GetnMapfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapfv(target: MapTarget; query: MapQuery; bufSize: Int32; v: array of single);
begin
z_GetnMapfv_ovr_0(target, query, bufSize, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapfv(target: MapTarget; query: MapQuery; bufSize: Int32; var v: single);
begin
z_GetnMapfv_ovr_0(target, query, bufSize, v);
end;
public 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);
begin
z_GetnMapfv_ovr_2(target, query, bufSize, v);
end;
// added in gl4.5
public z_GetnMapiv_adr := GetFuncAdr('glGetnMapiv');
public z_GetnMapiv_ovr_0 := GetFuncOrNil&<procedure(target: MapTarget; query: MapQuery; bufSize: Int32; var v: Int32)>(z_GetnMapiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapiv(target: MapTarget; query: MapQuery; bufSize: Int32; v: array of Int32);
begin
z_GetnMapiv_ovr_0(target, query, bufSize, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapiv(target: MapTarget; query: MapQuery; bufSize: Int32; var v: Int32);
begin
z_GetnMapiv_ovr_0(target, query, bufSize, v);
end;
public 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);
begin
z_GetnMapiv_ovr_2(target, query, bufSize, v);
end;
// added in gl4.5
public z_GetnMinmax_adr := GetFuncAdr('glGetnMinmax');
public 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);
begin
z_GetnMinmax_ovr_0(target, reset, format, &type, bufSize, values);
end;
// added in gl4.5
public z_GetnPixelMapfv_adr := GetFuncAdr('glGetnPixelMapfv');
public z_GetnPixelMapfv_ovr_0 := GetFuncOrNil&<procedure(map: PixelMap; bufSize: Int32; var values: single)>(z_GetnPixelMapfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapfv(map: PixelMap; bufSize: Int32; values: array of single);
begin
z_GetnPixelMapfv_ovr_0(map, bufSize, values[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapfv(map: PixelMap; bufSize: Int32; var values: single);
begin
z_GetnPixelMapfv_ovr_0(map, bufSize, values);
end;
public 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);
begin
z_GetnPixelMapfv_ovr_2(map, bufSize, values);
end;
// added in gl4.5
public z_GetnPixelMapuiv_adr := GetFuncAdr('glGetnPixelMapuiv');
public z_GetnPixelMapuiv_ovr_0 := GetFuncOrNil&<procedure(map: PixelMap; bufSize: Int32; var values: UInt32)>(z_GetnPixelMapuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapuiv(map: PixelMap; bufSize: Int32; values: array of UInt32);
begin
z_GetnPixelMapuiv_ovr_0(map, bufSize, values[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapuiv(map: PixelMap; bufSize: Int32; var values: UInt32);
begin
z_GetnPixelMapuiv_ovr_0(map, bufSize, values);
end;
public 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);
begin
z_GetnPixelMapuiv_ovr_2(map, bufSize, values);
end;
// added in gl4.5
public z_GetnPixelMapusv_adr := GetFuncAdr('glGetnPixelMapusv');
public z_GetnPixelMapusv_ovr_0 := GetFuncOrNil&<procedure(map: PixelMap; bufSize: Int32; var values: UInt16)>(z_GetnPixelMapusv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapusv(map: PixelMap; bufSize: Int32; values: array of UInt16);
begin
z_GetnPixelMapusv_ovr_0(map, bufSize, values[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapusv(map: PixelMap; bufSize: Int32; var values: UInt16);
begin
z_GetnPixelMapusv_ovr_0(map, bufSize, values);
end;
public 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);
begin
z_GetnPixelMapusv_ovr_2(map, bufSize, values);
end;
// added in gl4.5
public z_GetnPolygonStipple_adr := GetFuncAdr('glGetnPolygonStipple');
public z_GetnPolygonStipple_ovr_0 := GetFuncOrNil&<procedure(bufSize: Int32; var pattern: Byte)>(z_GetnPolygonStipple_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPolygonStipple(bufSize: Int32; pattern: array of Byte);
begin
z_GetnPolygonStipple_ovr_0(bufSize, pattern[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPolygonStipple(bufSize: Int32; var pattern: Byte);
begin
z_GetnPolygonStipple_ovr_0(bufSize, pattern);
end;
public z_GetnPolygonStipple_ovr_2 := GetFuncOrNil&<procedure(bufSize: Int32; pattern: IntPtr)>(z_GetnPolygonStipple_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPolygonStipple(bufSize: Int32; pattern: IntPtr);
begin
z_GetnPolygonStipple_ovr_2(bufSize, pattern);
end;
// added in gl4.5
public z_GetnSeparableFilter_adr := GetFuncAdr('glGetnSeparableFilter');
public 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);
begin
z_GetnSeparableFilter_ovr_0(target, format, &type, rowBufSize, row, columnBufSize, column, span);
end;
// added in gl4.5
public z_GetnTexImage_adr := GetFuncAdr('glGetnTexImage');
public 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);
begin
z_GetnTexImage_ovr_0(target, level, format, &type, bufSize, pixels);
end;
// added in gl4.5
public z_GetnUniformdv_adr := GetFuncAdr('glGetnUniformdv');
public z_GetnUniformdv_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; bufSize: Int32; var ¶ms: real)>(z_GetnUniformdv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformdv(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: array of real);
begin
z_GetnUniformdv_ovr_0(&program, location, bufSize, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformdv(&program: ProgramName; location: Int32; bufSize: Int32; var ¶ms: real);
begin
z_GetnUniformdv_ovr_0(&program, location, bufSize, ¶ms);
end;
public 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);
begin
z_GetnUniformdv_ovr_2(&program, location, bufSize, ¶ms);
end;
// added in gl4.5
public z_GetnUniformfv_adr := GetFuncAdr('glGetnUniformfv');
public z_GetnUniformfv_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; bufSize: Int32; var ¶ms: single)>(z_GetnUniformfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformfv(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: array of single);
begin
z_GetnUniformfv_ovr_0(&program, location, bufSize, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformfv(&program: ProgramName; location: Int32; bufSize: Int32; var ¶ms: single);
begin
z_GetnUniformfv_ovr_0(&program, location, bufSize, ¶ms);
end;
public 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);
begin
z_GetnUniformfv_ovr_2(&program, location, bufSize, ¶ms);
end;
// added in gl4.5
public z_GetnUniformiv_adr := GetFuncAdr('glGetnUniformiv');
public z_GetnUniformiv_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; bufSize: Int32; var ¶ms: Int32)>(z_GetnUniformiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformiv(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: array of Int32);
begin
z_GetnUniformiv_ovr_0(&program, location, bufSize, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformiv(&program: ProgramName; location: Int32; bufSize: Int32; var ¶ms: Int32);
begin
z_GetnUniformiv_ovr_0(&program, location, bufSize, ¶ms);
end;
public 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);
begin
z_GetnUniformiv_ovr_2(&program, location, bufSize, ¶ms);
end;
// added in gl4.5
public z_GetnUniformuiv_adr := GetFuncAdr('glGetnUniformuiv');
public z_GetnUniformuiv_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; bufSize: Int32; var ¶ms: UInt32)>(z_GetnUniformuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformuiv(&program: ProgramName; location: Int32; bufSize: Int32; ¶ms: array of UInt32);
begin
z_GetnUniformuiv_ovr_0(&program, location, bufSize, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformuiv(&program: ProgramName; location: Int32; bufSize: Int32; var ¶ms: UInt32);
begin
z_GetnUniformuiv_ovr_0(&program, location, bufSize, ¶ms);
end;
public 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);
begin
z_GetnUniformuiv_ovr_2(&program, location, bufSize, ¶ms);
end;
// added in gl4.3
public z_GetObjectLabel_adr := GetFuncAdr('glGetObjectLabel');
public z_GetObjectLabel_ovr_0 := GetFuncOrNil&<procedure(identifier: ObjectIdentifier; name: UInt32; bufSize: Int32; var length: Int32; &label: IntPtr)>(z_GetObjectLabel_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectLabel(identifier: ObjectIdentifier; name: UInt32; bufSize: Int32; length: array of Int32; &label: IntPtr);
begin
z_GetObjectLabel_ovr_0(identifier, name, bufSize, length[0], &label);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectLabel(identifier: ObjectIdentifier; name: UInt32; bufSize: Int32; var length: Int32; &label: IntPtr);
begin
z_GetObjectLabel_ovr_0(identifier, name, bufSize, length, &label);
end;
public 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);
begin
z_GetObjectLabel_ovr_2(identifier, name, bufSize, length, &label);
end;
// added in gl4.3
public z_GetObjectPtrLabel_adr := GetFuncAdr('glGetObjectPtrLabel');
public z_GetObjectPtrLabel_ovr_0 := GetFuncOrNil&<procedure(ptr: IntPtr; bufSize: Int32; var length: Int32; &label: IntPtr)>(z_GetObjectPtrLabel_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectPtrLabel(ptr: IntPtr; bufSize: Int32; length: array of Int32; &label: IntPtr);
begin
z_GetObjectPtrLabel_ovr_0(ptr, bufSize, length[0], &label);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectPtrLabel(ptr: IntPtr; bufSize: Int32; var length: Int32; &label: IntPtr);
begin
z_GetObjectPtrLabel_ovr_0(ptr, bufSize, length, &label);
end;
public 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);
begin
z_GetObjectPtrLabel_ovr_2(ptr, bufSize, length, &label);
end;
// added in gl1.1
private static procedure _z_GetPointerv_ovr0(pname: GetPointervPName; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of IntPtr);
external 'opengl32.dll' name 'glGetPointerv';
public static z_GetPointerv_ovr0 := _z_GetPointerv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPointerv(pname: GetPointervPName; ¶ms: array of IntPtr) := z_GetPointerv_ovr0(pname, ¶ms);
private static procedure _z_GetPointerv_ovr1(pname: GetPointervPName; var ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetPointerv';
public static z_GetPointerv_ovr1 := _z_GetPointerv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPointerv(pname: GetPointervPName; var ¶ms: IntPtr) := z_GetPointerv_ovr1(pname, ¶ms);
private static procedure _z_GetPointerv_ovr2(pname: GetPointervPName; ¶ms: pointer);
external 'opengl32.dll' name 'glGetPointerv';
public static z_GetPointerv_ovr2 := _z_GetPointerv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPointerv(pname: GetPointervPName; ¶ms: pointer) := z_GetPointerv_ovr2(pname, ¶ms);
// added in gl4.1
public z_GetProgramBinary_adr := GetFuncAdr('glGetProgramBinary');
public z_GetProgramBinary_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; bufSize: Int32; var length: Int32; var binaryFormat: DummyEnum; 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);
begin
z_GetProgramBinary_ovr_0(&program, bufSize, length[0], binaryFormat[0], binary);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramBinary(&program: UInt32; bufSize: Int32; length: array of Int32; var binaryFormat: DummyEnum; binary: IntPtr);
begin
z_GetProgramBinary_ovr_0(&program, bufSize, length[0], binaryFormat, binary);
end;
public z_GetProgramBinary_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; bufSize: Int32; var length: Int32; 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);
begin
z_GetProgramBinary_ovr_2(&program, bufSize, length[0], binaryFormat, binary);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramBinary(&program: UInt32; bufSize: Int32; var length: Int32; binaryFormat: array of DummyEnum; binary: IntPtr);
begin
z_GetProgramBinary_ovr_0(&program, bufSize, length, binaryFormat[0], binary);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramBinary(&program: UInt32; bufSize: Int32; var length: Int32; var binaryFormat: DummyEnum; binary: IntPtr);
begin
z_GetProgramBinary_ovr_0(&program, bufSize, length, binaryFormat, binary);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramBinary(&program: UInt32; bufSize: Int32; var length: Int32; binaryFormat: IntPtr; binary: IntPtr);
begin
z_GetProgramBinary_ovr_2(&program, bufSize, length, binaryFormat, binary);
end;
public z_GetProgramBinary_ovr_6 := 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: IntPtr; binaryFormat: array of DummyEnum; binary: IntPtr);
begin
z_GetProgramBinary_ovr_6(&program, bufSize, length, binaryFormat[0], binary);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramBinary(&program: UInt32; bufSize: Int32; length: IntPtr; var binaryFormat: DummyEnum; binary: IntPtr);
begin
z_GetProgramBinary_ovr_6(&program, bufSize, length, binaryFormat, binary);
end;
public 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);
begin
z_GetProgramBinary_ovr_8(&program, bufSize, length, binaryFormat, binary);
end;
// added in gl2.0
public z_GetProgramInfoLog_adr := GetFuncAdr('glGetProgramInfoLog');
public 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);
begin
z_GetProgramInfoLog_ovr_0(&program, bufSize, length, infoLog);
end;
public 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);
begin
z_GetProgramInfoLog_ovr_1(&program, bufSize, length, infoLog);
end;
// added in gl4.3
public z_GetProgramInterfaceiv_adr := GetFuncAdr('glGetProgramInterfaceiv');
public z_GetProgramInterfaceiv_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; _programInterface: ProgramInterface; pname: ProgramInterfacePName; var ¶ms: Int32)>(z_GetProgramInterfaceiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramInterfaceiv(&program: ProgramName; _programInterface: ProgramInterface; pname: ProgramInterfacePName; ¶ms: array of Int32);
begin
z_GetProgramInterfaceiv_ovr_0(&program, _programInterface, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramInterfaceiv(&program: ProgramName; _programInterface: ProgramInterface; pname: ProgramInterfacePName; var ¶ms: Int32);
begin
z_GetProgramInterfaceiv_ovr_0(&program, _programInterface, pname, ¶ms);
end;
public 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);
begin
z_GetProgramInterfaceiv_ovr_2(&program, _programInterface, pname, ¶ms);
end;
// added in gl2.0
public z_GetProgramiv_adr := GetFuncAdr('glGetProgramiv');
public z_GetProgramiv_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; pname: ProgramPropertyARB; var ¶ms: Int32)>(z_GetProgramiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramiv(&program: ProgramName; pname: ProgramPropertyARB; ¶ms: array of Int32);
begin
z_GetProgramiv_ovr_0(&program, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramiv(&program: ProgramName; pname: ProgramPropertyARB; var ¶ms: Int32);
begin
z_GetProgramiv_ovr_0(&program, pname, ¶ms);
end;
public 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);
begin
z_GetProgramiv_ovr_2(&program, pname, ¶ms);
end;
// added in gl4.1
public z_GetProgramPipelineInfoLog_adr := GetFuncAdr('glGetProgramPipelineInfoLog');
public z_GetProgramPipelineInfoLog_ovr_0 := GetFuncOrNil&<procedure(pipeline: UInt32; bufSize: Int32; var length: Int32; infoLog: IntPtr)>(z_GetProgramPipelineInfoLog_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramPipelineInfoLog(pipeline: UInt32; bufSize: Int32; length: array of Int32; infoLog: IntPtr);
begin
z_GetProgramPipelineInfoLog_ovr_0(pipeline, bufSize, length[0], infoLog);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramPipelineInfoLog(pipeline: UInt32; bufSize: Int32; var length: Int32; infoLog: IntPtr);
begin
z_GetProgramPipelineInfoLog_ovr_0(pipeline, bufSize, length, infoLog);
end;
public 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);
begin
z_GetProgramPipelineInfoLog_ovr_2(pipeline, bufSize, length, infoLog);
end;
// added in gl4.1
public z_GetProgramPipelineiv_adr := GetFuncAdr('glGetProgramPipelineiv');
public z_GetProgramPipelineiv_ovr_0 := GetFuncOrNil&<procedure(pipeline: UInt32; pname: PipelineParameterName; var ¶ms: Int32)>(z_GetProgramPipelineiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramPipelineiv(pipeline: UInt32; pname: PipelineParameterName; ¶ms: array of Int32);
begin
z_GetProgramPipelineiv_ovr_0(pipeline, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramPipelineiv(pipeline: UInt32; pname: PipelineParameterName; var ¶ms: Int32);
begin
z_GetProgramPipelineiv_ovr_0(pipeline, pname, ¶ms);
end;
public 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);
begin
z_GetProgramPipelineiv_ovr_2(pipeline, pname, ¶ms);
end;
// added in gl4.3
public z_GetProgramResourceIndex_adr := GetFuncAdr('glGetProgramResourceIndex');
public 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;
begin
Result := z_GetProgramResourceIndex_ovr_0(&program, _programInterface, name);
end;
// added in gl4.3
public z_GetProgramResourceiv_adr := GetFuncAdr('glGetProgramResourceiv');
public 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);
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);
begin
z_GetProgramResourceiv_ovr_0(&program, _programInterface, index, propCount, props[0], count, length[0], ¶ms[0]);
end;
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);
begin
z_GetProgramResourceiv_ovr_0(&program, _programInterface, index, propCount, props[0], count, length[0], ¶ms);
end;
public 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);
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);
begin
z_GetProgramResourceiv_ovr_2(&program, _programInterface, index, propCount, props[0], count, length[0], ¶ms);
end;
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);
begin
z_GetProgramResourceiv_ovr_0(&program, _programInterface, index, propCount, props[0], count, length, ¶ms[0]);
end;
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);
begin
z_GetProgramResourceiv_ovr_0(&program, _programInterface, index, propCount, props[0], count, length, ¶ms);
end;
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);
begin
z_GetProgramResourceiv_ovr_2(&program, _programInterface, index, propCount, props[0], count, length, ¶ms);
end;
public 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);
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);
begin
z_GetProgramResourceiv_ovr_6(&program, _programInterface, index, propCount, props[0], count, length, ¶ms[0]);
end;
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);
begin
z_GetProgramResourceiv_ovr_6(&program, _programInterface, index, propCount, props[0], count, length, ¶ms);
end;
public 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);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of ProgramResourceProperty; count: Int32; length: IntPtr; ¶ms: IntPtr);
begin
z_GetProgramResourceiv_ovr_8(&program, _programInterface, index, propCount, props[0], count, length, ¶ms);
end;
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);
begin
z_GetProgramResourceiv_ovr_0(&program, _programInterface, index, propCount, props, count, length[0], ¶ms[0]);
end;
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);
begin
z_GetProgramResourceiv_ovr_0(&program, _programInterface, index, propCount, props, count, length[0], ¶ms);
end;
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);
begin
z_GetProgramResourceiv_ovr_2(&program, _programInterface, index, propCount, props, count, length[0], ¶ms);
end;
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);
begin
z_GetProgramResourceiv_ovr_0(&program, _programInterface, index, propCount, props, count, length, ¶ms[0]);
end;
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);
begin
z_GetProgramResourceiv_ovr_0(&program, _programInterface, index, propCount, props, count, length, ¶ms);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; var length: Int32; ¶ms: IntPtr);
begin
z_GetProgramResourceiv_ovr_2(&program, _programInterface, index, propCount, props, count, length, ¶ms);
end;
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);
begin
z_GetProgramResourceiv_ovr_6(&program, _programInterface, index, propCount, props, count, length, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: IntPtr; var ¶ms: Int32);
begin
z_GetProgramResourceiv_ovr_6(&program, _programInterface, index, propCount, props, count, length, ¶ms);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: ProgramResourceProperty; count: Int32; length: IntPtr; ¶ms: IntPtr);
begin
z_GetProgramResourceiv_ovr_8(&program, _programInterface, index, propCount, props, count, length, ¶ms);
end;
public 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);
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);
begin
z_GetProgramResourceiv_ovr_18(&program, _programInterface, index, propCount, props, count, length[0], ¶ms[0]);
end;
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);
begin
z_GetProgramResourceiv_ovr_18(&program, _programInterface, index, propCount, props, count, length[0], ¶ms);
end;
public 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);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: array of Int32; ¶ms: IntPtr);
begin
z_GetProgramResourceiv_ovr_20(&program, _programInterface, index, propCount, props, count, length[0], ¶ms);
end;
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);
begin
z_GetProgramResourceiv_ovr_18(&program, _programInterface, index, propCount, props, count, length, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; var ¶ms: Int32);
begin
z_GetProgramResourceiv_ovr_18(&program, _programInterface, index, propCount, props, count, length, ¶ms);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; ¶ms: IntPtr);
begin
z_GetProgramResourceiv_ovr_20(&program, _programInterface, index, propCount, props, count, length, ¶ms);
end;
public 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);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: array of Int32);
begin
z_GetProgramResourceiv_ovr_24(&program, _programInterface, index, propCount, props, count, length, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceiv(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; var ¶ms: Int32);
begin
z_GetProgramResourceiv_ovr_24(&program, _programInterface, index, propCount, props, count, length, ¶ms);
end;
public 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);
begin
z_GetProgramResourceiv_ovr_26(&program, _programInterface, index, propCount, props, count, length, ¶ms);
end;
// added in gl4.3
public z_GetProgramResourceLocation_adr := GetFuncAdr('glGetProgramResourceLocation');
public 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;
begin
Result := z_GetProgramResourceLocation_ovr_0(&program, _programInterface, name);
end;
// added in gl4.3
public z_GetProgramResourceLocationIndex_adr := GetFuncAdr('glGetProgramResourceLocationIndex');
public 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;
begin
Result := z_GetProgramResourceLocationIndex_ovr_0(&program, _programInterface, name);
end;
// added in gl4.3
public z_GetProgramResourceName_adr := GetFuncAdr('glGetProgramResourceName');
public z_GetProgramResourceName_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; bufSize: Int32; var length: Int32; 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);
begin
z_GetProgramResourceName_ovr_0(&program, _programInterface, index, bufSize, length[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourceName(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; bufSize: Int32; var length: Int32; name: IntPtr);
begin
z_GetProgramResourceName_ovr_0(&program, _programInterface, index, bufSize, length, name);
end;
public 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);
begin
z_GetProgramResourceName_ovr_2(&program, _programInterface, index, bufSize, length, name);
end;
// added in gl4.0
public z_GetProgramStageiv_adr := GetFuncAdr('glGetProgramStageiv');
public z_GetProgramStageiv_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; _shadertype: ShaderType; pname: ProgramStagePName; var values: Int32)>(z_GetProgramStageiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramStageiv(&program: ProgramName; _shadertype: ShaderType; pname: ProgramStagePName; values: array of Int32);
begin
z_GetProgramStageiv_ovr_0(&program, _shadertype, pname, values[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramStageiv(&program: ProgramName; _shadertype: ShaderType; pname: ProgramStagePName; var values: Int32);
begin
z_GetProgramStageiv_ovr_0(&program, _shadertype, pname, values);
end;
public 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);
begin
z_GetProgramStageiv_ovr_2(&program, _shadertype, pname, values);
end;
// added in gl4.5
public z_GetQueryBufferObjecti64v_adr := GetFuncAdr('glGetQueryBufferObjecti64v');
public 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);
begin
z_GetQueryBufferObjecti64v_ovr_0(id, buffer, pname, offset);
end;
// added in gl4.5
public z_GetQueryBufferObjectiv_adr := GetFuncAdr('glGetQueryBufferObjectiv');
public 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);
begin
z_GetQueryBufferObjectiv_ovr_0(id, buffer, pname, offset);
end;
// added in gl4.5
public z_GetQueryBufferObjectui64v_adr := GetFuncAdr('glGetQueryBufferObjectui64v');
public 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);
begin
z_GetQueryBufferObjectui64v_ovr_0(id, buffer, pname, offset);
end;
// added in gl4.5
public z_GetQueryBufferObjectuiv_adr := GetFuncAdr('glGetQueryBufferObjectuiv');
public 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);
begin
z_GetQueryBufferObjectuiv_ovr_0(id, buffer, pname, offset);
end;
// added in gl4.0
public z_GetQueryIndexediv_adr := GetFuncAdr('glGetQueryIndexediv');
public z_GetQueryIndexediv_ovr_0 := GetFuncOrNil&<procedure(target: QueryTarget; index: UInt32; pname: QueryParameterName; var ¶ms: Int32)>(z_GetQueryIndexediv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryIndexediv(target: QueryTarget; index: UInt32; pname: QueryParameterName; ¶ms: array of Int32);
begin
z_GetQueryIndexediv_ovr_0(target, index, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryIndexediv(target: QueryTarget; index: UInt32; pname: QueryParameterName; var ¶ms: Int32);
begin
z_GetQueryIndexediv_ovr_0(target, index, pname, ¶ms);
end;
public 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);
begin
z_GetQueryIndexediv_ovr_2(target, index, pname, ¶ms);
end;
// added in gl1.5
public z_GetQueryiv_adr := GetFuncAdr('glGetQueryiv');
public z_GetQueryiv_ovr_0 := GetFuncOrNil&<procedure(target: QueryTarget; pname: QueryParameterName; var ¶ms: Int32)>(z_GetQueryiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryiv(target: QueryTarget; pname: QueryParameterName; ¶ms: array of Int32);
begin
z_GetQueryiv_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryiv(target: QueryTarget; pname: QueryParameterName; var ¶ms: Int32);
begin
z_GetQueryiv_ovr_0(target, pname, ¶ms);
end;
public 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);
begin
z_GetQueryiv_ovr_2(target, pname, ¶ms);
end;
// added in gl3.3
public z_GetQueryObjecti64v_adr := GetFuncAdr('glGetQueryObjecti64v');
public z_GetQueryObjecti64v_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; pname: QueryObjectParameterName; var ¶ms: Int64)>(z_GetQueryObjecti64v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjecti64v(id: UInt32; pname: QueryObjectParameterName; ¶ms: array of Int64);
begin
z_GetQueryObjecti64v_ovr_0(id, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjecti64v(id: UInt32; pname: QueryObjectParameterName; var ¶ms: Int64);
begin
z_GetQueryObjecti64v_ovr_0(id, pname, ¶ms);
end;
public 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);
begin
z_GetQueryObjecti64v_ovr_2(id, pname, ¶ms);
end;
// added in gl1.5
public z_GetQueryObjectiv_adr := GetFuncAdr('glGetQueryObjectiv');
public z_GetQueryObjectiv_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; pname: QueryObjectParameterName; var ¶ms: Int32)>(z_GetQueryObjectiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectiv(id: UInt32; pname: QueryObjectParameterName; ¶ms: array of Int32);
begin
z_GetQueryObjectiv_ovr_0(id, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectiv(id: UInt32; pname: QueryObjectParameterName; var ¶ms: Int32);
begin
z_GetQueryObjectiv_ovr_0(id, pname, ¶ms);
end;
public 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);
begin
z_GetQueryObjectiv_ovr_2(id, pname, ¶ms);
end;
// added in gl3.3
public z_GetQueryObjectui64v_adr := GetFuncAdr('glGetQueryObjectui64v');
public z_GetQueryObjectui64v_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; pname: QueryObjectParameterName; var ¶ms: UInt64)>(z_GetQueryObjectui64v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectui64v(id: UInt32; pname: QueryObjectParameterName; ¶ms: array of UInt64);
begin
z_GetQueryObjectui64v_ovr_0(id, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectui64v(id: UInt32; pname: QueryObjectParameterName; var ¶ms: UInt64);
begin
z_GetQueryObjectui64v_ovr_0(id, pname, ¶ms);
end;
public 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);
begin
z_GetQueryObjectui64v_ovr_2(id, pname, ¶ms);
end;
// added in gl1.5
public z_GetQueryObjectuiv_adr := GetFuncAdr('glGetQueryObjectuiv');
public z_GetQueryObjectuiv_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; pname: QueryObjectParameterName; var ¶ms: UInt32)>(z_GetQueryObjectuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectuiv(id: UInt32; pname: QueryObjectParameterName; ¶ms: array of UInt32);
begin
z_GetQueryObjectuiv_ovr_0(id, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectuiv(id: UInt32; pname: QueryObjectParameterName; var ¶ms: UInt32);
begin
z_GetQueryObjectuiv_ovr_0(id, pname, ¶ms);
end;
public 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);
begin
z_GetQueryObjectuiv_ovr_2(id, pname, ¶ms);
end;
// added in gl3.0
public z_GetRenderbufferParameteriv_adr := GetFuncAdr('glGetRenderbufferParameteriv');
public z_GetRenderbufferParameteriv_ovr_0 := GetFuncOrNil&<procedure(target: RenderbufferTarget; pname: RenderbufferParameterName; var ¶ms: Int32)>(z_GetRenderbufferParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetRenderbufferParameteriv(target: RenderbufferTarget; pname: RenderbufferParameterName; ¶ms: array of Int32);
begin
z_GetRenderbufferParameteriv_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetRenderbufferParameteriv(target: RenderbufferTarget; pname: RenderbufferParameterName; var ¶ms: Int32);
begin
z_GetRenderbufferParameteriv_ovr_0(target, pname, ¶ms);
end;
public 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);
begin
z_GetRenderbufferParameteriv_ovr_2(target, pname, ¶ms);
end;
// added in gl3.3
public z_GetSamplerParameterfv_adr := GetFuncAdr('glGetSamplerParameterfv');
public z_GetSamplerParameterfv_ovr_0 := GetFuncOrNil&<procedure(sampler: UInt32; pname: SamplerParameterF; var ¶ms: single)>(z_GetSamplerParameterfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameterfv(sampler: UInt32; pname: SamplerParameterF; ¶ms: array of single);
begin
z_GetSamplerParameterfv_ovr_0(sampler, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameterfv(sampler: UInt32; pname: SamplerParameterF; var ¶ms: single);
begin
z_GetSamplerParameterfv_ovr_0(sampler, pname, ¶ms);
end;
public 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);
begin
z_GetSamplerParameterfv_ovr_2(sampler, pname, ¶ms);
end;
// added in gl3.3
public z_GetSamplerParameterIiv_adr := GetFuncAdr('glGetSamplerParameterIiv');
public z_GetSamplerParameterIiv_ovr_0 := GetFuncOrNil&<procedure(sampler: UInt32; pname: SamplerParameterI; var ¶ms: Int32)>(z_GetSamplerParameterIiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameterIiv(sampler: UInt32; pname: SamplerParameterI; ¶ms: array of Int32);
begin
z_GetSamplerParameterIiv_ovr_0(sampler, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameterIiv(sampler: UInt32; pname: SamplerParameterI; var ¶ms: Int32);
begin
z_GetSamplerParameterIiv_ovr_0(sampler, pname, ¶ms);
end;
public 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);
begin
z_GetSamplerParameterIiv_ovr_2(sampler, pname, ¶ms);
end;
// added in gl3.3
public z_GetSamplerParameterIuiv_adr := GetFuncAdr('glGetSamplerParameterIuiv');
public z_GetSamplerParameterIuiv_ovr_0 := GetFuncOrNil&<procedure(sampler: UInt32; pname: SamplerParameterI; var ¶ms: UInt32)>(z_GetSamplerParameterIuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameterIuiv(sampler: UInt32; pname: SamplerParameterI; ¶ms: array of UInt32);
begin
z_GetSamplerParameterIuiv_ovr_0(sampler, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameterIuiv(sampler: UInt32; pname: SamplerParameterI; var ¶ms: UInt32);
begin
z_GetSamplerParameterIuiv_ovr_0(sampler, pname, ¶ms);
end;
public 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);
begin
z_GetSamplerParameterIuiv_ovr_2(sampler, pname, ¶ms);
end;
// added in gl3.3
public z_GetSamplerParameteriv_adr := GetFuncAdr('glGetSamplerParameteriv');
public z_GetSamplerParameteriv_ovr_0 := GetFuncOrNil&<procedure(sampler: UInt32; pname: SamplerParameterI; var ¶ms: Int32)>(z_GetSamplerParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameteriv(sampler: UInt32; pname: SamplerParameterI; ¶ms: array of Int32);
begin
z_GetSamplerParameteriv_ovr_0(sampler, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSamplerParameteriv(sampler: UInt32; pname: SamplerParameterI; var ¶ms: Int32);
begin
z_GetSamplerParameteriv_ovr_0(sampler, pname, ¶ms);
end;
public 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);
begin
z_GetSamplerParameteriv_ovr_2(sampler, pname, ¶ms);
end;
// added in gl2.0
public z_GetShaderInfoLog_adr := GetFuncAdr('glGetShaderInfoLog');
public 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);
begin
z_GetShaderInfoLog_ovr_0(shader, bufSize, length, infoLog);
end;
public 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);
begin
z_GetShaderInfoLog_ovr_1(shader, bufSize, length, infoLog);
end;
// added in gl2.0
public z_GetShaderiv_adr := GetFuncAdr('glGetShaderiv');
public z_GetShaderiv_ovr_0 := GetFuncOrNil&<procedure(shader: ShaderName; pname: ShaderParameterName; var ¶ms: Int32)>(z_GetShaderiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderiv(shader: ShaderName; pname: ShaderParameterName; ¶ms: array of Int32);
begin
z_GetShaderiv_ovr_0(shader, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderiv(shader: ShaderName; pname: ShaderParameterName; var ¶ms: Int32);
begin
z_GetShaderiv_ovr_0(shader, pname, ¶ms);
end;
public 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);
begin
z_GetShaderiv_ovr_2(shader, pname, ¶ms);
end;
// added in gl4.1
public z_GetShaderPrecisionFormat_adr := GetFuncAdr('glGetShaderPrecisionFormat');
public z_GetShaderPrecisionFormat_ovr_0 := GetFuncOrNil&<procedure(_shadertype: ShaderType; _precisiontype: PrecisionType; var range: Int32; var precision: Int32)>(z_GetShaderPrecisionFormat_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderPrecisionFormat(_shadertype: ShaderType; _precisiontype: PrecisionType; range: array of Int32; precision: array of Int32);
begin
z_GetShaderPrecisionFormat_ovr_0(_shadertype, _precisiontype, range[0], precision[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderPrecisionFormat(_shadertype: ShaderType; _precisiontype: PrecisionType; range: array of Int32; var precision: Int32);
begin
z_GetShaderPrecisionFormat_ovr_0(_shadertype, _precisiontype, range[0], precision);
end;
public z_GetShaderPrecisionFormat_ovr_2 := GetFuncOrNil&<procedure(_shadertype: ShaderType; _precisiontype: PrecisionType; var range: Int32; precision: IntPtr)>(z_GetShaderPrecisionFormat_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderPrecisionFormat(_shadertype: ShaderType; _precisiontype: PrecisionType; range: array of Int32; precision: IntPtr);
begin
z_GetShaderPrecisionFormat_ovr_2(_shadertype, _precisiontype, range[0], precision);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderPrecisionFormat(_shadertype: ShaderType; _precisiontype: PrecisionType; var range: Int32; precision: array of Int32);
begin
z_GetShaderPrecisionFormat_ovr_0(_shadertype, _precisiontype, range, precision[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderPrecisionFormat(_shadertype: ShaderType; _precisiontype: PrecisionType; var range: Int32; var precision: Int32);
begin
z_GetShaderPrecisionFormat_ovr_0(_shadertype, _precisiontype, range, precision);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderPrecisionFormat(_shadertype: ShaderType; _precisiontype: PrecisionType; var range: Int32; precision: IntPtr);
begin
z_GetShaderPrecisionFormat_ovr_2(_shadertype, _precisiontype, range, precision);
end;
public z_GetShaderPrecisionFormat_ovr_6 := 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: IntPtr; precision: array of Int32);
begin
z_GetShaderPrecisionFormat_ovr_6(_shadertype, _precisiontype, range, precision[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderPrecisionFormat(_shadertype: ShaderType; _precisiontype: PrecisionType; range: IntPtr; var precision: Int32);
begin
z_GetShaderPrecisionFormat_ovr_6(_shadertype, _precisiontype, range, precision);
end;
public 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);
begin
z_GetShaderPrecisionFormat_ovr_8(_shadertype, _precisiontype, range, precision);
end;
// added in gl2.0
public z_GetShaderSource_adr := GetFuncAdr('glGetShaderSource');
public z_GetShaderSource_ovr_0 := GetFuncOrNil&<procedure(shader: UInt32; bufSize: Int32; var length: Int32; source: IntPtr)>(z_GetShaderSource_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderSource(shader: UInt32; bufSize: Int32; length: array of Int32; source: IntPtr);
begin
z_GetShaderSource_ovr_0(shader, bufSize, length[0], source);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderSource(shader: UInt32; bufSize: Int32; var length: Int32; source: IntPtr);
begin
z_GetShaderSource_ovr_0(shader, bufSize, length, source);
end;
public 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);
begin
z_GetShaderSource_ovr_2(shader, bufSize, length, source);
end;
// added in gl1.0
private [Result: MarshalAs(UnmanagedType.LPStr)] static function _z_GetString_ovr0(name: StringName): string;
external 'opengl32.dll' name 'glGetString';
public static z_GetString_ovr0 := _z_GetString_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetString(name: StringName): string := z_GetString_ovr0(name);
// added in gl3.0
public z_GetStringi_adr := GetFuncAdr('glGetStringi');
public 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 par_0_str_ptr := z_GetStringi_ovr_0(name, index);
Result := Marshal.PtrToStringAnsi(par_0_str_ptr);
end;
// added in gl4.0
public z_GetSubroutineIndex_adr := GetFuncAdr('glGetSubroutineIndex');
public 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;
begin
Result := z_GetSubroutineIndex_ovr_0(&program, _shadertype, name);
end;
// added in gl4.0
public z_GetSubroutineUniformLocation_adr := GetFuncAdr('glGetSubroutineUniformLocation');
public 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;
begin
Result := z_GetSubroutineUniformLocation_ovr_0(&program, _shadertype, name);
end;
// added in gl3.2
public z_GetSynciv_adr := GetFuncAdr('glGetSynciv');
public z_GetSynciv_ovr_0 := GetFuncOrNil&<procedure(sync: GLsync; pname: SyncParameterName; count: Int32; var length: Int32; var values: Int32)>(z_GetSynciv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSynciv(sync: GLsync; pname: SyncParameterName; count: Int32; length: array of Int32; values: array of Int32);
begin
z_GetSynciv_ovr_0(sync, pname, count, length[0], values[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSynciv(sync: GLsync; pname: SyncParameterName; count: Int32; length: array of Int32; var values: Int32);
begin
z_GetSynciv_ovr_0(sync, pname, count, length[0], values);
end;
public z_GetSynciv_ovr_2 := GetFuncOrNil&<procedure(sync: GLsync; pname: SyncParameterName; count: Int32; var length: Int32; values: IntPtr)>(z_GetSynciv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSynciv(sync: GLsync; pname: SyncParameterName; count: Int32; length: array of Int32; values: IntPtr);
begin
z_GetSynciv_ovr_2(sync, pname, count, length[0], values);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSynciv(sync: GLsync; pname: SyncParameterName; count: Int32; var length: Int32; values: array of Int32);
begin
z_GetSynciv_ovr_0(sync, pname, count, length, values[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSynciv(sync: GLsync; pname: SyncParameterName; count: Int32; var length: Int32; var values: Int32);
begin
z_GetSynciv_ovr_0(sync, pname, count, length, values);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSynciv(sync: GLsync; pname: SyncParameterName; count: Int32; var length: Int32; values: IntPtr);
begin
z_GetSynciv_ovr_2(sync, pname, count, length, values);
end;
public z_GetSynciv_ovr_6 := 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: IntPtr; values: array of Int32);
begin
z_GetSynciv_ovr_6(sync, pname, count, length, values[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSynciv(sync: GLsync; pname: SyncParameterName; count: Int32; length: IntPtr; var values: Int32);
begin
z_GetSynciv_ovr_6(sync, pname, count, length, values);
end;
public 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);
begin
z_GetSynciv_ovr_8(sync, pname, count, length, values);
end;
// added in gl1.0
private static procedure _z_GetTexImage_ovr0(target: TextureTarget; level: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glGetTexImage';
public static z_GetTexImage_ovr0 := _z_GetTexImage_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexImage(target: TextureTarget; level: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) := z_GetTexImage_ovr0(target, level, format, &type, pixels);
// added in gl1.0
private static procedure _z_GetTexLevelParameterfv_ovr0(target: TextureTarget; level: Int32; pname: GetTextureParameter; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of single);
external 'opengl32.dll' name 'glGetTexLevelParameterfv';
public static z_GetTexLevelParameterfv_ovr0 := _z_GetTexLevelParameterfv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexLevelParameterfv(target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: array of single) := z_GetTexLevelParameterfv_ovr0(target, level, pname, ¶ms);
private static procedure _z_GetTexLevelParameterfv_ovr1(target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: single);
external 'opengl32.dll' name 'glGetTexLevelParameterfv';
public static z_GetTexLevelParameterfv_ovr1 := _z_GetTexLevelParameterfv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexLevelParameterfv(target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: single) := z_GetTexLevelParameterfv_ovr1(target, level, pname, ¶ms);
private static procedure _z_GetTexLevelParameterfv_ovr2(target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexLevelParameterfv';
public static z_GetTexLevelParameterfv_ovr2 := _z_GetTexLevelParameterfv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexLevelParameterfv(target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr) := z_GetTexLevelParameterfv_ovr2(target, level, pname, ¶ms);
// added in gl1.0
private static procedure _z_GetTexLevelParameteriv_ovr0(target: TextureTarget; level: Int32; pname: GetTextureParameter; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of Int32);
external 'opengl32.dll' name 'glGetTexLevelParameteriv';
public static z_GetTexLevelParameteriv_ovr0 := _z_GetTexLevelParameteriv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexLevelParameteriv(target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: array of Int32) := z_GetTexLevelParameteriv_ovr0(target, level, pname, ¶ms);
private static procedure _z_GetTexLevelParameteriv_ovr1(target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetTexLevelParameteriv';
public static z_GetTexLevelParameteriv_ovr1 := _z_GetTexLevelParameteriv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexLevelParameteriv(target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: Int32) := z_GetTexLevelParameteriv_ovr1(target, level, pname, ¶ms);
private static procedure _z_GetTexLevelParameteriv_ovr2(target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexLevelParameteriv';
public static z_GetTexLevelParameteriv_ovr2 := _z_GetTexLevelParameteriv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexLevelParameteriv(target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr) := z_GetTexLevelParameteriv_ovr2(target, level, pname, ¶ms);
// added in gl1.0
private static procedure _z_GetTexParameterfv_ovr0(target: TextureTarget; pname: GetTextureParameter; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of single);
external 'opengl32.dll' name 'glGetTexParameterfv';
public static z_GetTexParameterfv_ovr0 := _z_GetTexParameterfv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterfv(target: TextureTarget; pname: GetTextureParameter; ¶ms: array of single) := z_GetTexParameterfv_ovr0(target, pname, ¶ms);
private static procedure _z_GetTexParameterfv_ovr1(target: TextureTarget; pname: GetTextureParameter; var ¶ms: single);
external 'opengl32.dll' name 'glGetTexParameterfv';
public static z_GetTexParameterfv_ovr1 := _z_GetTexParameterfv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterfv(target: TextureTarget; pname: GetTextureParameter; var ¶ms: single) := z_GetTexParameterfv_ovr1(target, pname, ¶ms);
private static procedure _z_GetTexParameterfv_ovr2(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexParameterfv';
public static z_GetTexParameterfv_ovr2 := _z_GetTexParameterfv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterfv(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr) := z_GetTexParameterfv_ovr2(target, pname, ¶ms);
// added in gl3.0
public z_GetTexParameterIiv_adr := GetFuncAdr('glGetTexParameterIiv');
public z_GetTexParameterIiv_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32)>(z_GetTexParameterIiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterIiv(target: TextureTarget; pname: GetTextureParameter; ¶ms: array of Int32);
begin
z_GetTexParameterIiv_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterIiv(target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32);
begin
z_GetTexParameterIiv_ovr_0(target, pname, ¶ms);
end;
public 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);
begin
z_GetTexParameterIiv_ovr_2(target, pname, ¶ms);
end;
// added in gl3.0
public z_GetTexParameterIuiv_adr := GetFuncAdr('glGetTexParameterIuiv');
public z_GetTexParameterIuiv_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; pname: GetTextureParameter; var ¶ms: UInt32)>(z_GetTexParameterIuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterIuiv(target: TextureTarget; pname: GetTextureParameter; ¶ms: array of UInt32);
begin
z_GetTexParameterIuiv_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterIuiv(target: TextureTarget; pname: GetTextureParameter; var ¶ms: UInt32);
begin
z_GetTexParameterIuiv_ovr_0(target, pname, ¶ms);
end;
public 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);
begin
z_GetTexParameterIuiv_ovr_2(target, pname, ¶ms);
end;
// added in gl1.0
private static procedure _z_GetTexParameteriv_ovr0(target: TextureTarget; pname: GetTextureParameter; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of Int32);
external 'opengl32.dll' name 'glGetTexParameteriv';
public static z_GetTexParameteriv_ovr0 := _z_GetTexParameteriv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameteriv(target: TextureTarget; pname: GetTextureParameter; ¶ms: array of Int32) := z_GetTexParameteriv_ovr0(target, pname, ¶ms);
private static procedure _z_GetTexParameteriv_ovr1(target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetTexParameteriv';
public static z_GetTexParameteriv_ovr1 := _z_GetTexParameteriv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameteriv(target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32) := z_GetTexParameteriv_ovr1(target, pname, ¶ms);
private static procedure _z_GetTexParameteriv_ovr2(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexParameteriv';
public static z_GetTexParameteriv_ovr2 := _z_GetTexParameteriv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameteriv(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr) := z_GetTexParameteriv_ovr2(target, pname, ¶ms);
// added in gl4.5
public z_GetTextureImage_adr := GetFuncAdr('glGetTextureImage');
public 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);
begin
z_GetTextureImage_ovr_0(texture, level, format, &type, bufSize, pixels);
end;
// added in gl4.5
public z_GetTextureLevelParameterfv_adr := GetFuncAdr('glGetTextureLevelParameterfv');
public z_GetTextureLevelParameterfv_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; level: Int32; pname: GetTextureParameter; var ¶ms: single)>(z_GetTextureLevelParameterfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameterfv(texture: UInt32; level: Int32; pname: GetTextureParameter; ¶ms: array of single);
begin
z_GetTextureLevelParameterfv_ovr_0(texture, level, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameterfv(texture: UInt32; level: Int32; pname: GetTextureParameter; var ¶ms: single);
begin
z_GetTextureLevelParameterfv_ovr_0(texture, level, pname, ¶ms);
end;
public 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);
begin
z_GetTextureLevelParameterfv_ovr_2(texture, level, pname, ¶ms);
end;
// added in gl4.5
public z_GetTextureLevelParameteriv_adr := GetFuncAdr('glGetTextureLevelParameteriv');
public z_GetTextureLevelParameteriv_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; level: Int32; pname: GetTextureParameter; var ¶ms: Int32)>(z_GetTextureLevelParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameteriv(texture: UInt32; level: Int32; pname: GetTextureParameter; ¶ms: array of Int32);
begin
z_GetTextureLevelParameteriv_ovr_0(texture, level, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameteriv(texture: UInt32; level: Int32; pname: GetTextureParameter; var ¶ms: Int32);
begin
z_GetTextureLevelParameteriv_ovr_0(texture, level, pname, ¶ms);
end;
public 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);
begin
z_GetTextureLevelParameteriv_ovr_2(texture, level, pname, ¶ms);
end;
// added in gl4.5
public z_GetTextureParameterfv_adr := GetFuncAdr('glGetTextureParameterfv');
public z_GetTextureParameterfv_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; pname: GetTextureParameter; var ¶ms: single)>(z_GetTextureParameterfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterfv(texture: UInt32; pname: GetTextureParameter; ¶ms: array of single);
begin
z_GetTextureParameterfv_ovr_0(texture, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterfv(texture: UInt32; pname: GetTextureParameter; var ¶ms: single);
begin
z_GetTextureParameterfv_ovr_0(texture, pname, ¶ms);
end;
public 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);
begin
z_GetTextureParameterfv_ovr_2(texture, pname, ¶ms);
end;
// added in gl4.5
public z_GetTextureParameterIiv_adr := GetFuncAdr('glGetTextureParameterIiv');
public z_GetTextureParameterIiv_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; pname: GetTextureParameter; var ¶ms: Int32)>(z_GetTextureParameterIiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIiv(texture: UInt32; pname: GetTextureParameter; ¶ms: array of Int32);
begin
z_GetTextureParameterIiv_ovr_0(texture, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIiv(texture: UInt32; pname: GetTextureParameter; var ¶ms: Int32);
begin
z_GetTextureParameterIiv_ovr_0(texture, pname, ¶ms);
end;
public 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);
begin
z_GetTextureParameterIiv_ovr_2(texture, pname, ¶ms);
end;
// added in gl4.5
public z_GetTextureParameterIuiv_adr := GetFuncAdr('glGetTextureParameterIuiv');
public z_GetTextureParameterIuiv_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; pname: GetTextureParameter; var ¶ms: UInt32)>(z_GetTextureParameterIuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIuiv(texture: UInt32; pname: GetTextureParameter; ¶ms: array of UInt32);
begin
z_GetTextureParameterIuiv_ovr_0(texture, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIuiv(texture: UInt32; pname: GetTextureParameter; var ¶ms: UInt32);
begin
z_GetTextureParameterIuiv_ovr_0(texture, pname, ¶ms);
end;
public 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);
begin
z_GetTextureParameterIuiv_ovr_2(texture, pname, ¶ms);
end;
// added in gl4.5
public z_GetTextureParameteriv_adr := GetFuncAdr('glGetTextureParameteriv');
public z_GetTextureParameteriv_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; pname: GetTextureParameter; var ¶ms: Int32)>(z_GetTextureParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameteriv(texture: UInt32; pname: GetTextureParameter; ¶ms: array of Int32);
begin
z_GetTextureParameteriv_ovr_0(texture, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameteriv(texture: UInt32; pname: GetTextureParameter; var ¶ms: Int32);
begin
z_GetTextureParameteriv_ovr_0(texture, pname, ¶ms);
end;
public 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);
begin
z_GetTextureParameteriv_ovr_2(texture, pname, ¶ms);
end;
// added in gl4.5
public z_GetTextureSubImage_adr := GetFuncAdr('glGetTextureSubImage');
public 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);
begin
z_GetTextureSubImage_ovr_0(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, &type, bufSize, pixels);
end;
// added in gl4.5
public z_GetTransformFeedbacki_v_adr := GetFuncAdr('glGetTransformFeedbacki_v');
public z_GetTransformFeedbacki_v_ovr_0 := GetFuncOrNil&<procedure(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; var param: Int32)>(z_GetTransformFeedbacki_v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbacki_v(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; param: array of Int32);
begin
z_GetTransformFeedbacki_v_ovr_0(xfb, pname, index, param[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbacki_v(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; var param: Int32);
begin
z_GetTransformFeedbacki_v_ovr_0(xfb, pname, index, param);
end;
public 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);
begin
z_GetTransformFeedbacki_v_ovr_2(xfb, pname, index, param);
end;
// added in gl4.5
public z_GetTransformFeedbacki64_v_adr := GetFuncAdr('glGetTransformFeedbacki64_v');
public z_GetTransformFeedbacki64_v_ovr_0 := GetFuncOrNil&<procedure(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; var param: Int64)>(z_GetTransformFeedbacki64_v_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbacki64_v(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; param: array of Int64);
begin
z_GetTransformFeedbacki64_v_ovr_0(xfb, pname, index, param[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbacki64_v(xfb: UInt32; pname: TransformFeedbackPName; index: UInt32; var param: Int64);
begin
z_GetTransformFeedbacki64_v_ovr_0(xfb, pname, index, param);
end;
public 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);
begin
z_GetTransformFeedbacki64_v_ovr_2(xfb, pname, index, param);
end;
// added in gl4.5
public z_GetTransformFeedbackiv_adr := GetFuncAdr('glGetTransformFeedbackiv');
public z_GetTransformFeedbackiv_ovr_0 := GetFuncOrNil&<procedure(xfb: UInt32; pname: TransformFeedbackPName; var param: Int32)>(z_GetTransformFeedbackiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackiv(xfb: UInt32; pname: TransformFeedbackPName; param: array of Int32);
begin
z_GetTransformFeedbackiv_ovr_0(xfb, pname, param[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackiv(xfb: UInt32; pname: TransformFeedbackPName; var param: Int32);
begin
z_GetTransformFeedbackiv_ovr_0(xfb, pname, param);
end;
public 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);
begin
z_GetTransformFeedbackiv_ovr_2(xfb, pname, param);
end;
// added in gl3.0
public z_GetTransformFeedbackVarying_adr := GetFuncAdr('glGetTransformFeedbackVarying');
public 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);
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);
begin
z_GetTransformFeedbackVarying_ovr_0(&program, index, bufSize, length[0], size[0], &type[0], name);
end;
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);
begin
z_GetTransformFeedbackVarying_ovr_0(&program, index, bufSize, length[0], size[0], &type, name);
end;
public 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);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: array of Int32; &type: IntPtr; name: IntPtr);
begin
z_GetTransformFeedbackVarying_ovr_2(&program, index, bufSize, length[0], size[0], &type, name);
end;
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);
begin
z_GetTransformFeedbackVarying_ovr_0(&program, index, bufSize, length[0], size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; var size: Int32; var &type: GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVarying_ovr_0(&program, index, bufSize, length[0], size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; var size: Int32; &type: IntPtr; name: IntPtr);
begin
z_GetTransformFeedbackVarying_ovr_2(&program, index, bufSize, length[0], size, &type, name);
end;
public 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);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: IntPtr; &type: array of GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVarying_ovr_6(&program, index, bufSize, length[0], size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: IntPtr; var &type: GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVarying_ovr_6(&program, index, bufSize, length[0], size, &type, name);
end;
public z_GetTransformFeedbackVarying_ovr_8 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; 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);
begin
z_GetTransformFeedbackVarying_ovr_8(&program, index, bufSize, length[0], size, &type, name);
end;
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);
begin
z_GetTransformFeedbackVarying_ovr_0(&program, index, bufSize, length, size[0], &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: array of Int32; var &type: GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVarying_ovr_0(&program, index, bufSize, length, size[0], &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: array of Int32; &type: IntPtr; name: IntPtr);
begin
z_GetTransformFeedbackVarying_ovr_2(&program, index, bufSize, length, size[0], &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: array of GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVarying_ovr_0(&program, index, bufSize, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; var &type: GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVarying_ovr_0(&program, index, bufSize, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr);
begin
z_GetTransformFeedbackVarying_ovr_2(&program, index, bufSize, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: array of GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVarying_ovr_6(&program, index, bufSize, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; var &type: GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVarying_ovr_6(&program, index, bufSize, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr);
begin
z_GetTransformFeedbackVarying_ovr_8(&program, index, bufSize, length, size, &type, name);
end;
public 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);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: array of Int32; &type: array of GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVarying_ovr_18(&program, index, bufSize, length, size[0], &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: array of Int32; var &type: GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVarying_ovr_18(&program, index, bufSize, length, size[0], &type, name);
end;
public z_GetTransformFeedbackVarying_ovr_20 := 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: IntPtr; size: array of Int32; &type: IntPtr; name: IntPtr);
begin
z_GetTransformFeedbackVarying_ovr_20(&program, index, bufSize, length, size[0], &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: array of GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVarying_ovr_18(&program, index, bufSize, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVarying_ovr_18(&program, index, bufSize, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
begin
z_GetTransformFeedbackVarying_ovr_20(&program, index, bufSize, length, size, &type, name);
end;
public z_GetTransformFeedbackVarying_ovr_24 := 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: IntPtr; &type: array of GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVarying_ovr_24(&program, index, bufSize, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVarying(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVarying_ovr_24(&program, index, bufSize, length, size, &type, name);
end;
public 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);
begin
z_GetTransformFeedbackVarying_ovr_26(&program, index, bufSize, length, size, &type, name);
end;
// added in gl3.1
public z_GetUniformBlockIndex_adr := GetFuncAdr('glGetUniformBlockIndex');
public 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;
begin
Result := z_GetUniformBlockIndex_ovr_0(&program, uniformBlockName);
end;
// added in gl4.0
public z_GetUniformdv_adr := GetFuncAdr('glGetUniformdv');
public z_GetUniformdv_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; var ¶ms: real)>(z_GetUniformdv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformdv(&program: ProgramName; location: Int32; ¶ms: array of real);
begin
z_GetUniformdv_ovr_0(&program, location, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformdv(&program: ProgramName; location: Int32; var ¶ms: real);
begin
z_GetUniformdv_ovr_0(&program, location, ¶ms);
end;
public 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);
begin
z_GetUniformdv_ovr_2(&program, location, ¶ms);
end;
// added in gl2.0
public z_GetUniformfv_adr := GetFuncAdr('glGetUniformfv');
public z_GetUniformfv_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; var ¶ms: single)>(z_GetUniformfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformfv(&program: ProgramName; location: Int32; ¶ms: array of single);
begin
z_GetUniformfv_ovr_0(&program, location, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformfv(&program: ProgramName; location: Int32; var ¶ms: single);
begin
z_GetUniformfv_ovr_0(&program, location, ¶ms);
end;
public 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);
begin
z_GetUniformfv_ovr_2(&program, location, ¶ms);
end;
// added in gl3.1
public z_GetUniformIndices_adr := GetFuncAdr('glGetUniformIndices');
public z_GetUniformIndices_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; uniformCount: Int32; var uniformNames: IntPtr; var uniformIndices: UInt32)>(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));
z_GetUniformIndices_ovr_0(&program, uniformCount, par_3_str_ptr[0], uniformIndices[0]);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
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));
z_GetUniformIndices_ovr_0(&program, uniformCount, par_3_str_ptr[0], uniformIndices);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
public z_GetUniformIndices_ovr_2 := GetFuncOrNil&<procedure(&program: ProgramName; uniformCount: Int32; var 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));
z_GetUniformIndices_ovr_2(&program, uniformCount, par_3_str_ptr[0], uniformIndices);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformIndices(&program: ProgramName; uniformCount: Int32; uniformNames: array of IntPtr; uniformIndices: array of UInt32);
begin
z_GetUniformIndices_ovr_0(&program, uniformCount, uniformNames[0], uniformIndices[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformIndices(&program: ProgramName; uniformCount: Int32; uniformNames: array of IntPtr; var uniformIndices: UInt32);
begin
z_GetUniformIndices_ovr_0(&program, uniformCount, uniformNames[0], uniformIndices);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformIndices(&program: ProgramName; uniformCount: Int32; uniformNames: array of IntPtr; uniformIndices: IntPtr);
begin
z_GetUniformIndices_ovr_2(&program, uniformCount, uniformNames[0], uniformIndices);
end;
public z_GetUniformIndices_ovr_6 := 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: IntPtr; uniformIndices: array of UInt32);
begin
z_GetUniformIndices_ovr_6(&program, uniformCount, uniformNames, uniformIndices[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformIndices(&program: ProgramName; uniformCount: Int32; uniformNames: IntPtr; var uniformIndices: UInt32);
begin
z_GetUniformIndices_ovr_6(&program, uniformCount, uniformNames, uniformIndices);
end;
public 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);
begin
z_GetUniformIndices_ovr_8(&program, uniformCount, uniformNames, uniformIndices);
end;
// added in gl2.0
public z_GetUniformiv_adr := GetFuncAdr('glGetUniformiv');
public z_GetUniformiv_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; var ¶ms: Int32)>(z_GetUniformiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformiv(&program: ProgramName; location: Int32; ¶ms: array of Int32);
begin
z_GetUniformiv_ovr_0(&program, location, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformiv(&program: ProgramName; location: Int32; var ¶ms: Int32);
begin
z_GetUniformiv_ovr_0(&program, location, ¶ms);
end;
public 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);
begin
z_GetUniformiv_ovr_2(&program, location, ¶ms);
end;
// added in gl2.0
public z_GetUniformLocation_adr := GetFuncAdr('glGetUniformLocation');
public 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;
begin
Result := z_GetUniformLocation_ovr_0(&program, name);
end;
// added in gl4.0
public z_GetUniformSubroutineuiv_adr := GetFuncAdr('glGetUniformSubroutineuiv');
public z_GetUniformSubroutineuiv_ovr_0 := GetFuncOrNil&<procedure(_shadertype: ShaderType; location: Int32; var ¶ms: UInt32)>(z_GetUniformSubroutineuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformSubroutineuiv(_shadertype: ShaderType; location: Int32; ¶ms: array of UInt32);
begin
z_GetUniformSubroutineuiv_ovr_0(_shadertype, location, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformSubroutineuiv(_shadertype: ShaderType; location: Int32; var ¶ms: UInt32);
begin
z_GetUniformSubroutineuiv_ovr_0(_shadertype, location, ¶ms);
end;
public 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);
begin
z_GetUniformSubroutineuiv_ovr_2(_shadertype, location, ¶ms);
end;
// added in gl3.0
public z_GetUniformuiv_adr := GetFuncAdr('glGetUniformuiv');
public z_GetUniformuiv_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName; location: Int32; var ¶ms: UInt32)>(z_GetUniformuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformuiv(&program: ProgramName; location: Int32; ¶ms: array of UInt32);
begin
z_GetUniformuiv_ovr_0(&program, location, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformuiv(&program: ProgramName; location: Int32; var ¶ms: UInt32);
begin
z_GetUniformuiv_ovr_0(&program, location, ¶ms);
end;
public 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);
begin
z_GetUniformuiv_ovr_2(&program, location, ¶ms);
end;
// added in gl4.5
public z_GetVertexArrayIndexed64iv_adr := GetFuncAdr('glGetVertexArrayIndexed64iv');
public z_GetVertexArrayIndexed64iv_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; var param: Int64)>(z_GetVertexArrayIndexed64iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIndexed64iv(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: array of Int64);
begin
z_GetVertexArrayIndexed64iv_ovr_0(vaobj, index, pname, param[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIndexed64iv(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; var param: Int64);
begin
z_GetVertexArrayIndexed64iv_ovr_0(vaobj, index, pname, param);
end;
public 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);
begin
z_GetVertexArrayIndexed64iv_ovr_2(vaobj, index, pname, param);
end;
// added in gl4.5
public z_GetVertexArrayIndexediv_adr := GetFuncAdr('glGetVertexArrayIndexediv');
public z_GetVertexArrayIndexediv_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; var param: Int32)>(z_GetVertexArrayIndexediv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIndexediv(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: array of Int32);
begin
z_GetVertexArrayIndexediv_ovr_0(vaobj, index, pname, param[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIndexediv(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; var param: Int32);
begin
z_GetVertexArrayIndexediv_ovr_0(vaobj, index, pname, param);
end;
public 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);
begin
z_GetVertexArrayIndexediv_ovr_2(vaobj, index, pname, param);
end;
// added in gl4.5
public z_GetVertexArrayiv_adr := GetFuncAdr('glGetVertexArrayiv');
public z_GetVertexArrayiv_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; pname: VertexArrayPName; var param: Int32)>(z_GetVertexArrayiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayiv(vaobj: UInt32; pname: VertexArrayPName; param: array of Int32);
begin
z_GetVertexArrayiv_ovr_0(vaobj, pname, param[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayiv(vaobj: UInt32; pname: VertexArrayPName; var param: Int32);
begin
z_GetVertexArrayiv_ovr_0(vaobj, pname, param);
end;
public 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);
begin
z_GetVertexArrayiv_ovr_2(vaobj, pname, param);
end;
// added in gl2.0
public z_GetVertexAttribdv_adr := GetFuncAdr('glGetVertexAttribdv');
public z_GetVertexAttribdv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: real)>(z_GetVertexAttribdv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribdv(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: array of real);
begin
z_GetVertexAttribdv_ovr_0(index, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribdv(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: real);
begin
z_GetVertexAttribdv_ovr_0(index, pname, ¶ms);
end;
public 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);
begin
z_GetVertexAttribdv_ovr_2(index, pname, ¶ms);
end;
// added in gl2.0
public z_GetVertexAttribfv_adr := GetFuncAdr('glGetVertexAttribfv');
public z_GetVertexAttribfv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: single)>(z_GetVertexAttribfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribfv(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: array of single);
begin
z_GetVertexAttribfv_ovr_0(index, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribfv(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: single);
begin
z_GetVertexAttribfv_ovr_0(index, pname, ¶ms);
end;
public 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);
begin
z_GetVertexAttribfv_ovr_2(index, pname, ¶ms);
end;
// added in gl3.0
public z_GetVertexAttribIiv_adr := GetFuncAdr('glGetVertexAttribIiv');
public z_GetVertexAttribIiv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnum; var ¶ms: Int32)>(z_GetVertexAttribIiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribIiv(index: UInt32; pname: VertexAttribEnum; ¶ms: array of Int32);
begin
z_GetVertexAttribIiv_ovr_0(index, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribIiv(index: UInt32; pname: VertexAttribEnum; var ¶ms: Int32);
begin
z_GetVertexAttribIiv_ovr_0(index, pname, ¶ms);
end;
public 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);
begin
z_GetVertexAttribIiv_ovr_2(index, pname, ¶ms);
end;
// added in gl3.0
public z_GetVertexAttribIuiv_adr := GetFuncAdr('glGetVertexAttribIuiv');
public z_GetVertexAttribIuiv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnum; var ¶ms: UInt32)>(z_GetVertexAttribIuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribIuiv(index: UInt32; pname: VertexAttribEnum; ¶ms: array of UInt32);
begin
z_GetVertexAttribIuiv_ovr_0(index, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribIuiv(index: UInt32; pname: VertexAttribEnum; var ¶ms: UInt32);
begin
z_GetVertexAttribIuiv_ovr_0(index, pname, ¶ms);
end;
public 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);
begin
z_GetVertexAttribIuiv_ovr_2(index, pname, ¶ms);
end;
// added in gl2.0
public z_GetVertexAttribiv_adr := GetFuncAdr('glGetVertexAttribiv');
public z_GetVertexAttribiv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: Int32)>(z_GetVertexAttribiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribiv(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: array of Int32);
begin
z_GetVertexAttribiv_ovr_0(index, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribiv(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: Int32);
begin
z_GetVertexAttribiv_ovr_0(index, pname, ¶ms);
end;
public 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);
begin
z_GetVertexAttribiv_ovr_2(index, pname, ¶ms);
end;
// added in gl4.1
public z_GetVertexAttribLdv_adr := GetFuncAdr('glGetVertexAttribLdv');
public z_GetVertexAttribLdv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnum; var ¶ms: real)>(z_GetVertexAttribLdv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLdv(index: UInt32; pname: VertexAttribEnum; ¶ms: array of real);
begin
z_GetVertexAttribLdv_ovr_0(index, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLdv(index: UInt32; pname: VertexAttribEnum; var ¶ms: real);
begin
z_GetVertexAttribLdv_ovr_0(index, pname, ¶ms);
end;
public 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);
begin
z_GetVertexAttribLdv_ovr_2(index, pname, ¶ms);
end;
// added in gl2.0
public z_GetVertexAttribPointerv_adr := GetFuncAdr('glGetVertexAttribPointerv');
public z_GetVertexAttribPointerv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPointerPropertyARB; var _pointer: IntPtr)>(z_GetVertexAttribPointerv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribPointerv(index: UInt32; pname: VertexAttribPointerPropertyARB; _pointer: array of IntPtr);
begin
z_GetVertexAttribPointerv_ovr_0(index, pname, _pointer[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribPointerv(index: UInt32; pname: VertexAttribPointerPropertyARB; var _pointer: IntPtr);
begin
z_GetVertexAttribPointerv_ovr_0(index, pname, _pointer);
end;
public 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);
begin
z_GetVertexAttribPointerv_ovr_2(index, pname, _pointer);
end;
// added in gl1.0
private static procedure _z_Hint_ovr0(target: HintTarget; mode: HintMode);
external 'opengl32.dll' name 'glHint';
public static z_Hint_ovr0 := _z_Hint_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Hint(target: HintTarget; mode: HintMode) := z_Hint_ovr0(target, mode);
// added in gl4.3
public z_InvalidateBufferData_adr := GetFuncAdr('glInvalidateBufferData');
public z_InvalidateBufferData_ovr_0 := GetFuncOrNil&<procedure(buffer: BufferName)>(z_InvalidateBufferData_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateBufferData(buffer: BufferName);
begin
z_InvalidateBufferData_ovr_0(buffer);
end;
// added in gl4.3
public z_InvalidateBufferSubData_adr := GetFuncAdr('glInvalidateBufferSubData');
public 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);
begin
z_InvalidateBufferSubData_ovr_0(buffer, offset, length);
end;
// added in gl4.3
public z_InvalidateFramebuffer_adr := GetFuncAdr('glInvalidateFramebuffer');
public z_InvalidateFramebuffer_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; numAttachments: Int32; var attachments: InvalidateFramebufferAttachment)>(z_InvalidateFramebuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateFramebuffer(target: FramebufferTarget; numAttachments: Int32; attachments: array of InvalidateFramebufferAttachment);
begin
z_InvalidateFramebuffer_ovr_0(target, numAttachments, attachments[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateFramebuffer(target: FramebufferTarget; numAttachments: Int32; var attachments: InvalidateFramebufferAttachment);
begin
z_InvalidateFramebuffer_ovr_0(target, numAttachments, attachments);
end;
public 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);
begin
z_InvalidateFramebuffer_ovr_2(target, numAttachments, attachments);
end;
// added in gl4.5
public z_InvalidateNamedFramebufferData_adr := GetFuncAdr('glInvalidateNamedFramebufferData');
public z_InvalidateNamedFramebufferData_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; numAttachments: Int32; var attachments: FramebufferAttachment)>(z_InvalidateNamedFramebufferData_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateNamedFramebufferData(framebuffer: UInt32; numAttachments: Int32; attachments: array of FramebufferAttachment);
begin
z_InvalidateNamedFramebufferData_ovr_0(framebuffer, numAttachments, attachments[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateNamedFramebufferData(framebuffer: UInt32; numAttachments: Int32; var attachments: FramebufferAttachment);
begin
z_InvalidateNamedFramebufferData_ovr_0(framebuffer, numAttachments, attachments);
end;
public 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);
begin
z_InvalidateNamedFramebufferData_ovr_2(framebuffer, numAttachments, attachments);
end;
// added in gl4.5
public z_InvalidateNamedFramebufferSubData_adr := GetFuncAdr('glInvalidateNamedFramebufferSubData');
public z_InvalidateNamedFramebufferSubData_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; numAttachments: Int32; var attachments: FramebufferAttachment; 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);
begin
z_InvalidateNamedFramebufferSubData_ovr_0(framebuffer, numAttachments, attachments[0], x, y, width, height);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateNamedFramebufferSubData(framebuffer: UInt32; numAttachments: Int32; var attachments: FramebufferAttachment; x: Int32; y: Int32; width: Int32; height: Int32);
begin
z_InvalidateNamedFramebufferSubData_ovr_0(framebuffer, numAttachments, attachments, x, y, width, height);
end;
public 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);
begin
z_InvalidateNamedFramebufferSubData_ovr_2(framebuffer, numAttachments, attachments, x, y, width, height);
end;
// added in gl4.3
public z_InvalidateSubFramebuffer_adr := GetFuncAdr('glInvalidateSubFramebuffer');
public z_InvalidateSubFramebuffer_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; numAttachments: Int32; var attachments: InvalidateFramebufferAttachment; 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);
begin
z_InvalidateSubFramebuffer_ovr_0(target, numAttachments, attachments[0], x, y, width, height);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateSubFramebuffer(target: FramebufferTarget; numAttachments: Int32; var attachments: InvalidateFramebufferAttachment; x: Int32; y: Int32; width: Int32; height: Int32);
begin
z_InvalidateSubFramebuffer_ovr_0(target, numAttachments, attachments, x, y, width, height);
end;
public 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);
begin
z_InvalidateSubFramebuffer_ovr_2(target, numAttachments, attachments, x, y, width, height);
end;
// added in gl4.3
public z_InvalidateTexImage_adr := GetFuncAdr('glInvalidateTexImage');
public z_InvalidateTexImage_ovr_0 := GetFuncOrNil&<procedure(texture: TextureName; level: Int32)>(z_InvalidateTexImage_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InvalidateTexImage(texture: TextureName; level: Int32);
begin
z_InvalidateTexImage_ovr_0(texture, level);
end;
// added in gl4.3
public z_InvalidateTexSubImage_adr := GetFuncAdr('glInvalidateTexSubImage');
public 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);
begin
z_InvalidateTexSubImage_ovr_0(texture, level, xoffset, yoffset, zoffset, width, height, depth);
end;
// added in gl1.5
public z_IsBuffer_adr := GetFuncAdr('glIsBuffer');
public z_IsBuffer_ovr_0 := GetFuncOrNil&<function(buffer: BufferName): boolean>(z_IsBuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsBuffer(buffer: BufferName): boolean;
begin
Result := z_IsBuffer_ovr_0(buffer);
end;
// added in gl1.0
private static function _z_IsEnabled_ovr0(cap: EnableCap): boolean;
external 'opengl32.dll' name 'glIsEnabled';
public static z_IsEnabled_ovr0 := _z_IsEnabled_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsEnabled(cap: EnableCap): boolean := z_IsEnabled_ovr0(cap);
// added in gl3.0
public z_IsEnabledi_adr := GetFuncAdr('glIsEnabledi');
public 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;
begin
Result := z_IsEnabledi_ovr_0(target, index);
end;
// added in gl3.0
public z_IsFramebuffer_adr := GetFuncAdr('glIsFramebuffer');
public z_IsFramebuffer_ovr_0 := GetFuncOrNil&<function(framebuffer: FramebufferName): boolean>(z_IsFramebuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsFramebuffer(framebuffer: FramebufferName): boolean;
begin
Result := z_IsFramebuffer_ovr_0(framebuffer);
end;
// added in gl2.0
public z_IsProgram_adr := GetFuncAdr('glIsProgram');
public z_IsProgram_ovr_0 := GetFuncOrNil&<function(&program: ProgramName): boolean>(z_IsProgram_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsProgram(&program: ProgramName): boolean;
begin
Result := z_IsProgram_ovr_0(&program);
end;
// added in gl4.1
public z_IsProgramPipeline_adr := GetFuncAdr('glIsProgramPipeline');
public z_IsProgramPipeline_ovr_0 := GetFuncOrNil&<function(pipeline: ProgramPipelineName): boolean>(z_IsProgramPipeline_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsProgramPipeline(pipeline: ProgramPipelineName): boolean;
begin
Result := z_IsProgramPipeline_ovr_0(pipeline);
end;
// added in gl1.5
public z_IsQuery_adr := GetFuncAdr('glIsQuery');
public z_IsQuery_ovr_0 := GetFuncOrNil&<function(id: QueryName): boolean>(z_IsQuery_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsQuery(id: QueryName): boolean;
begin
Result := z_IsQuery_ovr_0(id);
end;
// added in gl3.0
public z_IsRenderbuffer_adr := GetFuncAdr('glIsRenderbuffer');
public z_IsRenderbuffer_ovr_0 := GetFuncOrNil&<function(renderbuffer: RenderbufferName): boolean>(z_IsRenderbuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsRenderbuffer(renderbuffer: RenderbufferName): boolean;
begin
Result := z_IsRenderbuffer_ovr_0(renderbuffer);
end;
// added in gl3.3
public z_IsSampler_adr := GetFuncAdr('glIsSampler');
public z_IsSampler_ovr_0 := GetFuncOrNil&<function(sampler: SamplerName): boolean>(z_IsSampler_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsSampler(sampler: SamplerName): boolean;
begin
Result := z_IsSampler_ovr_0(sampler);
end;
// added in gl2.0
public z_IsShader_adr := GetFuncAdr('glIsShader');
public z_IsShader_ovr_0 := GetFuncOrNil&<function(shader: ShaderName): boolean>(z_IsShader_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsShader(shader: ShaderName): boolean;
begin
Result := z_IsShader_ovr_0(shader);
end;
// added in gl3.2
public z_IsSync_adr := GetFuncAdr('glIsSync');
public z_IsSync_ovr_0 := GetFuncOrNil&<function(sync: GLsync): boolean>(z_IsSync_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsSync(sync: GLsync): boolean;
begin
Result := z_IsSync_ovr_0(sync);
end;
// added in gl1.1
private static function _z_IsTexture_ovr0(texture: TextureName): boolean;
external 'opengl32.dll' name 'glIsTexture';
public static z_IsTexture_ovr0 := _z_IsTexture_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsTexture(texture: TextureName): boolean := z_IsTexture_ovr0(texture);
// added in gl4.0
public z_IsTransformFeedback_adr := GetFuncAdr('glIsTransformFeedback');
public z_IsTransformFeedback_ovr_0 := GetFuncOrNil&<function(id: TransformFeedbackName): boolean>(z_IsTransformFeedback_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsTransformFeedback(id: TransformFeedbackName): boolean;
begin
Result := z_IsTransformFeedback_ovr_0(id);
end;
// added in gl3.0
public z_IsVertexArray_adr := GetFuncAdr('glIsVertexArray');
public z_IsVertexArray_ovr_0 := GetFuncOrNil&<function(&array: VertexArrayName): boolean>(z_IsVertexArray_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsVertexArray(&array: VertexArrayName): boolean;
begin
Result := z_IsVertexArray_ovr_0(&array);
end;
// added in gl1.0
private static procedure _z_LineWidth_ovr0(width: single);
external 'opengl32.dll' name 'glLineWidth';
public static z_LineWidth_ovr0 := _z_LineWidth_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LineWidth(width: single) := z_LineWidth_ovr0(width);
// added in gl2.0
public z_LinkProgram_adr := GetFuncAdr('glLinkProgram');
public z_LinkProgram_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName)>(z_LinkProgram_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LinkProgram(&program: ProgramName);
begin
z_LinkProgram_ovr_0(&program);
end;
// added in gl1.0
private static procedure _z_LogicOp_ovr0(opcode: OpenGL.LogicOp);
external 'opengl32.dll' name 'glLogicOp';
public static z_LogicOp_ovr0 := _z_LogicOp_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LogicOp(opcode: OpenGL.LogicOp) := z_LogicOp_ovr0(opcode);
// added in gl1.5
public z_MapBuffer_adr := GetFuncAdr('glMapBuffer');
public 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;
begin
Result := z_MapBuffer_ovr_0(target, access);
end;
// added in gl3.0
public z_MapBufferRange_adr := GetFuncAdr('glMapBufferRange');
public 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;
begin
Result := z_MapBufferRange_ovr_0(target, offset, length, access);
end;
// added in gl4.5
public z_MapNamedBuffer_adr := GetFuncAdr('glMapNamedBuffer');
public 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;
begin
Result := z_MapNamedBuffer_ovr_0(buffer, access);
end;
// added in gl4.5
public z_MapNamedBufferRange_adr := GetFuncAdr('glMapNamedBufferRange');
public 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;
begin
Result := z_MapNamedBufferRange_ovr_0(buffer, offset, length, access);
end;
// added in gl4.2
public z_MemoryBarrier_adr := GetFuncAdr('glMemoryBarrier');
public z_MemoryBarrier_ovr_0 := GetFuncOrNil&<procedure(barriers: MemoryBarrierMask)>(z_MemoryBarrier_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MemoryBarrier(barriers: MemoryBarrierMask);
begin
z_MemoryBarrier_ovr_0(barriers);
end;
// added in gl4.5
public z_MemoryBarrierByRegion_adr := GetFuncAdr('glMemoryBarrierByRegion');
public z_MemoryBarrierByRegion_ovr_0 := GetFuncOrNil&<procedure(barriers: MemoryBarrierMask)>(z_MemoryBarrierByRegion_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MemoryBarrierByRegion(barriers: MemoryBarrierMask);
begin
z_MemoryBarrierByRegion_ovr_0(barriers);
end;
// added in gl4.0
public z_MinSampleShading_adr := GetFuncAdr('glMinSampleShading');
public z_MinSampleShading_ovr_0 := GetFuncOrNil&<procedure(value: single)>(z_MinSampleShading_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MinSampleShading(value: single);
begin
z_MinSampleShading_ovr_0(value);
end;
// added in gl1.4
public z_MultiDrawArrays_adr := GetFuncAdr('glMultiDrawArrays');
public z_MultiDrawArrays_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; var first: Int32; var count: Int32; drawcount: Int32)>(z_MultiDrawArrays_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArrays(mode: PrimitiveType; first: array of Int32; count: array of Int32; drawcount: Int32);
begin
z_MultiDrawArrays_ovr_0(mode, first[0], count[0], drawcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArrays(mode: PrimitiveType; first: array of Int32; var count: Int32; drawcount: Int32);
begin
z_MultiDrawArrays_ovr_0(mode, first[0], count, drawcount);
end;
public z_MultiDrawArrays_ovr_2 := GetFuncOrNil&<procedure(mode: PrimitiveType; var first: Int32; count: IntPtr; drawcount: Int32)>(z_MultiDrawArrays_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArrays(mode: PrimitiveType; first: array of Int32; count: IntPtr; drawcount: Int32);
begin
z_MultiDrawArrays_ovr_2(mode, first[0], count, drawcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArrays(mode: PrimitiveType; var first: Int32; count: array of Int32; drawcount: Int32);
begin
z_MultiDrawArrays_ovr_0(mode, first, count[0], drawcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArrays(mode: PrimitiveType; var first: Int32; var count: Int32; drawcount: Int32);
begin
z_MultiDrawArrays_ovr_0(mode, first, count, drawcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArrays(mode: PrimitiveType; var first: Int32; count: IntPtr; drawcount: Int32);
begin
z_MultiDrawArrays_ovr_2(mode, first, count, drawcount);
end;
public z_MultiDrawArrays_ovr_6 := GetFuncOrNil&<procedure(mode: PrimitiveType; first: IntPtr; var count: Int32; drawcount: Int32)>(z_MultiDrawArrays_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArrays(mode: PrimitiveType; first: IntPtr; count: array of Int32; drawcount: Int32);
begin
z_MultiDrawArrays_ovr_6(mode, first, count[0], drawcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArrays(mode: PrimitiveType; first: IntPtr; var count: Int32; drawcount: Int32);
begin
z_MultiDrawArrays_ovr_6(mode, first, count, drawcount);
end;
public 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);
begin
z_MultiDrawArrays_ovr_8(mode, first, count, drawcount);
end;
// added in gl4.3
public z_MultiDrawArraysIndirect_adr := GetFuncAdr('glMultiDrawArraysIndirect');
public 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);
begin
z_MultiDrawArraysIndirect_ovr_0(mode, indirect, drawcount, stride);
end;
// added in gl4.6
public z_MultiDrawArraysIndirectCount_adr := GetFuncAdr('glMultiDrawArraysIndirectCount');
public 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);
begin
z_MultiDrawArraysIndirectCount_ovr_0(mode, indirect, drawcount, maxdrawcount, stride);
end;
// added in gl1.4
public z_MultiDrawElements_adr := GetFuncAdr('glMultiDrawElements');
public z_MultiDrawElements_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; var 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);
begin
z_MultiDrawElements_ovr_0(mode, count[0], &type, indices[0], drawcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElements(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32);
begin
z_MultiDrawElements_ovr_0(mode, count[0], &type, indices, drawcount);
end;
public z_MultiDrawElements_ovr_2 := GetFuncOrNil&<procedure(mode: PrimitiveType; var count: Int32; &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);
begin
z_MultiDrawElements_ovr_2(mode, count[0], &type, indices, drawcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElements(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32);
begin
z_MultiDrawElements_ovr_0(mode, count, &type, indices[0], drawcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElements(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32);
begin
z_MultiDrawElements_ovr_0(mode, count, &type, indices, drawcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElements(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; drawcount: Int32);
begin
z_MultiDrawElements_ovr_2(mode, count, &type, indices, drawcount);
end;
public z_MultiDrawElements_ovr_6 := 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: IntPtr; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32);
begin
z_MultiDrawElements_ovr_6(mode, count, &type, indices[0], drawcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElements(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32);
begin
z_MultiDrawElements_ovr_6(mode, count, &type, indices, drawcount);
end;
public 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);
begin
z_MultiDrawElements_ovr_8(mode, count, &type, indices, drawcount);
end;
// added in gl3.2
public z_MultiDrawElementsBaseVertex_adr := GetFuncAdr('glMultiDrawElementsBaseVertex');
public z_MultiDrawElementsBaseVertex_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; var count: Int32; &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; indices: array of IntPtr; drawcount: Int32; basevertex: array of Int32);
begin
z_MultiDrawElementsBaseVertex_ovr_0(mode, count[0], &type, indices[0], drawcount, basevertex[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32; var basevertex: Int32);
begin
z_MultiDrawElementsBaseVertex_ovr_0(mode, count[0], &type, indices[0], drawcount, basevertex);
end;
public z_MultiDrawElementsBaseVertex_ovr_2 := GetFuncOrNil&<procedure(mode: PrimitiveType; var count: Int32; &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; indices: array of IntPtr; drawcount: Int32; basevertex: IntPtr);
begin
z_MultiDrawElementsBaseVertex_ovr_2(mode, count[0], &type, indices[0], drawcount, basevertex);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: array of Int32);
begin
z_MultiDrawElementsBaseVertex_ovr_0(mode, count[0], &type, indices, drawcount, basevertex[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; var basevertex: Int32);
begin
z_MultiDrawElementsBaseVertex_ovr_0(mode, count[0], &type, indices, drawcount, basevertex);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: IntPtr);
begin
z_MultiDrawElementsBaseVertex_ovr_2(mode, count[0], &type, indices, drawcount, basevertex);
end;
public z_MultiDrawElementsBaseVertex_ovr_6 := GetFuncOrNil&<procedure(mode: PrimitiveType; var count: Int32; &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; basevertex: array of Int32);
begin
z_MultiDrawElementsBaseVertex_ovr_6(mode, count[0], &type, indices, drawcount, basevertex[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: pointer; drawcount: Int32; var basevertex: Int32);
begin
z_MultiDrawElementsBaseVertex_ovr_6(mode, count[0], &type, indices, drawcount, basevertex);
end;
public z_MultiDrawElementsBaseVertex_ovr_8 := GetFuncOrNil&<procedure(mode: PrimitiveType; var count: Int32; &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);
begin
z_MultiDrawElementsBaseVertex_ovr_8(mode, count[0], &type, indices, drawcount, basevertex);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32; basevertex: array of Int32);
begin
z_MultiDrawElementsBaseVertex_ovr_0(mode, count, &type, indices[0], drawcount, basevertex[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32; var basevertex: Int32);
begin
z_MultiDrawElementsBaseVertex_ovr_0(mode, count, &type, indices[0], drawcount, basevertex);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32; basevertex: IntPtr);
begin
z_MultiDrawElementsBaseVertex_ovr_2(mode, count, &type, indices[0], drawcount, basevertex);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: array of Int32);
begin
z_MultiDrawElementsBaseVertex_ovr_0(mode, count, &type, indices, drawcount, basevertex[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; var basevertex: Int32);
begin
z_MultiDrawElementsBaseVertex_ovr_0(mode, count, &type, indices, drawcount, basevertex);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: IntPtr);
begin
z_MultiDrawElementsBaseVertex_ovr_2(mode, count, &type, indices, drawcount, basevertex);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; drawcount: Int32; basevertex: array of Int32);
begin
z_MultiDrawElementsBaseVertex_ovr_6(mode, count, &type, indices, drawcount, basevertex[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; drawcount: Int32; var basevertex: Int32);
begin
z_MultiDrawElementsBaseVertex_ovr_6(mode, count, &type, indices, drawcount, basevertex);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; drawcount: Int32; basevertex: IntPtr);
begin
z_MultiDrawElementsBaseVertex_ovr_8(mode, count, &type, indices, drawcount, basevertex);
end;
public z_MultiDrawElementsBaseVertex_ovr_18 := 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: IntPtr; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32; basevertex: array of Int32);
begin
z_MultiDrawElementsBaseVertex_ovr_18(mode, count, &type, indices[0], drawcount, basevertex[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32; var basevertex: Int32);
begin
z_MultiDrawElementsBaseVertex_ovr_18(mode, count, &type, indices[0], drawcount, basevertex);
end;
public z_MultiDrawElementsBaseVertex_ovr_20 := 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: IntPtr; &type: DrawElementsType; indices: array of IntPtr; drawcount: Int32; basevertex: IntPtr);
begin
z_MultiDrawElementsBaseVertex_ovr_20(mode, count, &type, indices[0], drawcount, basevertex);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: array of Int32);
begin
z_MultiDrawElementsBaseVertex_ovr_18(mode, count, &type, indices, drawcount, basevertex[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; var basevertex: Int32);
begin
z_MultiDrawElementsBaseVertex_ovr_18(mode, count, &type, indices, drawcount, basevertex);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; drawcount: Int32; basevertex: IntPtr);
begin
z_MultiDrawElementsBaseVertex_ovr_20(mode, count, &type, indices, drawcount, basevertex);
end;
public z_MultiDrawElementsBaseVertex_ovr_24 := 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: IntPtr; &type: DrawElementsType; indices: pointer; drawcount: Int32; basevertex: array of Int32);
begin
z_MultiDrawElementsBaseVertex_ovr_24(mode, count, &type, indices, drawcount, basevertex[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsBaseVertex(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; drawcount: Int32; var basevertex: Int32);
begin
z_MultiDrawElementsBaseVertex_ovr_24(mode, count, &type, indices, drawcount, basevertex);
end;
public 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);
begin
z_MultiDrawElementsBaseVertex_ovr_26(mode, count, &type, indices, drawcount, basevertex);
end;
// added in gl4.3
public z_MultiDrawElementsIndirect_adr := GetFuncAdr('glMultiDrawElementsIndirect');
public 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);
begin
z_MultiDrawElementsIndirect_ovr_0(mode, &type, indirect, drawcount, stride);
end;
// added in gl4.6
public z_MultiDrawElementsIndirectCount_adr := GetFuncAdr('glMultiDrawElementsIndirectCount');
public 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);
begin
z_MultiDrawElementsIndirectCount_ovr_0(mode, &type, indirect, drawcount, maxdrawcount, stride);
end;
// added in gl3.3
public z_MultiTexCoordP1ui_adr := GetFuncAdr('glMultiTexCoordP1ui');
public 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);
begin
z_MultiTexCoordP1ui_ovr_0(texture, &type, coords);
end;
// added in gl3.3
public z_MultiTexCoordP1uiv_adr := GetFuncAdr('glMultiTexCoordP1uiv');
public z_MultiTexCoordP1uiv_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; &type: TexCoordPointerType; var coords: UInt32)>(z_MultiTexCoordP1uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP1uiv(texture: TextureUnit; &type: TexCoordPointerType; coords: array of UInt32);
begin
z_MultiTexCoordP1uiv_ovr_0(texture, &type, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP1uiv(texture: TextureUnit; &type: TexCoordPointerType; var coords: UInt32);
begin
z_MultiTexCoordP1uiv_ovr_0(texture, &type, coords);
end;
public 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);
begin
z_MultiTexCoordP1uiv_ovr_2(texture, &type, coords);
end;
// added in gl3.3
public z_MultiTexCoordP2ui_adr := GetFuncAdr('glMultiTexCoordP2ui');
public 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);
begin
z_MultiTexCoordP2ui_ovr_0(texture, &type, coords);
end;
// added in gl3.3
public z_MultiTexCoordP2uiv_adr := GetFuncAdr('glMultiTexCoordP2uiv');
public z_MultiTexCoordP2uiv_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; &type: TexCoordPointerType; var coords: UInt32)>(z_MultiTexCoordP2uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP2uiv(texture: TextureUnit; &type: TexCoordPointerType; coords: array of UInt32);
begin
z_MultiTexCoordP2uiv_ovr_0(texture, &type, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP2uiv(texture: TextureUnit; &type: TexCoordPointerType; var coords: UInt32);
begin
z_MultiTexCoordP2uiv_ovr_0(texture, &type, coords);
end;
public 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);
begin
z_MultiTexCoordP2uiv_ovr_2(texture, &type, coords);
end;
// added in gl3.3
public z_MultiTexCoordP3ui_adr := GetFuncAdr('glMultiTexCoordP3ui');
public 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);
begin
z_MultiTexCoordP3ui_ovr_0(texture, &type, coords);
end;
// added in gl3.3
public z_MultiTexCoordP3uiv_adr := GetFuncAdr('glMultiTexCoordP3uiv');
public z_MultiTexCoordP3uiv_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; &type: TexCoordPointerType; var coords: UInt32)>(z_MultiTexCoordP3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP3uiv(texture: TextureUnit; &type: TexCoordPointerType; coords: array of UInt32);
begin
z_MultiTexCoordP3uiv_ovr_0(texture, &type, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP3uiv(texture: TextureUnit; &type: TexCoordPointerType; var coords: UInt32);
begin
z_MultiTexCoordP3uiv_ovr_0(texture, &type, coords);
end;
public 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);
begin
z_MultiTexCoordP3uiv_ovr_2(texture, &type, coords);
end;
// added in gl3.3
public z_MultiTexCoordP4ui_adr := GetFuncAdr('glMultiTexCoordP4ui');
public 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);
begin
z_MultiTexCoordP4ui_ovr_0(texture, &type, coords);
end;
// added in gl3.3
public z_MultiTexCoordP4uiv_adr := GetFuncAdr('glMultiTexCoordP4uiv');
public z_MultiTexCoordP4uiv_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; &type: TexCoordPointerType; var coords: UInt32)>(z_MultiTexCoordP4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP4uiv(texture: TextureUnit; &type: TexCoordPointerType; coords: array of UInt32);
begin
z_MultiTexCoordP4uiv_ovr_0(texture, &type, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordP4uiv(texture: TextureUnit; &type: TexCoordPointerType; var coords: UInt32);
begin
z_MultiTexCoordP4uiv_ovr_0(texture, &type, coords);
end;
public 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);
begin
z_MultiTexCoordP4uiv_ovr_2(texture, &type, coords);
end;
// added in gl4.5
public z_NamedBufferData_adr := GetFuncAdr('glNamedBufferData');
public z_NamedBufferData_ovr_0 := GetFuncOrNil&<procedure(buffer: BufferName; size: IntPtr; var data: Byte; usage: VertexBufferObjectUsage)>(z_NamedBufferData_adr);
private [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure z_NamedBufferData_ovr_0_temp<T>(buffer: BufferName; size: IntPtr; var data: T; usage: VertexBufferObjectUsage) :=
z_NamedBufferData_ovr_0(buffer, size, PByte(pointer(@data))^, usage);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferData<T>(buffer: BufferName; size: IntPtr; data: array of T; usage: VertexBufferObjectUsage);
begin
z_NamedBufferData_ovr_0_temp(buffer, size, data[0], usage);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferData<T>(buffer: BufferName; size: IntPtr; var data: T; usage: VertexBufferObjectUsage);
begin
z_NamedBufferData_ovr_0(buffer, size, PByte(pointer(@data))^, usage);
end;
public 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);
begin
z_NamedBufferData_ovr_2(buffer, size, data, usage);
end;
// added in gl4.5
public z_NamedBufferStorage_adr := GetFuncAdr('glNamedBufferStorage');
public 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);
begin
z_NamedBufferStorage_ovr_0(buffer, size, data, flags);
end;
// added in gl4.5
public z_NamedBufferSubData_adr := GetFuncAdr('glNamedBufferSubData');
public 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);
begin
z_NamedBufferSubData_ovr_0(buffer, offset, size, data);
end;
// added in gl4.5
public z_NamedFramebufferDrawBuffer_adr := GetFuncAdr('glNamedFramebufferDrawBuffer');
public z_NamedFramebufferDrawBuffer_ovr_0 := GetFuncOrNil&<procedure(framebuffer: FramebufferName; buf: ColorBuffer)>(z_NamedFramebufferDrawBuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferDrawBuffer(framebuffer: FramebufferName; buf: ColorBuffer);
begin
z_NamedFramebufferDrawBuffer_ovr_0(framebuffer, buf);
end;
// added in gl4.5
public z_NamedFramebufferDrawBuffers_adr := GetFuncAdr('glNamedFramebufferDrawBuffers');
public z_NamedFramebufferDrawBuffers_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; n: Int32; var bufs: ColorBuffer)>(z_NamedFramebufferDrawBuffers_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferDrawBuffers(framebuffer: UInt32; n: Int32; bufs: array of ColorBuffer);
begin
z_NamedFramebufferDrawBuffers_ovr_0(framebuffer, n, bufs[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferDrawBuffers(framebuffer: UInt32; n: Int32; var bufs: ColorBuffer);
begin
z_NamedFramebufferDrawBuffers_ovr_0(framebuffer, n, bufs);
end;
public 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);
begin
z_NamedFramebufferDrawBuffers_ovr_2(framebuffer, n, bufs);
end;
// added in gl4.5
public z_NamedFramebufferParameteri_adr := GetFuncAdr('glNamedFramebufferParameteri');
public 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);
begin
z_NamedFramebufferParameteri_ovr_0(framebuffer, pname, param);
end;
// added in gl4.5
public z_NamedFramebufferReadBuffer_adr := GetFuncAdr('glNamedFramebufferReadBuffer');
public z_NamedFramebufferReadBuffer_ovr_0 := GetFuncOrNil&<procedure(framebuffer: FramebufferName; src: ColorBuffer)>(z_NamedFramebufferReadBuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferReadBuffer(framebuffer: FramebufferName; src: ColorBuffer);
begin
z_NamedFramebufferReadBuffer_ovr_0(framebuffer, src);
end;
// added in gl4.5
public z_NamedFramebufferRenderbuffer_adr := GetFuncAdr('glNamedFramebufferRenderbuffer');
public 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);
begin
z_NamedFramebufferRenderbuffer_ovr_0(framebuffer, attachment, _renderbuffertarget, renderbuffer);
end;
// added in gl4.5
public z_NamedFramebufferTexture_adr := GetFuncAdr('glNamedFramebufferTexture');
public 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);
begin
z_NamedFramebufferTexture_ovr_0(framebuffer, attachment, texture, level);
end;
// added in gl4.5
public z_NamedFramebufferTextureLayer_adr := GetFuncAdr('glNamedFramebufferTextureLayer');
public 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);
begin
z_NamedFramebufferTextureLayer_ovr_0(framebuffer, attachment, texture, level, layer);
end;
// added in gl4.5
public z_NamedRenderbufferStorage_adr := GetFuncAdr('glNamedRenderbufferStorage');
public 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);
begin
z_NamedRenderbufferStorage_ovr_0(renderbuffer, _internalformat, width, height);
end;
// added in gl4.5
public z_NamedRenderbufferStorageMultisample_adr := GetFuncAdr('glNamedRenderbufferStorageMultisample');
public 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);
begin
z_NamedRenderbufferStorageMultisample_ovr_0(renderbuffer, samples, _internalformat, width, height);
end;
// added in gl3.3
public z_NormalP3ui_adr := GetFuncAdr('glNormalP3ui');
public z_NormalP3ui_ovr_0 := GetFuncOrNil&<procedure(&type: NormalPointerType; coords: UInt32)>(z_NormalP3ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalP3ui(&type: NormalPointerType; coords: UInt32);
begin
z_NormalP3ui_ovr_0(&type, coords);
end;
// added in gl3.3
public z_NormalP3uiv_adr := GetFuncAdr('glNormalP3uiv');
public z_NormalP3uiv_ovr_0 := GetFuncOrNil&<procedure(&type: NormalPointerType; var coords: UInt32)>(z_NormalP3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalP3uiv(&type: NormalPointerType; coords: array of UInt32);
begin
z_NormalP3uiv_ovr_0(&type, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalP3uiv(&type: NormalPointerType; var coords: UInt32);
begin
z_NormalP3uiv_ovr_0(&type, coords);
end;
public z_NormalP3uiv_ovr_2 := GetFuncOrNil&<procedure(&type: NormalPointerType; coords: IntPtr)>(z_NormalP3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalP3uiv(&type: NormalPointerType; coords: IntPtr);
begin
z_NormalP3uiv_ovr_2(&type, coords);
end;
// added in gl4.3
public z_ObjectLabel_adr := GetFuncAdr('glObjectLabel');
public 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);
begin
z_ObjectLabel_ovr_0(identifier, name, length, &label);
end;
// added in gl4.3
public z_ObjectPtrLabel_adr := GetFuncAdr('glObjectPtrLabel');
public 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);
begin
z_ObjectPtrLabel_ovr_0(ptr, length, &label);
end;
// added in gl4.0
public z_PatchParameterfv_adr := GetFuncAdr('glPatchParameterfv');
public z_PatchParameterfv_ovr_0 := GetFuncOrNil&<procedure(pname: PatchParameterName; var values: single)>(z_PatchParameterfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PatchParameterfv(pname: PatchParameterName; values: array of single);
begin
z_PatchParameterfv_ovr_0(pname, values[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PatchParameterfv(pname: PatchParameterName; var values: single);
begin
z_PatchParameterfv_ovr_0(pname, values);
end;
public z_PatchParameterfv_ovr_2 := GetFuncOrNil&<procedure(pname: PatchParameterName; values: IntPtr)>(z_PatchParameterfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PatchParameterfv(pname: PatchParameterName; values: IntPtr);
begin
z_PatchParameterfv_ovr_2(pname, values);
end;
// added in gl4.0
public z_PatchParameteri_adr := GetFuncAdr('glPatchParameteri');
public z_PatchParameteri_ovr_0 := GetFuncOrNil&<procedure(pname: PatchParameterName; value: Int32)>(z_PatchParameteri_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PatchParameteri(pname: PatchParameterName; value: Int32);
begin
z_PatchParameteri_ovr_0(pname, value);
end;
// added in gl4.0
public z_PauseTransformFeedback_adr := GetFuncAdr('glPauseTransformFeedback');
public z_PauseTransformFeedback_ovr_0 := GetFuncOrNil&<procedure>(z_PauseTransformFeedback_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PauseTransformFeedback;
begin
z_PauseTransformFeedback_ovr_0;
end;
// added in gl1.0
private static procedure _z_PixelStoref_ovr0(pname: PixelStoreParameter; param: single);
external 'opengl32.dll' name 'glPixelStoref';
public static z_PixelStoref_ovr0 := _z_PixelStoref_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelStoref(pname: PixelStoreParameter; param: single) := z_PixelStoref_ovr0(pname, param);
// added in gl1.0
private static procedure _z_PixelStorei_ovr0(pname: PixelStoreParameter; param: Int32);
external 'opengl32.dll' name 'glPixelStorei';
public static z_PixelStorei_ovr0 := _z_PixelStorei_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelStorei(pname: PixelStoreParameter; param: Int32) := z_PixelStorei_ovr0(pname, param);
// added in gl1.4
public z_PointParameterf_adr := GetFuncAdr('glPointParameterf');
public z_PointParameterf_ovr_0 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; param: single)>(z_PointParameterf_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterf(pname: PointParameterNameARB; param: single);
begin
z_PointParameterf_ovr_0(pname, param);
end;
// added in gl1.4
public z_PointParameterfv_adr := GetFuncAdr('glPointParameterfv');
public z_PointParameterfv_ovr_0 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; var ¶ms: single)>(z_PointParameterfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfv(pname: PointParameterNameARB; ¶ms: array of single);
begin
z_PointParameterfv_ovr_0(pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfv(pname: PointParameterNameARB; var ¶ms: single);
begin
z_PointParameterfv_ovr_0(pname, ¶ms);
end;
public z_PointParameterfv_ovr_2 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; ¶ms: IntPtr)>(z_PointParameterfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfv(pname: PointParameterNameARB; ¶ms: IntPtr);
begin
z_PointParameterfv_ovr_2(pname, ¶ms);
end;
// added in gl1.4
public z_PointParameteri_adr := GetFuncAdr('glPointParameteri');
public z_PointParameteri_ovr_0 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; param: Int32)>(z_PointParameteri_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameteri(pname: PointParameterNameARB; param: Int32);
begin
z_PointParameteri_ovr_0(pname, param);
end;
// added in gl1.4
public z_PointParameteriv_adr := GetFuncAdr('glPointParameteriv');
public z_PointParameteriv_ovr_0 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; var ¶ms: Int32)>(z_PointParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameteriv(pname: PointParameterNameARB; ¶ms: array of Int32);
begin
z_PointParameteriv_ovr_0(pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameteriv(pname: PointParameterNameARB; var ¶ms: Int32);
begin
z_PointParameteriv_ovr_0(pname, ¶ms);
end;
public z_PointParameteriv_ovr_2 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; ¶ms: IntPtr)>(z_PointParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameteriv(pname: PointParameterNameARB; ¶ms: IntPtr);
begin
z_PointParameteriv_ovr_2(pname, ¶ms);
end;
// added in gl1.0
private static procedure _z_PointSize_ovr0(size: single);
external 'opengl32.dll' name 'glPointSize';
public static z_PointSize_ovr0 := _z_PointSize_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointSize(size: single) := z_PointSize_ovr0(size);
// added in gl1.0
private static procedure _z_PolygonMode_ovr0(face: DummyEnum; mode: OpenGL.PolygonMode);
external 'opengl32.dll' name 'glPolygonMode';
public static z_PolygonMode_ovr0 := _z_PolygonMode_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PolygonMode(face: DummyEnum; mode: OpenGL.PolygonMode) := z_PolygonMode_ovr0(face, mode);
// added in gl1.1
private static procedure _z_PolygonOffset_ovr0(factor: single; units: single);
external 'opengl32.dll' name 'glPolygonOffset';
public static z_PolygonOffset_ovr0 := _z_PolygonOffset_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PolygonOffset(factor: single; units: single) := z_PolygonOffset_ovr0(factor, units);
// added in gl4.6
public z_PolygonOffsetClamp_adr := GetFuncAdr('glPolygonOffsetClamp');
public 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);
begin
z_PolygonOffsetClamp_ovr_0(factor, units, clamp);
end;
// added in gl4.3
public z_PopDebugGroup_adr := GetFuncAdr('glPopDebugGroup');
public z_PopDebugGroup_ovr_0 := GetFuncOrNil&<procedure>(z_PopDebugGroup_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PopDebugGroup;
begin
z_PopDebugGroup_ovr_0;
end;
// added in gl3.1
public z_PrimitiveRestartIndex_adr := GetFuncAdr('glPrimitiveRestartIndex');
public z_PrimitiveRestartIndex_ovr_0 := GetFuncOrNil&<procedure(index: UInt32)>(z_PrimitiveRestartIndex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrimitiveRestartIndex(index: UInt32);
begin
z_PrimitiveRestartIndex_ovr_0(index);
end;
// added in gl4.1
public z_ProgramBinary_adr := GetFuncAdr('glProgramBinary');
public 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);
begin
z_ProgramBinary_ovr_0(&program, binaryFormat, binary, length);
end;
// added in gl4.1
public z_ProgramParameteri_adr := GetFuncAdr('glProgramParameteri');
public 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);
begin
z_ProgramParameteri_ovr_0(&program, pname, value);
end;
// added in gl4.1
public z_ProgramUniform1d_adr := GetFuncAdr('glProgramUniform1d');
public 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);
begin
z_ProgramUniform1d_ovr_0(&program, location, v0);
end;
// added in gl4.1
public z_ProgramUniform1dv_adr := GetFuncAdr('glProgramUniform1dv');
public z_ProgramUniform1dv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: real)>(z_ProgramUniform1dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1dv(&program: UInt32; location: Int32; count: Int32; value: array of real);
begin
z_ProgramUniform1dv_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1dv(&program: UInt32; location: Int32; count: Int32; var value: real);
begin
z_ProgramUniform1dv_ovr_0(&program, location, count, value);
end;
public 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);
begin
z_ProgramUniform1dv_ovr_2(&program, location, count, value);
end;
// added in gl4.1
public z_ProgramUniform1f_adr := GetFuncAdr('glProgramUniform1f');
public 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);
begin
z_ProgramUniform1f_ovr_0(&program, location, v0);
end;
// added in gl4.1
public z_ProgramUniform1fv_adr := GetFuncAdr('glProgramUniform1fv');
public z_ProgramUniform1fv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: single)>(z_ProgramUniform1fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1fv(&program: UInt32; location: Int32; count: Int32; value: array of single);
begin
z_ProgramUniform1fv_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1fv(&program: UInt32; location: Int32; count: Int32; var value: single);
begin
z_ProgramUniform1fv_ovr_0(&program, location, count, value);
end;
public 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);
begin
z_ProgramUniform1fv_ovr_2(&program, location, count, value);
end;
// added in gl4.1
public z_ProgramUniform1i_adr := GetFuncAdr('glProgramUniform1i');
public 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);
begin
z_ProgramUniform1i_ovr_0(&program, location, v0);
end;
// added in gl4.1
public z_ProgramUniform1iv_adr := GetFuncAdr('glProgramUniform1iv');
public z_ProgramUniform1iv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: Int32)>(z_ProgramUniform1iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1iv(&program: UInt32; location: Int32; count: Int32; value: array of Int32);
begin
z_ProgramUniform1iv_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1iv(&program: UInt32; location: Int32; count: Int32; var value: Int32);
begin
z_ProgramUniform1iv_ovr_0(&program, location, count, value);
end;
public 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);
begin
z_ProgramUniform1iv_ovr_2(&program, location, count, value);
end;
// added in gl4.1
public z_ProgramUniform1ui_adr := GetFuncAdr('glProgramUniform1ui');
public 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);
begin
z_ProgramUniform1ui_ovr_0(&program, location, v0);
end;
// added in gl4.1
public z_ProgramUniform1uiv_adr := GetFuncAdr('glProgramUniform1uiv');
public z_ProgramUniform1uiv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: UInt32)>(z_ProgramUniform1uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1uiv(&program: UInt32; location: Int32; count: Int32; value: array of UInt32);
begin
z_ProgramUniform1uiv_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1uiv(&program: UInt32; location: Int32; count: Int32; var value: UInt32);
begin
z_ProgramUniform1uiv_ovr_0(&program, location, count, value);
end;
public 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);
begin
z_ProgramUniform1uiv_ovr_2(&program, location, count, value);
end;
// added in gl4.1
public z_ProgramUniform2d_adr := GetFuncAdr('glProgramUniform2d');
public 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);
begin
z_ProgramUniform2d_ovr_0(&program, location, v0, v1);
end;
// added in gl4.1
public z_ProgramUniform2dv_adr := GetFuncAdr('glProgramUniform2dv');
public z_ProgramUniform2dv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: real)>(z_ProgramUniform2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2dv(&program: UInt32; location: Int32; count: Int32; value: array of real);
begin
z_ProgramUniform2dv_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2dv(&program: UInt32; location: Int32; count: Int32; var value: real);
begin
z_ProgramUniform2dv_ovr_0(&program, location, count, value);
end;
public 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);
begin
z_ProgramUniform2dv_ovr_2(&program, location, count, value);
end;
// added in gl4.1
public z_ProgramUniform2f_adr := GetFuncAdr('glProgramUniform2f');
public 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);
begin
z_ProgramUniform2f_ovr_0(&program, location, v0, v1);
end;
// added in gl4.1
public z_ProgramUniform2fv_adr := GetFuncAdr('glProgramUniform2fv');
public z_ProgramUniform2fv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: single)>(z_ProgramUniform2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2fv(&program: UInt32; location: Int32; count: Int32; value: array of single);
begin
z_ProgramUniform2fv_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2fv(&program: UInt32; location: Int32; count: Int32; var value: single);
begin
z_ProgramUniform2fv_ovr_0(&program, location, count, value);
end;
public 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);
begin
z_ProgramUniform2fv_ovr_2(&program, location, count, value);
end;
// added in gl4.1
public z_ProgramUniform2i_adr := GetFuncAdr('glProgramUniform2i');
public 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);
begin
z_ProgramUniform2i_ovr_0(&program, location, v0, v1);
end;
// added in gl4.1
public z_ProgramUniform2iv_adr := GetFuncAdr('glProgramUniform2iv');
public z_ProgramUniform2iv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: Int32)>(z_ProgramUniform2iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2iv(&program: UInt32; location: Int32; count: Int32; value: array of Int32);
begin
z_ProgramUniform2iv_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2iv(&program: UInt32; location: Int32; count: Int32; var value: Int32);
begin
z_ProgramUniform2iv_ovr_0(&program, location, count, value);
end;
public 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);
begin
z_ProgramUniform2iv_ovr_2(&program, location, count, value);
end;
// added in gl4.1
public z_ProgramUniform2ui_adr := GetFuncAdr('glProgramUniform2ui');
public 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);
begin
z_ProgramUniform2ui_ovr_0(&program, location, v0, v1);
end;
// added in gl4.1
public z_ProgramUniform2uiv_adr := GetFuncAdr('glProgramUniform2uiv');
public z_ProgramUniform2uiv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: UInt32)>(z_ProgramUniform2uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2uiv(&program: UInt32; location: Int32; count: Int32; value: array of UInt32);
begin
z_ProgramUniform2uiv_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2uiv(&program: UInt32; location: Int32; count: Int32; var value: UInt32);
begin
z_ProgramUniform2uiv_ovr_0(&program, location, count, value);
end;
public 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);
begin
z_ProgramUniform2uiv_ovr_2(&program, location, count, value);
end;
// added in gl4.1
public z_ProgramUniform3d_adr := GetFuncAdr('glProgramUniform3d');
public 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);
begin
z_ProgramUniform3d_ovr_0(&program, location, v0, v1, v2);
end;
// added in gl4.1
public z_ProgramUniform3dv_adr := GetFuncAdr('glProgramUniform3dv');
public z_ProgramUniform3dv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: real)>(z_ProgramUniform3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3dv(&program: UInt32; location: Int32; count: Int32; value: array of real);
begin
z_ProgramUniform3dv_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3dv(&program: UInt32; location: Int32; count: Int32; var value: real);
begin
z_ProgramUniform3dv_ovr_0(&program, location, count, value);
end;
public 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);
begin
z_ProgramUniform3dv_ovr_2(&program, location, count, value);
end;
// added in gl4.1
public z_ProgramUniform3f_adr := GetFuncAdr('glProgramUniform3f');
public 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);
begin
z_ProgramUniform3f_ovr_0(&program, location, v0, v1, v2);
end;
// added in gl4.1
public z_ProgramUniform3fv_adr := GetFuncAdr('glProgramUniform3fv');
public z_ProgramUniform3fv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: single)>(z_ProgramUniform3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3fv(&program: UInt32; location: Int32; count: Int32; value: array of single);
begin
z_ProgramUniform3fv_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3fv(&program: UInt32; location: Int32; count: Int32; var value: single);
begin
z_ProgramUniform3fv_ovr_0(&program, location, count, value);
end;
public 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);
begin
z_ProgramUniform3fv_ovr_2(&program, location, count, value);
end;
// added in gl4.1
public z_ProgramUniform3i_adr := GetFuncAdr('glProgramUniform3i');
public 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);
begin
z_ProgramUniform3i_ovr_0(&program, location, v0, v1, v2);
end;
// added in gl4.1
public z_ProgramUniform3iv_adr := GetFuncAdr('glProgramUniform3iv');
public z_ProgramUniform3iv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: Int32)>(z_ProgramUniform3iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3iv(&program: UInt32; location: Int32; count: Int32; value: array of Int32);
begin
z_ProgramUniform3iv_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3iv(&program: UInt32; location: Int32; count: Int32; var value: Int32);
begin
z_ProgramUniform3iv_ovr_0(&program, location, count, value);
end;
public 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);
begin
z_ProgramUniform3iv_ovr_2(&program, location, count, value);
end;
// added in gl4.1
public z_ProgramUniform3ui_adr := GetFuncAdr('glProgramUniform3ui');
public 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);
begin
z_ProgramUniform3ui_ovr_0(&program, location, v0, v1, v2);
end;
// added in gl4.1
public z_ProgramUniform3uiv_adr := GetFuncAdr('glProgramUniform3uiv');
public z_ProgramUniform3uiv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: UInt32)>(z_ProgramUniform3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3uiv(&program: UInt32; location: Int32; count: Int32; value: array of UInt32);
begin
z_ProgramUniform3uiv_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3uiv(&program: UInt32; location: Int32; count: Int32; var value: UInt32);
begin
z_ProgramUniform3uiv_ovr_0(&program, location, count, value);
end;
public 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);
begin
z_ProgramUniform3uiv_ovr_2(&program, location, count, value);
end;
// added in gl4.1
public z_ProgramUniform4d_adr := GetFuncAdr('glProgramUniform4d');
public 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);
begin
z_ProgramUniform4d_ovr_0(&program, location, v0, v1, v2, v3);
end;
// added in gl4.1
public z_ProgramUniform4dv_adr := GetFuncAdr('glProgramUniform4dv');
public z_ProgramUniform4dv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: real)>(z_ProgramUniform4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4dv(&program: UInt32; location: Int32; count: Int32; value: array of real);
begin
z_ProgramUniform4dv_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4dv(&program: UInt32; location: Int32; count: Int32; var value: real);
begin
z_ProgramUniform4dv_ovr_0(&program, location, count, value);
end;
public 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);
begin
z_ProgramUniform4dv_ovr_2(&program, location, count, value);
end;
// added in gl4.1
public z_ProgramUniform4f_adr := GetFuncAdr('glProgramUniform4f');
public 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);
begin
z_ProgramUniform4f_ovr_0(&program, location, v0, v1, v2, v3);
end;
// added in gl4.1
public z_ProgramUniform4fv_adr := GetFuncAdr('glProgramUniform4fv');
public z_ProgramUniform4fv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: single)>(z_ProgramUniform4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4fv(&program: UInt32; location: Int32; count: Int32; value: array of single);
begin
z_ProgramUniform4fv_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4fv(&program: UInt32; location: Int32; count: Int32; var value: single);
begin
z_ProgramUniform4fv_ovr_0(&program, location, count, value);
end;
public 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);
begin
z_ProgramUniform4fv_ovr_2(&program, location, count, value);
end;
// added in gl4.1
public z_ProgramUniform4i_adr := GetFuncAdr('glProgramUniform4i');
public 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);
begin
z_ProgramUniform4i_ovr_0(&program, location, v0, v1, v2, v3);
end;
// added in gl4.1
public z_ProgramUniform4iv_adr := GetFuncAdr('glProgramUniform4iv');
public z_ProgramUniform4iv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: Int32)>(z_ProgramUniform4iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4iv(&program: UInt32; location: Int32; count: Int32; value: array of Int32);
begin
z_ProgramUniform4iv_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4iv(&program: UInt32; location: Int32; count: Int32; var value: Int32);
begin
z_ProgramUniform4iv_ovr_0(&program, location, count, value);
end;
public 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);
begin
z_ProgramUniform4iv_ovr_2(&program, location, count, value);
end;
// added in gl4.1
public z_ProgramUniform4ui_adr := GetFuncAdr('glProgramUniform4ui');
public 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);
begin
z_ProgramUniform4ui_ovr_0(&program, location, v0, v1, v2, v3);
end;
// added in gl4.1
public z_ProgramUniform4uiv_adr := GetFuncAdr('glProgramUniform4uiv');
public z_ProgramUniform4uiv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: UInt32)>(z_ProgramUniform4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4uiv(&program: UInt32; location: Int32; count: Int32; value: array of UInt32);
begin
z_ProgramUniform4uiv_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4uiv(&program: UInt32; location: Int32; count: Int32; var value: UInt32);
begin
z_ProgramUniform4uiv_ovr_0(&program, location, count, value);
end;
public 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);
begin
z_ProgramUniform4uiv_ovr_2(&program, location, count, value);
end;
// added in gl4.1
public z_ProgramUniformMatrix2dv_adr := GetFuncAdr('glProgramUniformMatrix2dv');
public z_ProgramUniformMatrix2dv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real)>(z_ProgramUniformMatrix2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real);
begin
z_ProgramUniformMatrix2dv_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
begin
z_ProgramUniformMatrix2dv_ovr_0(&program, location, count, transpose, value);
end;
public 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);
begin
z_ProgramUniformMatrix2dv_ovr_2(&program, location, count, transpose, value);
end;
// added in gl4.1
public z_ProgramUniformMatrix2fv_adr := GetFuncAdr('glProgramUniformMatrix2fv');
public z_ProgramUniformMatrix2fv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single)>(z_ProgramUniformMatrix2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_ProgramUniformMatrix2fv_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_ProgramUniformMatrix2fv_ovr_0(&program, location, count, transpose, value);
end;
public 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);
begin
z_ProgramUniformMatrix2fv_ovr_2(&program, location, count, transpose, value);
end;
// added in gl4.1
public z_ProgramUniformMatrix2x3dv_adr := GetFuncAdr('glProgramUniformMatrix2x3dv');
public z_ProgramUniformMatrix2x3dv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real)>(z_ProgramUniformMatrix2x3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real);
begin
z_ProgramUniformMatrix2x3dv_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
begin
z_ProgramUniformMatrix2x3dv_ovr_0(&program, location, count, transpose, value);
end;
public 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);
begin
z_ProgramUniformMatrix2x3dv_ovr_2(&program, location, count, transpose, value);
end;
// added in gl4.1
public z_ProgramUniformMatrix2x3fv_adr := GetFuncAdr('glProgramUniformMatrix2x3fv');
public z_ProgramUniformMatrix2x3fv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single)>(z_ProgramUniformMatrix2x3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_ProgramUniformMatrix2x3fv_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_ProgramUniformMatrix2x3fv_ovr_0(&program, location, count, transpose, value);
end;
public 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);
begin
z_ProgramUniformMatrix2x3fv_ovr_2(&program, location, count, transpose, value);
end;
// added in gl4.1
public z_ProgramUniformMatrix2x4dv_adr := GetFuncAdr('glProgramUniformMatrix2x4dv');
public z_ProgramUniformMatrix2x4dv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real)>(z_ProgramUniformMatrix2x4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real);
begin
z_ProgramUniformMatrix2x4dv_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
begin
z_ProgramUniformMatrix2x4dv_ovr_0(&program, location, count, transpose, value);
end;
public 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);
begin
z_ProgramUniformMatrix2x4dv_ovr_2(&program, location, count, transpose, value);
end;
// added in gl4.1
public z_ProgramUniformMatrix2x4fv_adr := GetFuncAdr('glProgramUniformMatrix2x4fv');
public z_ProgramUniformMatrix2x4fv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single)>(z_ProgramUniformMatrix2x4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_ProgramUniformMatrix2x4fv_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_ProgramUniformMatrix2x4fv_ovr_0(&program, location, count, transpose, value);
end;
public 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);
begin
z_ProgramUniformMatrix2x4fv_ovr_2(&program, location, count, transpose, value);
end;
// added in gl4.1
public z_ProgramUniformMatrix3dv_adr := GetFuncAdr('glProgramUniformMatrix3dv');
public z_ProgramUniformMatrix3dv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real)>(z_ProgramUniformMatrix3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real);
begin
z_ProgramUniformMatrix3dv_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
begin
z_ProgramUniformMatrix3dv_ovr_0(&program, location, count, transpose, value);
end;
public 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);
begin
z_ProgramUniformMatrix3dv_ovr_2(&program, location, count, transpose, value);
end;
// added in gl4.1
public z_ProgramUniformMatrix3fv_adr := GetFuncAdr('glProgramUniformMatrix3fv');
public z_ProgramUniformMatrix3fv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single)>(z_ProgramUniformMatrix3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_ProgramUniformMatrix3fv_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_ProgramUniformMatrix3fv_ovr_0(&program, location, count, transpose, value);
end;
public 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);
begin
z_ProgramUniformMatrix3fv_ovr_2(&program, location, count, transpose, value);
end;
// added in gl4.1
public z_ProgramUniformMatrix3x2dv_adr := GetFuncAdr('glProgramUniformMatrix3x2dv');
public z_ProgramUniformMatrix3x2dv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real)>(z_ProgramUniformMatrix3x2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real);
begin
z_ProgramUniformMatrix3x2dv_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
begin
z_ProgramUniformMatrix3x2dv_ovr_0(&program, location, count, transpose, value);
end;
public 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);
begin
z_ProgramUniformMatrix3x2dv_ovr_2(&program, location, count, transpose, value);
end;
// added in gl4.1
public z_ProgramUniformMatrix3x2fv_adr := GetFuncAdr('glProgramUniformMatrix3x2fv');
public z_ProgramUniformMatrix3x2fv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single)>(z_ProgramUniformMatrix3x2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_ProgramUniformMatrix3x2fv_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_ProgramUniformMatrix3x2fv_ovr_0(&program, location, count, transpose, value);
end;
public 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);
begin
z_ProgramUniformMatrix3x2fv_ovr_2(&program, location, count, transpose, value);
end;
// added in gl4.1
public z_ProgramUniformMatrix3x4dv_adr := GetFuncAdr('glProgramUniformMatrix3x4dv');
public z_ProgramUniformMatrix3x4dv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real)>(z_ProgramUniformMatrix3x4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real);
begin
z_ProgramUniformMatrix3x4dv_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
begin
z_ProgramUniformMatrix3x4dv_ovr_0(&program, location, count, transpose, value);
end;
public 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);
begin
z_ProgramUniformMatrix3x4dv_ovr_2(&program, location, count, transpose, value);
end;
// added in gl4.1
public z_ProgramUniformMatrix3x4fv_adr := GetFuncAdr('glProgramUniformMatrix3x4fv');
public z_ProgramUniformMatrix3x4fv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single)>(z_ProgramUniformMatrix3x4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_ProgramUniformMatrix3x4fv_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_ProgramUniformMatrix3x4fv_ovr_0(&program, location, count, transpose, value);
end;
public 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);
begin
z_ProgramUniformMatrix3x4fv_ovr_2(&program, location, count, transpose, value);
end;
// added in gl4.1
public z_ProgramUniformMatrix4dv_adr := GetFuncAdr('glProgramUniformMatrix4dv');
public z_ProgramUniformMatrix4dv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real)>(z_ProgramUniformMatrix4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real);
begin
z_ProgramUniformMatrix4dv_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
begin
z_ProgramUniformMatrix4dv_ovr_0(&program, location, count, transpose, value);
end;
public 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);
begin
z_ProgramUniformMatrix4dv_ovr_2(&program, location, count, transpose, value);
end;
// added in gl4.1
public z_ProgramUniformMatrix4fv_adr := GetFuncAdr('glProgramUniformMatrix4fv');
public z_ProgramUniformMatrix4fv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single)>(z_ProgramUniformMatrix4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_ProgramUniformMatrix4fv_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_ProgramUniformMatrix4fv_ovr_0(&program, location, count, transpose, value);
end;
public 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);
begin
z_ProgramUniformMatrix4fv_ovr_2(&program, location, count, transpose, value);
end;
// added in gl4.1
public z_ProgramUniformMatrix4x2dv_adr := GetFuncAdr('glProgramUniformMatrix4x2dv');
public z_ProgramUniformMatrix4x2dv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real)>(z_ProgramUniformMatrix4x2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real);
begin
z_ProgramUniformMatrix4x2dv_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
begin
z_ProgramUniformMatrix4x2dv_ovr_0(&program, location, count, transpose, value);
end;
public 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);
begin
z_ProgramUniformMatrix4x2dv_ovr_2(&program, location, count, transpose, value);
end;
// added in gl4.1
public z_ProgramUniformMatrix4x2fv_adr := GetFuncAdr('glProgramUniformMatrix4x2fv');
public z_ProgramUniformMatrix4x2fv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single)>(z_ProgramUniformMatrix4x2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_ProgramUniformMatrix4x2fv_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_ProgramUniformMatrix4x2fv_ovr_0(&program, location, count, transpose, value);
end;
public 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);
begin
z_ProgramUniformMatrix4x2fv_ovr_2(&program, location, count, transpose, value);
end;
// added in gl4.1
public z_ProgramUniformMatrix4x3dv_adr := GetFuncAdr('glProgramUniformMatrix4x3dv');
public z_ProgramUniformMatrix4x3dv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real)>(z_ProgramUniformMatrix4x3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real);
begin
z_ProgramUniformMatrix4x3dv_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3dv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
begin
z_ProgramUniformMatrix4x3dv_ovr_0(&program, location, count, transpose, value);
end;
public 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);
begin
z_ProgramUniformMatrix4x3dv_ovr_2(&program, location, count, transpose, value);
end;
// added in gl4.1
public z_ProgramUniformMatrix4x3fv_adr := GetFuncAdr('glProgramUniformMatrix4x3fv');
public z_ProgramUniformMatrix4x3fv_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single)>(z_ProgramUniformMatrix4x3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_ProgramUniformMatrix4x3fv_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3fv(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_ProgramUniformMatrix4x3fv_ovr_0(&program, location, count, transpose, value);
end;
public 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);
begin
z_ProgramUniformMatrix4x3fv_ovr_2(&program, location, count, transpose, value);
end;
// added in gl3.2
public z_ProvokingVertex_adr := GetFuncAdr('glProvokingVertex');
public z_ProvokingVertex_ovr_0 := GetFuncOrNil&<procedure(mode: VertexProvokingMode)>(z_ProvokingVertex_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProvokingVertex(mode: VertexProvokingMode);
begin
z_ProvokingVertex_ovr_0(mode);
end;
// added in gl4.3
public z_PushDebugGroup_adr := GetFuncAdr('glPushDebugGroup');
public 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);
begin
z_PushDebugGroup_ovr_0(source, id, length, message);
end;
// added in gl3.3
public z_QueryCounter_adr := GetFuncAdr('glQueryCounter');
public z_QueryCounter_ovr_0 := GetFuncOrNil&<procedure(id: QueryName; target: QueryCounterTarget)>(z_QueryCounter_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure QueryCounter(id: QueryName; target: QueryCounterTarget);
begin
z_QueryCounter_ovr_0(id, target);
end;
// added in gl1.0
private static procedure _z_ReadBuffer_ovr0(src: ReadBufferMode);
external 'opengl32.dll' name 'glReadBuffer';
public static z_ReadBuffer_ovr0 := _z_ReadBuffer_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReadBuffer(src: ReadBufferMode) := z_ReadBuffer_ovr0(src);
// added in gl4.5
public z_ReadnPixels_adr := GetFuncAdr('glReadnPixels');
public 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);
begin
z_ReadnPixels_ovr_0(x, y, width, height, format, &type, bufSize, data);
end;
// added in gl1.0
private static procedure _z_ReadPixels_ovr0(x: Int32; y: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glReadPixels';
public static z_ReadPixels_ovr0 := _z_ReadPixels_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReadPixels(x: Int32; y: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) := z_ReadPixels_ovr0(x, y, width, height, format, &type, pixels);
// added in gl4.1
public z_ReleaseShaderCompiler_adr := GetFuncAdr('glReleaseShaderCompiler');
public z_ReleaseShaderCompiler_ovr_0 := GetFuncOrNil&<procedure>(z_ReleaseShaderCompiler_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReleaseShaderCompiler;
begin
z_ReleaseShaderCompiler_ovr_0;
end;
// added in gl3.0
public z_RenderbufferStorage_adr := GetFuncAdr('glRenderbufferStorage');
public 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);
begin
z_RenderbufferStorage_ovr_0(target, _internalformat, width, height);
end;
// added in gl3.0
public z_RenderbufferStorageMultisample_adr := GetFuncAdr('glRenderbufferStorageMultisample');
public 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);
begin
z_RenderbufferStorageMultisample_ovr_0(target, samples, _internalformat, width, height);
end;
// added in gl4.0
public z_ResumeTransformFeedback_adr := GetFuncAdr('glResumeTransformFeedback');
public z_ResumeTransformFeedback_ovr_0 := GetFuncOrNil&<procedure>(z_ResumeTransformFeedback_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ResumeTransformFeedback;
begin
z_ResumeTransformFeedback_ovr_0;
end;
// added in gl1.3
public z_SampleCoverage_adr := GetFuncAdr('glSampleCoverage');
public z_SampleCoverage_ovr_0 := GetFuncOrNil&<procedure(value: single; invert: boolean)>(z_SampleCoverage_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SampleCoverage(value: single; invert: boolean);
begin
z_SampleCoverage_ovr_0(value, invert);
end;
// added in gl3.2
public z_SampleMaski_adr := GetFuncAdr('glSampleMaski');
public z_SampleMaski_ovr_0 := GetFuncOrNil&<procedure(maskNumber: UInt32; mask: DummyFlags)>(z_SampleMaski_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SampleMaski(maskNumber: UInt32; mask: DummyFlags);
begin
z_SampleMaski_ovr_0(maskNumber, mask);
end;
// added in gl3.3
public z_SamplerParameterf_adr := GetFuncAdr('glSamplerParameterf');
public 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);
begin
z_SamplerParameterf_ovr_0(sampler, pname, param);
end;
// added in gl3.3
public z_SamplerParameterfv_adr := GetFuncAdr('glSamplerParameterfv');
public z_SamplerParameterfv_ovr_0 := GetFuncOrNil&<procedure(sampler: UInt32; pname: OpenGL.SamplerParameterF; var param: single)>(z_SamplerParameterfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameterfv(sampler: UInt32; pname: OpenGL.SamplerParameterF; param: array of single);
begin
z_SamplerParameterfv_ovr_0(sampler, pname, param[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameterfv(sampler: UInt32; pname: OpenGL.SamplerParameterF; var param: single);
begin
z_SamplerParameterfv_ovr_0(sampler, pname, param);
end;
public 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);
begin
z_SamplerParameterfv_ovr_2(sampler, pname, param);
end;
// added in gl3.3
public z_SamplerParameteri_adr := GetFuncAdr('glSamplerParameteri');
public 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);
begin
z_SamplerParameteri_ovr_0(sampler, pname, param);
end;
// added in gl3.3
public z_SamplerParameterIiv_adr := GetFuncAdr('glSamplerParameterIiv');
public z_SamplerParameterIiv_ovr_0 := GetFuncOrNil&<procedure(sampler: UInt32; pname: OpenGL.SamplerParameterI; var param: Int32)>(z_SamplerParameterIiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameterIiv(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: array of Int32);
begin
z_SamplerParameterIiv_ovr_0(sampler, pname, param[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameterIiv(sampler: UInt32; pname: OpenGL.SamplerParameterI; var param: Int32);
begin
z_SamplerParameterIiv_ovr_0(sampler, pname, param);
end;
public 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);
begin
z_SamplerParameterIiv_ovr_2(sampler, pname, param);
end;
// added in gl3.3
public z_SamplerParameterIuiv_adr := GetFuncAdr('glSamplerParameterIuiv');
public z_SamplerParameterIuiv_ovr_0 := GetFuncOrNil&<procedure(sampler: UInt32; pname: OpenGL.SamplerParameterI; var param: UInt32)>(z_SamplerParameterIuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameterIuiv(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: array of UInt32);
begin
z_SamplerParameterIuiv_ovr_0(sampler, pname, param[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameterIuiv(sampler: UInt32; pname: OpenGL.SamplerParameterI; var param: UInt32);
begin
z_SamplerParameterIuiv_ovr_0(sampler, pname, param);
end;
public 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);
begin
z_SamplerParameterIuiv_ovr_2(sampler, pname, param);
end;
// added in gl3.3
public z_SamplerParameteriv_adr := GetFuncAdr('glSamplerParameteriv');
public z_SamplerParameteriv_ovr_0 := GetFuncOrNil&<procedure(sampler: UInt32; pname: OpenGL.SamplerParameterI; var param: Int32)>(z_SamplerParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameteriv(sampler: UInt32; pname: OpenGL.SamplerParameterI; param: array of Int32);
begin
z_SamplerParameteriv_ovr_0(sampler, pname, param[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplerParameteriv(sampler: UInt32; pname: OpenGL.SamplerParameterI; var param: Int32);
begin
z_SamplerParameteriv_ovr_0(sampler, pname, param);
end;
public 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);
begin
z_SamplerParameteriv_ovr_2(sampler, pname, param);
end;
// added in gl1.0
private static procedure _z_Scissor_ovr0(x: Int32; y: Int32; width: Int32; height: Int32);
external 'opengl32.dll' name 'glScissor';
public static z_Scissor_ovr0 := _z_Scissor_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Scissor(x: Int32; y: Int32; width: Int32; height: Int32) := z_Scissor_ovr0(x, y, width, height);
// added in gl4.1
public z_ScissorArrayv_adr := GetFuncAdr('glScissorArrayv');
public z_ScissorArrayv_ovr_0 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var v: Int32)>(z_ScissorArrayv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScissorArrayv(first: UInt32; count: Int32; v: array of Int32);
begin
z_ScissorArrayv_ovr_0(first, count, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScissorArrayv(first: UInt32; count: Int32; var v: Int32);
begin
z_ScissorArrayv_ovr_0(first, count, v);
end;
public 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);
begin
z_ScissorArrayv_ovr_2(first, count, v);
end;
// added in gl4.1
public z_ScissorIndexed_adr := GetFuncAdr('glScissorIndexed');
public 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);
begin
z_ScissorIndexed_ovr_0(index, left, bottom, width, height);
end;
// added in gl4.1
public z_ScissorIndexedv_adr := GetFuncAdr('glScissorIndexedv');
public z_ScissorIndexedv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int32)>(z_ScissorIndexedv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScissorIndexedv(index: UInt32; v: array of Int32);
begin
z_ScissorIndexedv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScissorIndexedv(index: UInt32; var v: Int32);
begin
z_ScissorIndexedv_ovr_0(index, v);
end;
public z_ScissorIndexedv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_ScissorIndexedv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScissorIndexedv(index: UInt32; v: IntPtr);
begin
z_ScissorIndexedv_ovr_2(index, v);
end;
// added in gl3.3
public z_SecondaryColorP3ui_adr := GetFuncAdr('glSecondaryColorP3ui');
public z_SecondaryColorP3ui_ovr_0 := GetFuncOrNil&<procedure(&type: ColorPointerType; color: UInt32)>(z_SecondaryColorP3ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColorP3ui(&type: ColorPointerType; color: UInt32);
begin
z_SecondaryColorP3ui_ovr_0(&type, color);
end;
// added in gl3.3
public z_SecondaryColorP3uiv_adr := GetFuncAdr('glSecondaryColorP3uiv');
public z_SecondaryColorP3uiv_ovr_0 := GetFuncOrNil&<procedure(&type: ColorPointerType; var color: UInt32)>(z_SecondaryColorP3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColorP3uiv(&type: ColorPointerType; color: array of UInt32);
begin
z_SecondaryColorP3uiv_ovr_0(&type, color[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColorP3uiv(&type: ColorPointerType; var color: UInt32);
begin
z_SecondaryColorP3uiv_ovr_0(&type, color);
end;
public z_SecondaryColorP3uiv_ovr_2 := GetFuncOrNil&<procedure(&type: ColorPointerType; color: IntPtr)>(z_SecondaryColorP3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColorP3uiv(&type: ColorPointerType; color: IntPtr);
begin
z_SecondaryColorP3uiv_ovr_2(&type, color);
end;
// added in gl4.1
public z_ShaderBinary_adr := GetFuncAdr('glShaderBinary');
public z_ShaderBinary_ovr_0 := GetFuncOrNil&<procedure(count: Int32; var shaders: UInt32; 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);
begin
z_ShaderBinary_ovr_0(count, shaders[0], binaryformat, binary, length);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderBinary(count: Int32; var shaders: UInt32; binaryformat: DummyEnum; binary: IntPtr; length: Int32);
begin
z_ShaderBinary_ovr_0(count, shaders, binaryformat, binary, length);
end;
public 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);
begin
z_ShaderBinary_ovr_2(count, shaders, binaryformat, binary, length);
end;
// added in gl2.0
public z_ShaderSource_adr := GetFuncAdr('glShaderSource');
public z_ShaderSource_ovr_0 := GetFuncOrNil&<procedure(shader: ShaderName; count: Int32; var _string: IntPtr; var length: Int32)>(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));
z_ShaderSource_ovr_0(shader, count, par_3_str_ptr[0], length[0]);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
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));
z_ShaderSource_ovr_0(shader, count, par_3_str_ptr[0], length);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
public z_ShaderSource_ovr_2 := GetFuncOrNil&<procedure(shader: ShaderName; count: Int32; var _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));
z_ShaderSource_ovr_2(shader, count, par_3_str_ptr[0], length);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSource(shader: ShaderName; count: Int32; _string: array of IntPtr; length: array of Int32);
begin
z_ShaderSource_ovr_0(shader, count, _string[0], length[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSource(shader: ShaderName; count: Int32; _string: array of IntPtr; var length: Int32);
begin
z_ShaderSource_ovr_0(shader, count, _string[0], length);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSource(shader: ShaderName; count: Int32; _string: array of IntPtr; length: IntPtr);
begin
z_ShaderSource_ovr_2(shader, count, _string[0], length);
end;
public z_ShaderSource_ovr_6 := 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: IntPtr; length: array of Int32);
begin
z_ShaderSource_ovr_6(shader, count, _string, length[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSource(shader: ShaderName; count: Int32; _string: IntPtr; var length: Int32);
begin
z_ShaderSource_ovr_6(shader, count, _string, length);
end;
public 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);
begin
z_ShaderSource_ovr_8(shader, count, _string, length);
end;
// added in gl4.3
public z_ShaderStorageBlockBinding_adr := GetFuncAdr('glShaderStorageBlockBinding');
public 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);
begin
z_ShaderStorageBlockBinding_ovr_0(&program, storageBlockIndex, storageBlockBinding);
end;
// added in gl4.6
public z_SpecializeShader_adr := GetFuncAdr('glSpecializeShader');
public z_SpecializeShader_ovr_0 := GetFuncOrNil&<procedure(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; var pConstantValue: UInt32)>(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);
z_SpecializeShader_ovr_0(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex[0], pConstantValue[0]);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
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);
z_SpecializeShader_ovr_0(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex[0], pConstantValue);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public z_SpecializeShader_ovr_2 := GetFuncOrNil&<procedure(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; 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);
z_SpecializeShader_ovr_2(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex[0], 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);
z_SpecializeShader_ovr_0(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex, pConstantValue[0]);
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;
public z_SpecializeShader_ovr_6 := 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: IntPtr; pConstantValue: array of UInt32);
begin
var par_2_str_ptr := Marshal.StringToHGlobalAnsi(pEntryPoint);
z_SpecializeShader_ovr_6(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex, pConstantValue[0]);
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;
public 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);
begin
z_SpecializeShader_ovr_0(shader, pEntryPoint, numSpecializationConstants, pConstantIndex[0], pConstantValue[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShader(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: array of UInt32; var pConstantValue: UInt32);
begin
z_SpecializeShader_ovr_0(shader, pEntryPoint, numSpecializationConstants, pConstantIndex[0], pConstantValue);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShader(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: array of UInt32; pConstantValue: IntPtr);
begin
z_SpecializeShader_ovr_2(shader, pEntryPoint, numSpecializationConstants, pConstantIndex[0], pConstantValue);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShader(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; pConstantValue: array of UInt32);
begin
z_SpecializeShader_ovr_0(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShader(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; var pConstantValue: UInt32);
begin
z_SpecializeShader_ovr_0(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShader(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; pConstantValue: IntPtr);
begin
z_SpecializeShader_ovr_2(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShader(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; pConstantValue: array of UInt32);
begin
z_SpecializeShader_ovr_6(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShader(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; var pConstantValue: UInt32);
begin
z_SpecializeShader_ovr_6(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShader(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; pConstantValue: IntPtr);
begin
z_SpecializeShader_ovr_8(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue);
end;
// added in gl1.0
private static procedure _z_StencilFunc_ovr0(func: StencilFunction; ref: Int32; mask: UInt32);
external 'opengl32.dll' name 'glStencilFunc';
public static z_StencilFunc_ovr0 := _z_StencilFunc_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilFunc(func: StencilFunction; ref: Int32; mask: UInt32) := z_StencilFunc_ovr0(func, ref, mask);
// added in gl2.0
public z_StencilFuncSeparate_adr := GetFuncAdr('glStencilFuncSeparate');
public 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);
begin
z_StencilFuncSeparate_ovr_0(face, func, ref, mask);
end;
// added in gl1.0
private static procedure _z_StencilMask_ovr0(mask: UInt32);
external 'opengl32.dll' name 'glStencilMask';
public static z_StencilMask_ovr0 := _z_StencilMask_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilMask(mask: UInt32) := z_StencilMask_ovr0(mask);
// added in gl2.0
public z_StencilMaskSeparate_adr := GetFuncAdr('glStencilMaskSeparate');
public z_StencilMaskSeparate_ovr_0 := GetFuncOrNil&<procedure(face: StencilFaceDirection; mask: UInt32)>(z_StencilMaskSeparate_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilMaskSeparate(face: StencilFaceDirection; mask: UInt32);
begin
z_StencilMaskSeparate_ovr_0(face, mask);
end;
// added in gl1.0
private static procedure _z_StencilOp_ovr0(fail: OpenGL.StencilOp; zfail: OpenGL.StencilOp; zpass: OpenGL.StencilOp);
external 'opengl32.dll' name 'glStencilOp';
public static z_StencilOp_ovr0 := _z_StencilOp_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilOp(fail: OpenGL.StencilOp; zfail: OpenGL.StencilOp; zpass: OpenGL.StencilOp) := z_StencilOp_ovr0(fail, zfail, zpass);
// added in gl2.0
public z_StencilOpSeparate_adr := GetFuncAdr('glStencilOpSeparate');
public 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);
begin
z_StencilOpSeparate_ovr_0(face, sfail, dpfail, dppass);
end;
// added in gl3.1
public z_TexBuffer_adr := GetFuncAdr('glTexBuffer');
public 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);
begin
z_TexBuffer_ovr_0(target, _internalformat, buffer);
end;
// added in gl4.3
public z_TexBufferRange_adr := GetFuncAdr('glTexBufferRange');
public 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);
begin
z_TexBufferRange_ovr_0(target, _internalformat, buffer, offset, size);
end;
// added in gl3.3
public z_TexCoordP1ui_adr := GetFuncAdr('glTexCoordP1ui');
public z_TexCoordP1ui_ovr_0 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; coords: UInt32)>(z_TexCoordP1ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP1ui(&type: TexCoordPointerType; coords: UInt32);
begin
z_TexCoordP1ui_ovr_0(&type, coords);
end;
// added in gl3.3
public z_TexCoordP1uiv_adr := GetFuncAdr('glTexCoordP1uiv');
public z_TexCoordP1uiv_ovr_0 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; var coords: UInt32)>(z_TexCoordP1uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP1uiv(&type: TexCoordPointerType; coords: array of UInt32);
begin
z_TexCoordP1uiv_ovr_0(&type, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP1uiv(&type: TexCoordPointerType; var coords: UInt32);
begin
z_TexCoordP1uiv_ovr_0(&type, coords);
end;
public z_TexCoordP1uiv_ovr_2 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; coords: IntPtr)>(z_TexCoordP1uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP1uiv(&type: TexCoordPointerType; coords: IntPtr);
begin
z_TexCoordP1uiv_ovr_2(&type, coords);
end;
// added in gl3.3
public z_TexCoordP2ui_adr := GetFuncAdr('glTexCoordP2ui');
public z_TexCoordP2ui_ovr_0 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; coords: UInt32)>(z_TexCoordP2ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP2ui(&type: TexCoordPointerType; coords: UInt32);
begin
z_TexCoordP2ui_ovr_0(&type, coords);
end;
// added in gl3.3
public z_TexCoordP2uiv_adr := GetFuncAdr('glTexCoordP2uiv');
public z_TexCoordP2uiv_ovr_0 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; var coords: UInt32)>(z_TexCoordP2uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP2uiv(&type: TexCoordPointerType; coords: array of UInt32);
begin
z_TexCoordP2uiv_ovr_0(&type, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP2uiv(&type: TexCoordPointerType; var coords: UInt32);
begin
z_TexCoordP2uiv_ovr_0(&type, coords);
end;
public z_TexCoordP2uiv_ovr_2 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; coords: IntPtr)>(z_TexCoordP2uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP2uiv(&type: TexCoordPointerType; coords: IntPtr);
begin
z_TexCoordP2uiv_ovr_2(&type, coords);
end;
// added in gl3.3
public z_TexCoordP3ui_adr := GetFuncAdr('glTexCoordP3ui');
public z_TexCoordP3ui_ovr_0 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; coords: UInt32)>(z_TexCoordP3ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP3ui(&type: TexCoordPointerType; coords: UInt32);
begin
z_TexCoordP3ui_ovr_0(&type, coords);
end;
// added in gl3.3
public z_TexCoordP3uiv_adr := GetFuncAdr('glTexCoordP3uiv');
public z_TexCoordP3uiv_ovr_0 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; var coords: UInt32)>(z_TexCoordP3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP3uiv(&type: TexCoordPointerType; coords: array of UInt32);
begin
z_TexCoordP3uiv_ovr_0(&type, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP3uiv(&type: TexCoordPointerType; var coords: UInt32);
begin
z_TexCoordP3uiv_ovr_0(&type, coords);
end;
public z_TexCoordP3uiv_ovr_2 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; coords: IntPtr)>(z_TexCoordP3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP3uiv(&type: TexCoordPointerType; coords: IntPtr);
begin
z_TexCoordP3uiv_ovr_2(&type, coords);
end;
// added in gl3.3
public z_TexCoordP4ui_adr := GetFuncAdr('glTexCoordP4ui');
public z_TexCoordP4ui_ovr_0 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; coords: UInt32)>(z_TexCoordP4ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP4ui(&type: TexCoordPointerType; coords: UInt32);
begin
z_TexCoordP4ui_ovr_0(&type, coords);
end;
// added in gl3.3
public z_TexCoordP4uiv_adr := GetFuncAdr('glTexCoordP4uiv');
public z_TexCoordP4uiv_ovr_0 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; var coords: UInt32)>(z_TexCoordP4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP4uiv(&type: TexCoordPointerType; coords: array of UInt32);
begin
z_TexCoordP4uiv_ovr_0(&type, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP4uiv(&type: TexCoordPointerType; var coords: UInt32);
begin
z_TexCoordP4uiv_ovr_0(&type, coords);
end;
public z_TexCoordP4uiv_ovr_2 := GetFuncOrNil&<procedure(&type: TexCoordPointerType; coords: IntPtr)>(z_TexCoordP4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordP4uiv(&type: TexCoordPointerType; coords: IntPtr);
begin
z_TexCoordP4uiv_ovr_2(&type, coords);
end;
// added in gl1.0
private static procedure _z_TexImage1D_ovr0(target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glTexImage1D';
public static z_TexImage1D_ovr0 := _z_TexImage1D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexImage1D(target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) := z_TexImage1D_ovr0(target, level, internalformat, width, border, format, &type, pixels);
// added in gl1.0
private static procedure _z_TexImage2D_ovr0(target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; height: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glTexImage2D';
public static z_TexImage2D_ovr0 := _z_TexImage2D_ovr0;
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_ovr0(target, level, internalformat, width, height, border, format, &type, pixels);
// added in gl3.2
public z_TexImage2DMultisample_adr := GetFuncAdr('glTexImage2DMultisample');
public 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);
begin
z_TexImage2DMultisample_ovr_0(target, samples, _internalformat, width, height, fixedsamplelocations);
end;
// added in gl1.2
public z_TexImage3D_adr := GetFuncAdr('glTexImage3D');
public 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);
begin
z_TexImage3D_ovr_0(target, level, internalformat, width, height, depth, border, format, &type, pixels);
end;
// added in gl3.2
public z_TexImage3DMultisample_adr := GetFuncAdr('glTexImage3DMultisample');
public 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);
begin
z_TexImage3DMultisample_ovr_0(target, samples, _internalformat, width, height, depth, fixedsamplelocations);
end;
// added in gl1.0
private static procedure _z_TexParameterf_ovr0(target: TextureTarget; pname: TextureParameterName; param: single);
external 'opengl32.dll' name 'glTexParameterf';
public static z_TexParameterf_ovr0 := _z_TexParameterf_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterf(target: TextureTarget; pname: TextureParameterName; param: single) := z_TexParameterf_ovr0(target, pname, param);
// added in gl1.0
private static procedure _z_TexParameterfv_ovr0(target: TextureTarget; pname: TextureParameterName; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of single);
external 'opengl32.dll' name 'glTexParameterfv';
public static z_TexParameterfv_ovr0 := _z_TexParameterfv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterfv(target: TextureTarget; pname: TextureParameterName; ¶ms: array of single) := z_TexParameterfv_ovr0(target, pname, ¶ms);
private static procedure _z_TexParameterfv_ovr1(target: TextureTarget; pname: TextureParameterName; var ¶ms: single);
external 'opengl32.dll' name 'glTexParameterfv';
public static z_TexParameterfv_ovr1 := _z_TexParameterfv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterfv(target: TextureTarget; pname: TextureParameterName; var ¶ms: single) := z_TexParameterfv_ovr1(target, pname, ¶ms);
private static procedure _z_TexParameterfv_ovr2(target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexParameterfv';
public static z_TexParameterfv_ovr2 := _z_TexParameterfv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterfv(target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr) := z_TexParameterfv_ovr2(target, pname, ¶ms);
// added in gl1.0
private static procedure _z_TexParameteri_ovr0(target: TextureTarget; pname: TextureParameterName; param: Int32);
external 'opengl32.dll' name 'glTexParameteri';
public static z_TexParameteri_ovr0 := _z_TexParameteri_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameteri(target: TextureTarget; pname: TextureParameterName; param: Int32) := z_TexParameteri_ovr0(target, pname, param);
// added in gl3.0
public z_TexParameterIiv_adr := GetFuncAdr('glTexParameterIiv');
public z_TexParameterIiv_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32)>(z_TexParameterIiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterIiv(target: TextureTarget; pname: TextureParameterName; ¶ms: array of Int32);
begin
z_TexParameterIiv_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterIiv(target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32);
begin
z_TexParameterIiv_ovr_0(target, pname, ¶ms);
end;
public 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);
begin
z_TexParameterIiv_ovr_2(target, pname, ¶ms);
end;
// added in gl3.0
public z_TexParameterIuiv_adr := GetFuncAdr('glTexParameterIuiv');
public z_TexParameterIuiv_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; pname: TextureParameterName; var ¶ms: UInt32)>(z_TexParameterIuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterIuiv(target: TextureTarget; pname: TextureParameterName; ¶ms: array of UInt32);
begin
z_TexParameterIuiv_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterIuiv(target: TextureTarget; pname: TextureParameterName; var ¶ms: UInt32);
begin
z_TexParameterIuiv_ovr_0(target, pname, ¶ms);
end;
public 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);
begin
z_TexParameterIuiv_ovr_2(target, pname, ¶ms);
end;
// added in gl1.0
private static procedure _z_TexParameteriv_ovr0(target: TextureTarget; pname: TextureParameterName; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of Int32);
external 'opengl32.dll' name 'glTexParameteriv';
public static z_TexParameteriv_ovr0 := _z_TexParameteriv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameteriv(target: TextureTarget; pname: TextureParameterName; ¶ms: array of Int32) := z_TexParameteriv_ovr0(target, pname, ¶ms);
private static procedure _z_TexParameteriv_ovr1(target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32);
external 'opengl32.dll' name 'glTexParameteriv';
public static z_TexParameteriv_ovr1 := _z_TexParameteriv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameteriv(target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32) := z_TexParameteriv_ovr1(target, pname, ¶ms);
private static procedure _z_TexParameteriv_ovr2(target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexParameteriv';
public static z_TexParameteriv_ovr2 := _z_TexParameteriv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameteriv(target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr) := z_TexParameteriv_ovr2(target, pname, ¶ms);
// added in gl4.2
public z_TexStorage1D_adr := GetFuncAdr('glTexStorage1D');
public 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);
begin
z_TexStorage1D_ovr_0(target, levels, _internalformat, width);
end;
// added in gl4.2
public z_TexStorage2D_adr := GetFuncAdr('glTexStorage2D');
public 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);
begin
z_TexStorage2D_ovr_0(target, levels, _internalformat, width, height);
end;
// added in gl4.3
public z_TexStorage2DMultisample_adr := GetFuncAdr('glTexStorage2DMultisample');
public 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);
begin
z_TexStorage2DMultisample_ovr_0(target, samples, _internalformat, width, height, fixedsamplelocations);
end;
// added in gl4.2
public z_TexStorage3D_adr := GetFuncAdr('glTexStorage3D');
public 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);
begin
z_TexStorage3D_ovr_0(target, levels, _internalformat, width, height, depth);
end;
// added in gl4.3
public z_TexStorage3DMultisample_adr := GetFuncAdr('glTexStorage3DMultisample');
public 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);
begin
z_TexStorage3DMultisample_ovr_0(target, samples, _internalformat, width, height, depth, fixedsamplelocations);
end;
// added in gl1.1
private static procedure _z_TexSubImage1D_ovr0(target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glTexSubImage1D';
public static z_TexSubImage1D_ovr0 := _z_TexSubImage1D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexSubImage1D(target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) := z_TexSubImage1D_ovr0(target, level, xoffset, width, format, &type, pixels);
// added in gl1.1
private static procedure _z_TexSubImage2D_ovr0(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glTexSubImage2D';
public static z_TexSubImage2D_ovr0 := _z_TexSubImage2D_ovr0;
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_ovr0(target, level, xoffset, yoffset, width, height, format, &type, pixels);
// added in gl1.2
public z_TexSubImage3D_adr := GetFuncAdr('glTexSubImage3D');
public 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);
begin
z_TexSubImage3D_ovr_0(target, level, xoffset, yoffset, zoffset, width, height, depth, format, &type, pixels);
end;
// added in gl4.5
public z_TextureBarrier_adr := GetFuncAdr('glTextureBarrier');
public z_TextureBarrier_ovr_0 := GetFuncOrNil&<procedure>(z_TextureBarrier_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureBarrier;
begin
z_TextureBarrier_ovr_0;
end;
// added in gl4.5
public z_TextureBuffer_adr := GetFuncAdr('glTextureBuffer');
public 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);
begin
z_TextureBuffer_ovr_0(texture, _internalformat, buffer);
end;
// added in gl4.5
public z_TextureBufferRange_adr := GetFuncAdr('glTextureBufferRange');
public 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);
begin
z_TextureBufferRange_ovr_0(texture, _internalformat, buffer, offset, size);
end;
// added in gl4.5
public z_TextureParameterf_adr := GetFuncAdr('glTextureParameterf');
public 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);
begin
z_TextureParameterf_ovr_0(texture, pname, param);
end;
// added in gl4.5
public z_TextureParameterfv_adr := GetFuncAdr('glTextureParameterfv');
public z_TextureParameterfv_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; pname: TextureParameterName; var param: single)>(z_TextureParameterfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterfv(texture: UInt32; pname: TextureParameterName; param: array of single);
begin
z_TextureParameterfv_ovr_0(texture, pname, param[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterfv(texture: UInt32; pname: TextureParameterName; var param: single);
begin
z_TextureParameterfv_ovr_0(texture, pname, param);
end;
public 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);
begin
z_TextureParameterfv_ovr_2(texture, pname, param);
end;
// added in gl4.5
public z_TextureParameteri_adr := GetFuncAdr('glTextureParameteri');
public 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);
begin
z_TextureParameteri_ovr_0(texture, pname, param);
end;
// added in gl4.5
public z_TextureParameterIiv_adr := GetFuncAdr('glTextureParameterIiv');
public z_TextureParameterIiv_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; pname: TextureParameterName; var ¶ms: Int32)>(z_TextureParameterIiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIiv(texture: UInt32; pname: TextureParameterName; ¶ms: array of Int32);
begin
z_TextureParameterIiv_ovr_0(texture, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIiv(texture: UInt32; pname: TextureParameterName; var ¶ms: Int32);
begin
z_TextureParameterIiv_ovr_0(texture, pname, ¶ms);
end;
public 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);
begin
z_TextureParameterIiv_ovr_2(texture, pname, ¶ms);
end;
// added in gl4.5
public z_TextureParameterIuiv_adr := GetFuncAdr('glTextureParameterIuiv');
public z_TextureParameterIuiv_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; pname: TextureParameterName; var ¶ms: UInt32)>(z_TextureParameterIuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIuiv(texture: UInt32; pname: TextureParameterName; ¶ms: array of UInt32);
begin
z_TextureParameterIuiv_ovr_0(texture, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIuiv(texture: UInt32; pname: TextureParameterName; var ¶ms: UInt32);
begin
z_TextureParameterIuiv_ovr_0(texture, pname, ¶ms);
end;
public 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);
begin
z_TextureParameterIuiv_ovr_2(texture, pname, ¶ms);
end;
// added in gl4.5
public z_TextureParameteriv_adr := GetFuncAdr('glTextureParameteriv');
public z_TextureParameteriv_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; pname: TextureParameterName; var param: Int32)>(z_TextureParameteriv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameteriv(texture: UInt32; pname: TextureParameterName; param: array of Int32);
begin
z_TextureParameteriv_ovr_0(texture, pname, param[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameteriv(texture: UInt32; pname: TextureParameterName; var param: Int32);
begin
z_TextureParameteriv_ovr_0(texture, pname, param);
end;
public 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);
begin
z_TextureParameteriv_ovr_2(texture, pname, param);
end;
// added in gl4.5
public z_TextureStorage1D_adr := GetFuncAdr('glTextureStorage1D');
public 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);
begin
z_TextureStorage1D_ovr_0(texture, levels, _internalformat, width);
end;
// added in gl4.5
public z_TextureStorage2D_adr := GetFuncAdr('glTextureStorage2D');
public 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);
begin
z_TextureStorage2D_ovr_0(texture, levels, _internalformat, width, height);
end;
// added in gl4.5
public z_TextureStorage2DMultisample_adr := GetFuncAdr('glTextureStorage2DMultisample');
public 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);
begin
z_TextureStorage2DMultisample_ovr_0(texture, samples, _internalformat, width, height, fixedsamplelocations);
end;
// added in gl4.5
public z_TextureStorage3D_adr := GetFuncAdr('glTextureStorage3D');
public 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);
begin
z_TextureStorage3D_ovr_0(texture, levels, _internalformat, width, height, depth);
end;
// added in gl4.5
public z_TextureStorage3DMultisample_adr := GetFuncAdr('glTextureStorage3DMultisample');
public 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);
begin
z_TextureStorage3DMultisample_ovr_0(texture, samples, _internalformat, width, height, depth, fixedsamplelocations);
end;
// added in gl4.5
public z_TextureSubImage1D_adr := GetFuncAdr('glTextureSubImage1D');
public 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);
begin
z_TextureSubImage1D_ovr_0(texture, level, xoffset, width, format, &type, pixels);
end;
// added in gl4.5
public z_TextureSubImage2D_adr := GetFuncAdr('glTextureSubImage2D');
public 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);
begin
z_TextureSubImage2D_ovr_0(texture, level, xoffset, yoffset, width, height, format, &type, pixels);
end;
// added in gl4.5
public z_TextureSubImage3D_adr := GetFuncAdr('glTextureSubImage3D');
public 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);
begin
z_TextureSubImage3D_ovr_0(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, &type, pixels);
end;
// added in gl4.3
public z_TextureView_adr := GetFuncAdr('glTextureView');
public 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);
begin
z_TextureView_ovr_0(texture, target, origtexture, _internalformat, minlevel, numlevels, minlayer, numlayers);
end;
// added in gl4.5
public z_TransformFeedbackBufferBase_adr := GetFuncAdr('glTransformFeedbackBufferBase');
public 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);
begin
z_TransformFeedbackBufferBase_ovr_0(xfb, index, buffer);
end;
// added in gl4.5
public z_TransformFeedbackBufferRange_adr := GetFuncAdr('glTransformFeedbackBufferRange');
public 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);
begin
z_TransformFeedbackBufferRange_ovr_0(xfb, index, buffer, offset, size);
end;
// added in gl3.0
public z_TransformFeedbackVaryings_adr := GetFuncAdr('glTransformFeedbackVaryings');
public z_TransformFeedbackVaryings_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; count: Int32; var 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));
z_TransformFeedbackVaryings_ovr_0(&program, count, par_3_str_ptr[0], bufferMode);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackVaryings(&program: UInt32; count: Int32; varyings: array of IntPtr; bufferMode: TransformFeedbackBufferMode);
begin
z_TransformFeedbackVaryings_ovr_0(&program, count, varyings[0], bufferMode);
end;
public 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);
begin
z_TransformFeedbackVaryings_ovr_2(&program, count, varyings, bufferMode);
end;
// added in gl4.0
public z_Uniform1d_adr := GetFuncAdr('glUniform1d');
public z_Uniform1d_ovr_0 := GetFuncOrNil&<procedure(location: Int32; x: real)>(z_Uniform1d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1d(location: Int32; x: real);
begin
z_Uniform1d_ovr_0(location, x);
end;
// added in gl4.0
public z_Uniform1dv_adr := GetFuncAdr('glUniform1dv');
public z_Uniform1dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: real)>(z_Uniform1dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1dv(location: Int32; count: Int32; value: array of real);
begin
z_Uniform1dv_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1dv(location: Int32; count: Int32; var value: real);
begin
z_Uniform1dv_ovr_0(location, count, value);
end;
public 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);
begin
z_Uniform1dv_ovr_2(location, count, value);
end;
// added in gl2.0
public z_Uniform1f_adr := GetFuncAdr('glUniform1f');
public z_Uniform1f_ovr_0 := GetFuncOrNil&<procedure(location: Int32; v0: single)>(z_Uniform1f_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1f(location: Int32; v0: single);
begin
z_Uniform1f_ovr_0(location, v0);
end;
// added in gl2.0
public z_Uniform1fv_adr := GetFuncAdr('glUniform1fv');
public z_Uniform1fv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: single)>(z_Uniform1fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1fv(location: Int32; count: Int32; value: array of single);
begin
z_Uniform1fv_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1fv(location: Int32; count: Int32; var value: single);
begin
z_Uniform1fv_ovr_0(location, count, value);
end;
public 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);
begin
z_Uniform1fv_ovr_2(location, count, value);
end;
// added in gl2.0
public z_Uniform1i_adr := GetFuncAdr('glUniform1i');
public z_Uniform1i_ovr_0 := GetFuncOrNil&<procedure(location: Int32; v0: Int32)>(z_Uniform1i_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1i(location: Int32; v0: Int32);
begin
z_Uniform1i_ovr_0(location, v0);
end;
// added in gl2.0
public z_Uniform1iv_adr := GetFuncAdr('glUniform1iv');
public z_Uniform1iv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Int32)>(z_Uniform1iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1iv(location: Int32; count: Int32; value: array of Int32);
begin
z_Uniform1iv_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1iv(location: Int32; count: Int32; var value: Int32);
begin
z_Uniform1iv_ovr_0(location, count, value);
end;
public 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);
begin
z_Uniform1iv_ovr_2(location, count, value);
end;
// added in gl3.0
public z_Uniform1ui_adr := GetFuncAdr('glUniform1ui');
public z_Uniform1ui_ovr_0 := GetFuncOrNil&<procedure(location: Int32; v0: UInt32)>(z_Uniform1ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ui(location: Int32; v0: UInt32);
begin
z_Uniform1ui_ovr_0(location, v0);
end;
// added in gl3.0
public z_Uniform1uiv_adr := GetFuncAdr('glUniform1uiv');
public z_Uniform1uiv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: UInt32)>(z_Uniform1uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1uiv(location: Int32; count: Int32; value: array of UInt32);
begin
z_Uniform1uiv_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1uiv(location: Int32; count: Int32; var value: UInt32);
begin
z_Uniform1uiv_ovr_0(location, count, value);
end;
public 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);
begin
z_Uniform1uiv_ovr_2(location, count, value);
end;
// added in gl4.0
public z_Uniform2d_adr := GetFuncAdr('glUniform2d');
public 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);
begin
z_Uniform2d_ovr_0(location, x, y);
end;
// added in gl4.0
public z_Uniform2dv_adr := GetFuncAdr('glUniform2dv');
public z_Uniform2dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: real)>(z_Uniform2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2dv(location: Int32; count: Int32; value: array of real);
begin
z_Uniform2dv_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2dv(location: Int32; count: Int32; var value: real);
begin
z_Uniform2dv_ovr_0(location, count, value);
end;
public 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);
begin
z_Uniform2dv_ovr_2(location, count, value);
end;
// added in gl2.0
public z_Uniform2f_adr := GetFuncAdr('glUniform2f');
public 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);
begin
z_Uniform2f_ovr_0(location, v0, v1);
end;
// added in gl2.0
public z_Uniform2fv_adr := GetFuncAdr('glUniform2fv');
public z_Uniform2fv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: single)>(z_Uniform2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2fv(location: Int32; count: Int32; value: array of single);
begin
z_Uniform2fv_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2fv(location: Int32; count: Int32; var value: single);
begin
z_Uniform2fv_ovr_0(location, count, value);
end;
public 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);
begin
z_Uniform2fv_ovr_2(location, count, value);
end;
// added in gl2.0
public z_Uniform2i_adr := GetFuncAdr('glUniform2i');
public 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);
begin
z_Uniform2i_ovr_0(location, v0, v1);
end;
// added in gl2.0
public z_Uniform2iv_adr := GetFuncAdr('glUniform2iv');
public z_Uniform2iv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Int32)>(z_Uniform2iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2iv(location: Int32; count: Int32; value: array of Int32);
begin
z_Uniform2iv_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2iv(location: Int32; count: Int32; var value: Int32);
begin
z_Uniform2iv_ovr_0(location, count, value);
end;
public 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);
begin
z_Uniform2iv_ovr_2(location, count, value);
end;
// added in gl3.0
public z_Uniform2ui_adr := GetFuncAdr('glUniform2ui');
public 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);
begin
z_Uniform2ui_ovr_0(location, v0, v1);
end;
// added in gl3.0
public z_Uniform2uiv_adr := GetFuncAdr('glUniform2uiv');
public z_Uniform2uiv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: UInt32)>(z_Uniform2uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2uiv(location: Int32; count: Int32; value: array of UInt32);
begin
z_Uniform2uiv_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2uiv(location: Int32; count: Int32; var value: UInt32);
begin
z_Uniform2uiv_ovr_0(location, count, value);
end;
public 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);
begin
z_Uniform2uiv_ovr_2(location, count, value);
end;
// added in gl4.0
public z_Uniform3d_adr := GetFuncAdr('glUniform3d');
public 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);
begin
z_Uniform3d_ovr_0(location, x, y, z);
end;
// added in gl4.0
public z_Uniform3dv_adr := GetFuncAdr('glUniform3dv');
public z_Uniform3dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: real)>(z_Uniform3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3dv(location: Int32; count: Int32; value: array of real);
begin
z_Uniform3dv_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3dv(location: Int32; count: Int32; var value: real);
begin
z_Uniform3dv_ovr_0(location, count, value);
end;
public 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);
begin
z_Uniform3dv_ovr_2(location, count, value);
end;
// added in gl2.0
public z_Uniform3f_adr := GetFuncAdr('glUniform3f');
public 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);
begin
z_Uniform3f_ovr_0(location, v0, v1, v2);
end;
// added in gl2.0
public z_Uniform3fv_adr := GetFuncAdr('glUniform3fv');
public z_Uniform3fv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: single)>(z_Uniform3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3fv(location: Int32; count: Int32; value: array of single);
begin
z_Uniform3fv_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3fv(location: Int32; count: Int32; var value: single);
begin
z_Uniform3fv_ovr_0(location, count, value);
end;
public 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);
begin
z_Uniform3fv_ovr_2(location, count, value);
end;
// added in gl2.0
public z_Uniform3i_adr := GetFuncAdr('glUniform3i');
public 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);
begin
z_Uniform3i_ovr_0(location, v0, v1, v2);
end;
// added in gl2.0
public z_Uniform3iv_adr := GetFuncAdr('glUniform3iv');
public z_Uniform3iv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Int32)>(z_Uniform3iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3iv(location: Int32; count: Int32; value: array of Int32);
begin
z_Uniform3iv_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3iv(location: Int32; count: Int32; var value: Int32);
begin
z_Uniform3iv_ovr_0(location, count, value);
end;
public 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);
begin
z_Uniform3iv_ovr_2(location, count, value);
end;
// added in gl3.0
public z_Uniform3ui_adr := GetFuncAdr('glUniform3ui');
public 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);
begin
z_Uniform3ui_ovr_0(location, v0, v1, v2);
end;
// added in gl3.0
public z_Uniform3uiv_adr := GetFuncAdr('glUniform3uiv');
public z_Uniform3uiv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: UInt32)>(z_Uniform3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3uiv(location: Int32; count: Int32; value: array of UInt32);
begin
z_Uniform3uiv_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3uiv(location: Int32; count: Int32; var value: UInt32);
begin
z_Uniform3uiv_ovr_0(location, count, value);
end;
public 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);
begin
z_Uniform3uiv_ovr_2(location, count, value);
end;
// added in gl4.0
public z_Uniform4d_adr := GetFuncAdr('glUniform4d');
public 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);
begin
z_Uniform4d_ovr_0(location, x, y, z, w);
end;
// added in gl4.0
public z_Uniform4dv_adr := GetFuncAdr('glUniform4dv');
public z_Uniform4dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: real)>(z_Uniform4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4dv(location: Int32; count: Int32; value: array of real);
begin
z_Uniform4dv_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4dv(location: Int32; count: Int32; var value: real);
begin
z_Uniform4dv_ovr_0(location, count, value);
end;
public 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);
begin
z_Uniform4dv_ovr_2(location, count, value);
end;
// added in gl2.0
public z_Uniform4f_adr := GetFuncAdr('glUniform4f');
public 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);
begin
z_Uniform4f_ovr_0(location, v0, v1, v2, v3);
end;
// added in gl2.0
public z_Uniform4fv_adr := GetFuncAdr('glUniform4fv');
public z_Uniform4fv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: single)>(z_Uniform4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4fv(location: Int32; count: Int32; value: array of single);
begin
z_Uniform4fv_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4fv(location: Int32; count: Int32; var value: single);
begin
z_Uniform4fv_ovr_0(location, count, value);
end;
public 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);
begin
z_Uniform4fv_ovr_2(location, count, value);
end;
// added in gl2.0
public z_Uniform4i_adr := GetFuncAdr('glUniform4i');
public 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);
begin
z_Uniform4i_ovr_0(location, v0, v1, v2, v3);
end;
// added in gl2.0
public z_Uniform4iv_adr := GetFuncAdr('glUniform4iv');
public z_Uniform4iv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Int32)>(z_Uniform4iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4iv(location: Int32; count: Int32; value: array of Int32);
begin
z_Uniform4iv_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4iv(location: Int32; count: Int32; var value: Int32);
begin
z_Uniform4iv_ovr_0(location, count, value);
end;
public 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);
begin
z_Uniform4iv_ovr_2(location, count, value);
end;
// added in gl3.0
public z_Uniform4ui_adr := GetFuncAdr('glUniform4ui');
public 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);
begin
z_Uniform4ui_ovr_0(location, v0, v1, v2, v3);
end;
// added in gl3.0
public z_Uniform4uiv_adr := GetFuncAdr('glUniform4uiv');
public z_Uniform4uiv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: UInt32)>(z_Uniform4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4uiv(location: Int32; count: Int32; value: array of UInt32);
begin
z_Uniform4uiv_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4uiv(location: Int32; count: Int32; var value: UInt32);
begin
z_Uniform4uiv_ovr_0(location, count, value);
end;
public 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);
begin
z_Uniform4uiv_ovr_2(location, count, value);
end;
// added in gl3.1
public z_UniformBlockBinding_adr := GetFuncAdr('glUniformBlockBinding');
public 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);
begin
z_UniformBlockBinding_ovr_0(&program, uniformBlockIndex, uniformBlockBinding);
end;
// added in gl4.0
public z_UniformMatrix2dv_adr := GetFuncAdr('glUniformMatrix2dv');
public z_UniformMatrix2dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: real)>(z_UniformMatrix2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2dv(location: Int32; count: Int32; transpose: boolean; value: array of real);
begin
z_UniformMatrix2dv_ovr_0(location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2dv(location: Int32; count: Int32; transpose: boolean; var value: real);
begin
z_UniformMatrix2dv_ovr_0(location, count, transpose, value);
end;
public 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);
begin
z_UniformMatrix2dv_ovr_2(location, count, transpose, value);
end;
// added in gl2.0
public z_UniformMatrix2fv_adr := GetFuncAdr('glUniformMatrix2fv');
public z_UniformMatrix2fv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: single)>(z_UniformMatrix2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2fv(location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_UniformMatrix2fv_ovr_0(location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2fv(location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_UniformMatrix2fv_ovr_0(location, count, transpose, value);
end;
public 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);
begin
z_UniformMatrix2fv_ovr_2(location, count, transpose, value);
end;
// added in gl4.0
public z_UniformMatrix2x3dv_adr := GetFuncAdr('glUniformMatrix2x3dv');
public z_UniformMatrix2x3dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: real)>(z_UniformMatrix2x3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2x3dv(location: Int32; count: Int32; transpose: boolean; value: array of real);
begin
z_UniformMatrix2x3dv_ovr_0(location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2x3dv(location: Int32; count: Int32; transpose: boolean; var value: real);
begin
z_UniformMatrix2x3dv_ovr_0(location, count, transpose, value);
end;
public 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);
begin
z_UniformMatrix2x3dv_ovr_2(location, count, transpose, value);
end;
// added in gl2.1
public z_UniformMatrix2x3fv_adr := GetFuncAdr('glUniformMatrix2x3fv');
public z_UniformMatrix2x3fv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: single)>(z_UniformMatrix2x3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2x3fv(location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_UniformMatrix2x3fv_ovr_0(location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2x3fv(location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_UniformMatrix2x3fv_ovr_0(location, count, transpose, value);
end;
public 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);
begin
z_UniformMatrix2x3fv_ovr_2(location, count, transpose, value);
end;
// added in gl4.0
public z_UniformMatrix2x4dv_adr := GetFuncAdr('glUniformMatrix2x4dv');
public z_UniformMatrix2x4dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: real)>(z_UniformMatrix2x4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2x4dv(location: Int32; count: Int32; transpose: boolean; value: array of real);
begin
z_UniformMatrix2x4dv_ovr_0(location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2x4dv(location: Int32; count: Int32; transpose: boolean; var value: real);
begin
z_UniformMatrix2x4dv_ovr_0(location, count, transpose, value);
end;
public 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);
begin
z_UniformMatrix2x4dv_ovr_2(location, count, transpose, value);
end;
// added in gl2.1
public z_UniformMatrix2x4fv_adr := GetFuncAdr('glUniformMatrix2x4fv');
public z_UniformMatrix2x4fv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: single)>(z_UniformMatrix2x4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2x4fv(location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_UniformMatrix2x4fv_ovr_0(location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2x4fv(location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_UniformMatrix2x4fv_ovr_0(location, count, transpose, value);
end;
public 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);
begin
z_UniformMatrix2x4fv_ovr_2(location, count, transpose, value);
end;
// added in gl4.0
public z_UniformMatrix3dv_adr := GetFuncAdr('glUniformMatrix3dv');
public z_UniformMatrix3dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: real)>(z_UniformMatrix3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3dv(location: Int32; count: Int32; transpose: boolean; value: array of real);
begin
z_UniformMatrix3dv_ovr_0(location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3dv(location: Int32; count: Int32; transpose: boolean; var value: real);
begin
z_UniformMatrix3dv_ovr_0(location, count, transpose, value);
end;
public 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);
begin
z_UniformMatrix3dv_ovr_2(location, count, transpose, value);
end;
// added in gl2.0
public z_UniformMatrix3fv_adr := GetFuncAdr('glUniformMatrix3fv');
public z_UniformMatrix3fv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: single)>(z_UniformMatrix3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3fv(location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_UniformMatrix3fv_ovr_0(location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3fv(location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_UniformMatrix3fv_ovr_0(location, count, transpose, value);
end;
public 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);
begin
z_UniformMatrix3fv_ovr_2(location, count, transpose, value);
end;
// added in gl4.0
public z_UniformMatrix3x2dv_adr := GetFuncAdr('glUniformMatrix3x2dv');
public z_UniformMatrix3x2dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: real)>(z_UniformMatrix3x2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3x2dv(location: Int32; count: Int32; transpose: boolean; value: array of real);
begin
z_UniformMatrix3x2dv_ovr_0(location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3x2dv(location: Int32; count: Int32; transpose: boolean; var value: real);
begin
z_UniformMatrix3x2dv_ovr_0(location, count, transpose, value);
end;
public 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);
begin
z_UniformMatrix3x2dv_ovr_2(location, count, transpose, value);
end;
// added in gl2.1
public z_UniformMatrix3x2fv_adr := GetFuncAdr('glUniformMatrix3x2fv');
public z_UniformMatrix3x2fv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: single)>(z_UniformMatrix3x2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3x2fv(location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_UniformMatrix3x2fv_ovr_0(location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3x2fv(location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_UniformMatrix3x2fv_ovr_0(location, count, transpose, value);
end;
public 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);
begin
z_UniformMatrix3x2fv_ovr_2(location, count, transpose, value);
end;
// added in gl4.0
public z_UniformMatrix3x4dv_adr := GetFuncAdr('glUniformMatrix3x4dv');
public z_UniformMatrix3x4dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: real)>(z_UniformMatrix3x4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3x4dv(location: Int32; count: Int32; transpose: boolean; value: array of real);
begin
z_UniformMatrix3x4dv_ovr_0(location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3x4dv(location: Int32; count: Int32; transpose: boolean; var value: real);
begin
z_UniformMatrix3x4dv_ovr_0(location, count, transpose, value);
end;
public 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);
begin
z_UniformMatrix3x4dv_ovr_2(location, count, transpose, value);
end;
// added in gl2.1
public z_UniformMatrix3x4fv_adr := GetFuncAdr('glUniformMatrix3x4fv');
public z_UniformMatrix3x4fv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: single)>(z_UniformMatrix3x4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3x4fv(location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_UniformMatrix3x4fv_ovr_0(location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3x4fv(location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_UniformMatrix3x4fv_ovr_0(location, count, transpose, value);
end;
public 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);
begin
z_UniformMatrix3x4fv_ovr_2(location, count, transpose, value);
end;
// added in gl4.0
public z_UniformMatrix4dv_adr := GetFuncAdr('glUniformMatrix4dv');
public z_UniformMatrix4dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: real)>(z_UniformMatrix4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4dv(location: Int32; count: Int32; transpose: boolean; value: array of real);
begin
z_UniformMatrix4dv_ovr_0(location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4dv(location: Int32; count: Int32; transpose: boolean; var value: real);
begin
z_UniformMatrix4dv_ovr_0(location, count, transpose, value);
end;
public 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);
begin
z_UniformMatrix4dv_ovr_2(location, count, transpose, value);
end;
// added in gl2.0
public z_UniformMatrix4fv_adr := GetFuncAdr('glUniformMatrix4fv');
public z_UniformMatrix4fv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: single)>(z_UniformMatrix4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4fv(location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_UniformMatrix4fv_ovr_0(location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4fv(location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_UniformMatrix4fv_ovr_0(location, count, transpose, value);
end;
public 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);
begin
z_UniformMatrix4fv_ovr_2(location, count, transpose, value);
end;
// added in gl4.0
public z_UniformMatrix4x2dv_adr := GetFuncAdr('glUniformMatrix4x2dv');
public z_UniformMatrix4x2dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: real)>(z_UniformMatrix4x2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4x2dv(location: Int32; count: Int32; transpose: boolean; value: array of real);
begin
z_UniformMatrix4x2dv_ovr_0(location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4x2dv(location: Int32; count: Int32; transpose: boolean; var value: real);
begin
z_UniformMatrix4x2dv_ovr_0(location, count, transpose, value);
end;
public 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);
begin
z_UniformMatrix4x2dv_ovr_2(location, count, transpose, value);
end;
// added in gl2.1
public z_UniformMatrix4x2fv_adr := GetFuncAdr('glUniformMatrix4x2fv');
public z_UniformMatrix4x2fv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: single)>(z_UniformMatrix4x2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4x2fv(location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_UniformMatrix4x2fv_ovr_0(location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4x2fv(location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_UniformMatrix4x2fv_ovr_0(location, count, transpose, value);
end;
public 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);
begin
z_UniformMatrix4x2fv_ovr_2(location, count, transpose, value);
end;
// added in gl4.0
public z_UniformMatrix4x3dv_adr := GetFuncAdr('glUniformMatrix4x3dv');
public z_UniformMatrix4x3dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: real)>(z_UniformMatrix4x3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4x3dv(location: Int32; count: Int32; transpose: boolean; value: array of real);
begin
z_UniformMatrix4x3dv_ovr_0(location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4x3dv(location: Int32; count: Int32; transpose: boolean; var value: real);
begin
z_UniformMatrix4x3dv_ovr_0(location, count, transpose, value);
end;
public 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);
begin
z_UniformMatrix4x3dv_ovr_2(location, count, transpose, value);
end;
// added in gl2.1
public z_UniformMatrix4x3fv_adr := GetFuncAdr('glUniformMatrix4x3fv');
public z_UniformMatrix4x3fv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: single)>(z_UniformMatrix4x3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4x3fv(location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_UniformMatrix4x3fv_ovr_0(location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4x3fv(location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_UniformMatrix4x3fv_ovr_0(location, count, transpose, value);
end;
public 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);
begin
z_UniformMatrix4x3fv_ovr_2(location, count, transpose, value);
end;
// added in gl4.0
public z_UniformSubroutinesuiv_adr := GetFuncAdr('glUniformSubroutinesuiv');
public z_UniformSubroutinesuiv_ovr_0 := GetFuncOrNil&<procedure(_shadertype: ShaderType; count: Int32; var indices: UInt32)>(z_UniformSubroutinesuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformSubroutinesuiv(_shadertype: ShaderType; count: Int32; indices: array of UInt32);
begin
z_UniformSubroutinesuiv_ovr_0(_shadertype, count, indices[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformSubroutinesuiv(_shadertype: ShaderType; count: Int32; var indices: UInt32);
begin
z_UniformSubroutinesuiv_ovr_0(_shadertype, count, indices);
end;
public 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);
begin
z_UniformSubroutinesuiv_ovr_2(_shadertype, count, indices);
end;
// added in gl1.5
public z_UnmapBuffer_adr := GetFuncAdr('glUnmapBuffer');
public z_UnmapBuffer_ovr_0 := GetFuncOrNil&<function(target: BufferTargetARB): boolean>(z_UnmapBuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function UnmapBuffer(target: BufferTargetARB): boolean;
begin
Result := z_UnmapBuffer_ovr_0(target);
end;
// added in gl4.5
public z_UnmapNamedBuffer_adr := GetFuncAdr('glUnmapNamedBuffer');
public z_UnmapNamedBuffer_ovr_0 := GetFuncOrNil&<function(buffer: BufferName): boolean>(z_UnmapNamedBuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function UnmapNamedBuffer(buffer: BufferName): boolean;
begin
Result := z_UnmapNamedBuffer_ovr_0(buffer);
end;
// added in gl2.0
public z_UseProgram_adr := GetFuncAdr('glUseProgram');
public z_UseProgram_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName)>(z_UseProgram_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UseProgram(&program: ProgramName);
begin
z_UseProgram_ovr_0(&program);
end;
// added in gl4.1
public z_UseProgramStages_adr := GetFuncAdr('glUseProgramStages');
public 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);
begin
z_UseProgramStages_ovr_0(pipeline, stages, &program);
end;
// added in gl2.0
public z_ValidateProgram_adr := GetFuncAdr('glValidateProgram');
public z_ValidateProgram_ovr_0 := GetFuncOrNil&<procedure(&program: ProgramName)>(z_ValidateProgram_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ValidateProgram(&program: ProgramName);
begin
z_ValidateProgram_ovr_0(&program);
end;
// added in gl4.1
public z_ValidateProgramPipeline_adr := GetFuncAdr('glValidateProgramPipeline');
public z_ValidateProgramPipeline_ovr_0 := GetFuncOrNil&<procedure(pipeline: ProgramPipelineName)>(z_ValidateProgramPipeline_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ValidateProgramPipeline(pipeline: ProgramPipelineName);
begin
z_ValidateProgramPipeline_ovr_0(pipeline);
end;
// added in gl4.5
public z_VertexArrayAttribBinding_adr := GetFuncAdr('glVertexArrayAttribBinding');
public 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);
begin
z_VertexArrayAttribBinding_ovr_0(vaobj, attribindex, bindingindex);
end;
// added in gl4.5
public z_VertexArrayAttribFormat_adr := GetFuncAdr('glVertexArrayAttribFormat');
public 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);
begin
z_VertexArrayAttribFormat_ovr_0(vaobj, attribindex, size, &type, normalized, relativeoffset);
end;
// added in gl4.5
public z_VertexArrayAttribIFormat_adr := GetFuncAdr('glVertexArrayAttribIFormat');
public 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);
begin
z_VertexArrayAttribIFormat_ovr_0(vaobj, attribindex, size, &type, relativeoffset);
end;
// added in gl4.5
public z_VertexArrayAttribLFormat_adr := GetFuncAdr('glVertexArrayAttribLFormat');
public 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);
begin
z_VertexArrayAttribLFormat_ovr_0(vaobj, attribindex, size, &type, relativeoffset);
end;
// added in gl4.5
public z_VertexArrayBindingDivisor_adr := GetFuncAdr('glVertexArrayBindingDivisor');
public 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);
begin
z_VertexArrayBindingDivisor_ovr_0(vaobj, bindingindex, divisor);
end;
// added in gl4.5
public z_VertexArrayElementBuffer_adr := GetFuncAdr('glVertexArrayElementBuffer');
public z_VertexArrayElementBuffer_ovr_0 := GetFuncOrNil&<procedure(vaobj: VertexArrayName; buffer: BufferName)>(z_VertexArrayElementBuffer_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayElementBuffer(vaobj: VertexArrayName; buffer: BufferName);
begin
z_VertexArrayElementBuffer_ovr_0(vaobj, buffer);
end;
// added in gl4.5
public z_VertexArrayVertexBuffer_adr := GetFuncAdr('glVertexArrayVertexBuffer');
public 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);
begin
z_VertexArrayVertexBuffer_ovr_0(vaobj, bindingindex, buffer, offset, stride);
end;
// added in gl4.5
public z_VertexArrayVertexBuffers_adr := GetFuncAdr('glVertexArrayVertexBuffers');
public z_VertexArrayVertexBuffers_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; 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; offsets: array of IntPtr; strides: array of Int32);
begin
z_VertexArrayVertexBuffers_ovr_0(vaobj, first, count, buffers[0], offsets[0], strides[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: array of UInt32; offsets: array of IntPtr; var strides: Int32);
begin
z_VertexArrayVertexBuffers_ovr_0(vaobj, first, count, buffers[0], offsets[0], strides);
end;
public z_VertexArrayVertexBuffers_ovr_2 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; var 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);
begin
z_VertexArrayVertexBuffers_ovr_2(vaobj, first, count, buffers[0], offsets[0], strides);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: array of UInt32; var offsets: IntPtr; strides: array of Int32);
begin
z_VertexArrayVertexBuffers_ovr_0(vaobj, first, count, buffers[0], offsets, strides[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: array of UInt32; var offsets: IntPtr; var strides: Int32);
begin
z_VertexArrayVertexBuffers_ovr_0(vaobj, first, count, buffers[0], offsets, strides);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: array of UInt32; var offsets: IntPtr; strides: IntPtr);
begin
z_VertexArrayVertexBuffers_ovr_2(vaobj, first, count, buffers[0], offsets, strides);
end;
public z_VertexArrayVertexBuffers_ovr_6 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; 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; strides: array of Int32);
begin
z_VertexArrayVertexBuffers_ovr_6(vaobj, first, count, buffers[0], offsets, strides[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: array of UInt32; offsets: pointer; var strides: Int32);
begin
z_VertexArrayVertexBuffers_ovr_6(vaobj, first, count, buffers[0], offsets, strides);
end;
public z_VertexArrayVertexBuffers_ovr_8 := GetFuncOrNil&<procedure(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; 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);
begin
z_VertexArrayVertexBuffers_ovr_8(vaobj, first, count, buffers[0], offsets, strides);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: array of IntPtr; strides: array of Int32);
begin
z_VertexArrayVertexBuffers_ovr_0(vaobj, first, count, buffers, offsets[0], strides[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: array of IntPtr; var strides: Int32);
begin
z_VertexArrayVertexBuffers_ovr_0(vaobj, first, count, buffers, offsets[0], strides);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: array of IntPtr; strides: IntPtr);
begin
z_VertexArrayVertexBuffers_ovr_2(vaobj, first, count, buffers, offsets[0], strides);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; strides: array of Int32);
begin
z_VertexArrayVertexBuffers_ovr_0(vaobj, first, count, buffers, offsets, strides[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; var strides: Int32);
begin
z_VertexArrayVertexBuffers_ovr_0(vaobj, first, count, buffers, offsets, strides);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; var offsets: IntPtr; strides: IntPtr);
begin
z_VertexArrayVertexBuffers_ovr_2(vaobj, first, count, buffers, offsets, strides);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; strides: array of Int32);
begin
z_VertexArrayVertexBuffers_ovr_6(vaobj, first, count, buffers, offsets, strides[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; var strides: Int32);
begin
z_VertexArrayVertexBuffers_ovr_6(vaobj, first, count, buffers, offsets, strides);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; var buffers: UInt32; offsets: pointer; strides: IntPtr);
begin
z_VertexArrayVertexBuffers_ovr_8(vaobj, first, count, buffers, offsets, strides);
end;
public z_VertexArrayVertexBuffers_ovr_18 := 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: IntPtr; offsets: array of IntPtr; strides: array of Int32);
begin
z_VertexArrayVertexBuffers_ovr_18(vaobj, first, count, buffers, offsets[0], strides[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; var strides: Int32);
begin
z_VertexArrayVertexBuffers_ovr_18(vaobj, first, count, buffers, offsets[0], strides);
end;
public z_VertexArrayVertexBuffers_ovr_20 := 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: IntPtr; offsets: array of IntPtr; strides: IntPtr);
begin
z_VertexArrayVertexBuffers_ovr_20(vaobj, first, count, buffers, offsets[0], strides);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: array of Int32);
begin
z_VertexArrayVertexBuffers_ovr_18(vaobj, first, count, buffers, offsets, strides[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var strides: Int32);
begin
z_VertexArrayVertexBuffers_ovr_18(vaobj, first, count, buffers, offsets, strides);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; strides: IntPtr);
begin
z_VertexArrayVertexBuffers_ovr_20(vaobj, first, count, buffers, offsets, strides);
end;
public z_VertexArrayVertexBuffers_ovr_24 := 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: IntPtr; offsets: pointer; strides: array of Int32);
begin
z_VertexArrayVertexBuffers_ovr_24(vaobj, first, count, buffers, offsets, strides[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBuffers(vaobj: UInt32; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var strides: Int32);
begin
z_VertexArrayVertexBuffers_ovr_24(vaobj, first, count, buffers, offsets, strides);
end;
public 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);
begin
z_VertexArrayVertexBuffers_ovr_26(vaobj, first, count, buffers, offsets, strides);
end;
// added in gl2.0
public z_VertexAttrib1d_adr := GetFuncAdr('glVertexAttrib1d');
public z_VertexAttrib1d_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: real)>(z_VertexAttrib1d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1d(index: UInt32; x: real);
begin
z_VertexAttrib1d_ovr_0(index, x);
end;
// added in gl2.0
public z_VertexAttrib1dv_adr := GetFuncAdr('glVertexAttrib1dv');
public z_VertexAttrib1dv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttrib1dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dv(index: UInt32; v: array of real);
begin
z_VertexAttrib1dv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dv(index: UInt32; var v: real);
begin
z_VertexAttrib1dv_ovr_0(index, v);
end;
public z_VertexAttrib1dv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib1dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dv(index: UInt32; v: IntPtr);
begin
z_VertexAttrib1dv_ovr_2(index, v);
end;
// added in gl2.0
public z_VertexAttrib1f_adr := GetFuncAdr('glVertexAttrib1f');
public z_VertexAttrib1f_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: single)>(z_VertexAttrib1f_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1f(index: UInt32; x: single);
begin
z_VertexAttrib1f_ovr_0(index, x);
end;
// added in gl2.0
public z_VertexAttrib1fv_adr := GetFuncAdr('glVertexAttrib1fv');
public z_VertexAttrib1fv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: single)>(z_VertexAttrib1fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fv(index: UInt32; v: array of single);
begin
z_VertexAttrib1fv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fv(index: UInt32; var v: single);
begin
z_VertexAttrib1fv_ovr_0(index, v);
end;
public z_VertexAttrib1fv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib1fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fv(index: UInt32; v: IntPtr);
begin
z_VertexAttrib1fv_ovr_2(index, v);
end;
// added in gl2.0
public z_VertexAttrib1s_adr := GetFuncAdr('glVertexAttrib1s');
public z_VertexAttrib1s_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Int16)>(z_VertexAttrib1s_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1s(index: UInt32; x: Int16);
begin
z_VertexAttrib1s_ovr_0(index, x);
end;
// added in gl2.0
public z_VertexAttrib1sv_adr := GetFuncAdr('glVertexAttrib1sv');
public z_VertexAttrib1sv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int16)>(z_VertexAttrib1sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1sv(index: UInt32; v: array of Int16);
begin
z_VertexAttrib1sv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1sv(index: UInt32; var v: Int16);
begin
z_VertexAttrib1sv_ovr_0(index, v);
end;
public z_VertexAttrib1sv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib1sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1sv(index: UInt32; v: IntPtr);
begin
z_VertexAttrib1sv_ovr_2(index, v);
end;
// added in gl2.0
public z_VertexAttrib2d_adr := GetFuncAdr('glVertexAttrib2d');
public 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);
begin
z_VertexAttrib2d_ovr_0(index, x, y);
end;
// added in gl2.0
public z_VertexAttrib2dv_adr := GetFuncAdr('glVertexAttrib2dv');
public z_VertexAttrib2dv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttrib2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dv(index: UInt32; v: array of real);
begin
z_VertexAttrib2dv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dv(index: UInt32; var v: real);
begin
z_VertexAttrib2dv_ovr_0(index, v);
end;
public z_VertexAttrib2dv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dv(index: UInt32; v: IntPtr);
begin
z_VertexAttrib2dv_ovr_2(index, v);
end;
// added in gl2.0
public z_VertexAttrib2f_adr := GetFuncAdr('glVertexAttrib2f');
public 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);
begin
z_VertexAttrib2f_ovr_0(index, x, y);
end;
// added in gl2.0
public z_VertexAttrib2fv_adr := GetFuncAdr('glVertexAttrib2fv');
public z_VertexAttrib2fv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: single)>(z_VertexAttrib2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fv(index: UInt32; v: array of single);
begin
z_VertexAttrib2fv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fv(index: UInt32; var v: single);
begin
z_VertexAttrib2fv_ovr_0(index, v);
end;
public z_VertexAttrib2fv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fv(index: UInt32; v: IntPtr);
begin
z_VertexAttrib2fv_ovr_2(index, v);
end;
// added in gl2.0
public z_VertexAttrib2s_adr := GetFuncAdr('glVertexAttrib2s');
public 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);
begin
z_VertexAttrib2s_ovr_0(index, x, y);
end;
// added in gl2.0
public z_VertexAttrib2sv_adr := GetFuncAdr('glVertexAttrib2sv');
public z_VertexAttrib2sv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int16)>(z_VertexAttrib2sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2sv(index: UInt32; v: array of Int16);
begin
z_VertexAttrib2sv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2sv(index: UInt32; var v: Int16);
begin
z_VertexAttrib2sv_ovr_0(index, v);
end;
public z_VertexAttrib2sv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib2sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2sv(index: UInt32; v: IntPtr);
begin
z_VertexAttrib2sv_ovr_2(index, v);
end;
// added in gl2.0
public z_VertexAttrib3d_adr := GetFuncAdr('glVertexAttrib3d');
public 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);
begin
z_VertexAttrib3d_ovr_0(index, x, y, z);
end;
// added in gl2.0
public z_VertexAttrib3dv_adr := GetFuncAdr('glVertexAttrib3dv');
public z_VertexAttrib3dv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttrib3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dv(index: UInt32; v: array of real);
begin
z_VertexAttrib3dv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dv(index: UInt32; var v: real);
begin
z_VertexAttrib3dv_ovr_0(index, v);
end;
public z_VertexAttrib3dv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dv(index: UInt32; v: IntPtr);
begin
z_VertexAttrib3dv_ovr_2(index, v);
end;
// added in gl2.0
public z_VertexAttrib3f_adr := GetFuncAdr('glVertexAttrib3f');
public 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);
begin
z_VertexAttrib3f_ovr_0(index, x, y, z);
end;
// added in gl2.0
public z_VertexAttrib3fv_adr := GetFuncAdr('glVertexAttrib3fv');
public z_VertexAttrib3fv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: single)>(z_VertexAttrib3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fv(index: UInt32; v: array of single);
begin
z_VertexAttrib3fv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fv(index: UInt32; var v: single);
begin
z_VertexAttrib3fv_ovr_0(index, v);
end;
public z_VertexAttrib3fv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fv(index: UInt32; v: IntPtr);
begin
z_VertexAttrib3fv_ovr_2(index, v);
end;
// added in gl2.0
public z_VertexAttrib3s_adr := GetFuncAdr('glVertexAttrib3s');
public 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);
begin
z_VertexAttrib3s_ovr_0(index, x, y, z);
end;
// added in gl2.0
public z_VertexAttrib3sv_adr := GetFuncAdr('glVertexAttrib3sv');
public z_VertexAttrib3sv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int16)>(z_VertexAttrib3sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3sv(index: UInt32; v: array of Int16);
begin
z_VertexAttrib3sv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3sv(index: UInt32; var v: Int16);
begin
z_VertexAttrib3sv_ovr_0(index, v);
end;
public z_VertexAttrib3sv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib3sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3sv(index: UInt32; v: IntPtr);
begin
z_VertexAttrib3sv_ovr_2(index, v);
end;
// added in gl2.0
public z_VertexAttrib4bv_adr := GetFuncAdr('glVertexAttrib4bv');
public z_VertexAttrib4bv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: SByte)>(z_VertexAttrib4bv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4bv(index: UInt32; v: array of SByte);
begin
z_VertexAttrib4bv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4bv(index: UInt32; var v: SByte);
begin
z_VertexAttrib4bv_ovr_0(index, v);
end;
public z_VertexAttrib4bv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4bv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4bv(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4bv_ovr_2(index, v);
end;
// added in gl2.0
public z_VertexAttrib4d_adr := GetFuncAdr('glVertexAttrib4d');
public 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);
begin
z_VertexAttrib4d_ovr_0(index, x, y, z, w);
end;
// added in gl2.0
public z_VertexAttrib4dv_adr := GetFuncAdr('glVertexAttrib4dv');
public z_VertexAttrib4dv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttrib4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dv(index: UInt32; v: array of real);
begin
z_VertexAttrib4dv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dv(index: UInt32; var v: real);
begin
z_VertexAttrib4dv_ovr_0(index, v);
end;
public z_VertexAttrib4dv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dv(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4dv_ovr_2(index, v);
end;
// added in gl2.0
public z_VertexAttrib4f_adr := GetFuncAdr('glVertexAttrib4f');
public 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);
begin
z_VertexAttrib4f_ovr_0(index, x, y, z, w);
end;
// added in gl2.0
public z_VertexAttrib4fv_adr := GetFuncAdr('glVertexAttrib4fv');
public z_VertexAttrib4fv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: single)>(z_VertexAttrib4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fv(index: UInt32; v: array of single);
begin
z_VertexAttrib4fv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fv(index: UInt32; var v: single);
begin
z_VertexAttrib4fv_ovr_0(index, v);
end;
public z_VertexAttrib4fv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fv(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4fv_ovr_2(index, v);
end;
// added in gl2.0
public z_VertexAttrib4iv_adr := GetFuncAdr('glVertexAttrib4iv');
public z_VertexAttrib4iv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int32)>(z_VertexAttrib4iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4iv(index: UInt32; v: array of Int32);
begin
z_VertexAttrib4iv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4iv(index: UInt32; var v: Int32);
begin
z_VertexAttrib4iv_ovr_0(index, v);
end;
public z_VertexAttrib4iv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4iv(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4iv_ovr_2(index, v);
end;
// added in gl2.0
public z_VertexAttrib4Nbv_adr := GetFuncAdr('glVertexAttrib4Nbv');
public z_VertexAttrib4Nbv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: SByte)>(z_VertexAttrib4Nbv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nbv(index: UInt32; v: array of SByte);
begin
z_VertexAttrib4Nbv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nbv(index: UInt32; var v: SByte);
begin
z_VertexAttrib4Nbv_ovr_0(index, v);
end;
public z_VertexAttrib4Nbv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4Nbv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nbv(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4Nbv_ovr_2(index, v);
end;
// added in gl2.0
public z_VertexAttrib4Niv_adr := GetFuncAdr('glVertexAttrib4Niv');
public z_VertexAttrib4Niv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int32)>(z_VertexAttrib4Niv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Niv(index: UInt32; v: array of Int32);
begin
z_VertexAttrib4Niv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Niv(index: UInt32; var v: Int32);
begin
z_VertexAttrib4Niv_ovr_0(index, v);
end;
public z_VertexAttrib4Niv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4Niv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Niv(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4Niv_ovr_2(index, v);
end;
// added in gl2.0
public z_VertexAttrib4Nsv_adr := GetFuncAdr('glVertexAttrib4Nsv');
public z_VertexAttrib4Nsv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int16)>(z_VertexAttrib4Nsv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nsv(index: UInt32; v: array of Int16);
begin
z_VertexAttrib4Nsv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nsv(index: UInt32; var v: Int16);
begin
z_VertexAttrib4Nsv_ovr_0(index, v);
end;
public z_VertexAttrib4Nsv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4Nsv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nsv(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4Nsv_ovr_2(index, v);
end;
// added in gl2.0
public z_VertexAttrib4Nub_adr := GetFuncAdr('glVertexAttrib4Nub');
public 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);
begin
z_VertexAttrib4Nub_ovr_0(index, x, y, z, w);
end;
// added in gl2.0
public z_VertexAttrib4Nubv_adr := GetFuncAdr('glVertexAttrib4Nubv');
public z_VertexAttrib4Nubv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Byte)>(z_VertexAttrib4Nubv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nubv(index: UInt32; v: array of Byte);
begin
z_VertexAttrib4Nubv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nubv(index: UInt32; var v: Byte);
begin
z_VertexAttrib4Nubv_ovr_0(index, v);
end;
public z_VertexAttrib4Nubv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4Nubv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nubv(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4Nubv_ovr_2(index, v);
end;
// added in gl2.0
public z_VertexAttrib4Nuiv_adr := GetFuncAdr('glVertexAttrib4Nuiv');
public z_VertexAttrib4Nuiv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt32)>(z_VertexAttrib4Nuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nuiv(index: UInt32; v: array of UInt32);
begin
z_VertexAttrib4Nuiv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nuiv(index: UInt32; var v: UInt32);
begin
z_VertexAttrib4Nuiv_ovr_0(index, v);
end;
public z_VertexAttrib4Nuiv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4Nuiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nuiv(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4Nuiv_ovr_2(index, v);
end;
// added in gl2.0
public z_VertexAttrib4Nusv_adr := GetFuncAdr('glVertexAttrib4Nusv');
public z_VertexAttrib4Nusv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt16)>(z_VertexAttrib4Nusv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nusv(index: UInt32; v: array of UInt16);
begin
z_VertexAttrib4Nusv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nusv(index: UInt32; var v: UInt16);
begin
z_VertexAttrib4Nusv_ovr_0(index, v);
end;
public z_VertexAttrib4Nusv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4Nusv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4Nusv(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4Nusv_ovr_2(index, v);
end;
// added in gl2.0
public z_VertexAttrib4s_adr := GetFuncAdr('glVertexAttrib4s');
public 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);
begin
z_VertexAttrib4s_ovr_0(index, x, y, z, w);
end;
// added in gl2.0
public z_VertexAttrib4sv_adr := GetFuncAdr('glVertexAttrib4sv');
public z_VertexAttrib4sv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int16)>(z_VertexAttrib4sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4sv(index: UInt32; v: array of Int16);
begin
z_VertexAttrib4sv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4sv(index: UInt32; var v: Int16);
begin
z_VertexAttrib4sv_ovr_0(index, v);
end;
public z_VertexAttrib4sv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4sv(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4sv_ovr_2(index, v);
end;
// added in gl2.0
public z_VertexAttrib4ubv_adr := GetFuncAdr('glVertexAttrib4ubv');
public z_VertexAttrib4ubv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Byte)>(z_VertexAttrib4ubv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ubv(index: UInt32; v: array of Byte);
begin
z_VertexAttrib4ubv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ubv(index: UInt32; var v: Byte);
begin
z_VertexAttrib4ubv_ovr_0(index, v);
end;
public z_VertexAttrib4ubv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4ubv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ubv(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4ubv_ovr_2(index, v);
end;
// added in gl2.0
public z_VertexAttrib4uiv_adr := GetFuncAdr('glVertexAttrib4uiv');
public z_VertexAttrib4uiv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt32)>(z_VertexAttrib4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4uiv(index: UInt32; v: array of UInt32);
begin
z_VertexAttrib4uiv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4uiv(index: UInt32; var v: UInt32);
begin
z_VertexAttrib4uiv_ovr_0(index, v);
end;
public z_VertexAttrib4uiv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4uiv(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4uiv_ovr_2(index, v);
end;
// added in gl2.0
public z_VertexAttrib4usv_adr := GetFuncAdr('glVertexAttrib4usv');
public z_VertexAttrib4usv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt16)>(z_VertexAttrib4usv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4usv(index: UInt32; v: array of UInt16);
begin
z_VertexAttrib4usv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4usv(index: UInt32; var v: UInt16);
begin
z_VertexAttrib4usv_ovr_0(index, v);
end;
public z_VertexAttrib4usv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4usv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4usv(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4usv_ovr_2(index, v);
end;
// added in gl4.3
public z_VertexAttribBinding_adr := GetFuncAdr('glVertexAttribBinding');
public z_VertexAttribBinding_ovr_0 := GetFuncOrNil&<procedure(attribindex: UInt32; bindingindex: UInt32)>(z_VertexAttribBinding_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribBinding(attribindex: UInt32; bindingindex: UInt32);
begin
z_VertexAttribBinding_ovr_0(attribindex, bindingindex);
end;
// added in gl3.3
public z_VertexAttribDivisor_adr := GetFuncAdr('glVertexAttribDivisor');
public z_VertexAttribDivisor_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; divisor: UInt32)>(z_VertexAttribDivisor_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribDivisor(index: UInt32; divisor: UInt32);
begin
z_VertexAttribDivisor_ovr_0(index, divisor);
end;
// added in gl4.3
public z_VertexAttribFormat_adr := GetFuncAdr('glVertexAttribFormat');
public 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);
begin
z_VertexAttribFormat_ovr_0(attribindex, size, &type, normalized, relativeoffset);
end;
// added in gl3.0
public z_VertexAttribI1i_adr := GetFuncAdr('glVertexAttribI1i');
public z_VertexAttribI1i_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Int32)>(z_VertexAttribI1i_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI1i(index: UInt32; x: Int32);
begin
z_VertexAttribI1i_ovr_0(index, x);
end;
// added in gl3.0
public z_VertexAttribI1iv_adr := GetFuncAdr('glVertexAttribI1iv');
public z_VertexAttribI1iv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int32)>(z_VertexAttribI1iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI1iv(index: UInt32; v: array of Int32);
begin
z_VertexAttribI1iv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI1iv(index: UInt32; var v: Int32);
begin
z_VertexAttribI1iv_ovr_0(index, v);
end;
public z_VertexAttribI1iv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI1iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI1iv(index: UInt32; v: IntPtr);
begin
z_VertexAttribI1iv_ovr_2(index, v);
end;
// added in gl3.0
public z_VertexAttribI1ui_adr := GetFuncAdr('glVertexAttribI1ui');
public z_VertexAttribI1ui_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: UInt32)>(z_VertexAttribI1ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI1ui(index: UInt32; x: UInt32);
begin
z_VertexAttribI1ui_ovr_0(index, x);
end;
// added in gl3.0
public z_VertexAttribI1uiv_adr := GetFuncAdr('glVertexAttribI1uiv');
public z_VertexAttribI1uiv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt32)>(z_VertexAttribI1uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI1uiv(index: UInt32; v: array of UInt32);
begin
z_VertexAttribI1uiv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI1uiv(index: UInt32; var v: UInt32);
begin
z_VertexAttribI1uiv_ovr_0(index, v);
end;
public z_VertexAttribI1uiv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI1uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI1uiv(index: UInt32; v: IntPtr);
begin
z_VertexAttribI1uiv_ovr_2(index, v);
end;
// added in gl3.0
public z_VertexAttribI2i_adr := GetFuncAdr('glVertexAttribI2i');
public 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);
begin
z_VertexAttribI2i_ovr_0(index, x, y);
end;
// added in gl3.0
public z_VertexAttribI2iv_adr := GetFuncAdr('glVertexAttribI2iv');
public z_VertexAttribI2iv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int32)>(z_VertexAttribI2iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI2iv(index: UInt32; v: array of Int32);
begin
z_VertexAttribI2iv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI2iv(index: UInt32; var v: Int32);
begin
z_VertexAttribI2iv_ovr_0(index, v);
end;
public z_VertexAttribI2iv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI2iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI2iv(index: UInt32; v: IntPtr);
begin
z_VertexAttribI2iv_ovr_2(index, v);
end;
// added in gl3.0
public z_VertexAttribI2ui_adr := GetFuncAdr('glVertexAttribI2ui');
public 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);
begin
z_VertexAttribI2ui_ovr_0(index, x, y);
end;
// added in gl3.0
public z_VertexAttribI2uiv_adr := GetFuncAdr('glVertexAttribI2uiv');
public z_VertexAttribI2uiv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt32)>(z_VertexAttribI2uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI2uiv(index: UInt32; v: array of UInt32);
begin
z_VertexAttribI2uiv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI2uiv(index: UInt32; var v: UInt32);
begin
z_VertexAttribI2uiv_ovr_0(index, v);
end;
public z_VertexAttribI2uiv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI2uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI2uiv(index: UInt32; v: IntPtr);
begin
z_VertexAttribI2uiv_ovr_2(index, v);
end;
// added in gl3.0
public z_VertexAttribI3i_adr := GetFuncAdr('glVertexAttribI3i');
public 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);
begin
z_VertexAttribI3i_ovr_0(index, x, y, z);
end;
// added in gl3.0
public z_VertexAttribI3iv_adr := GetFuncAdr('glVertexAttribI3iv');
public z_VertexAttribI3iv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int32)>(z_VertexAttribI3iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI3iv(index: UInt32; v: array of Int32);
begin
z_VertexAttribI3iv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI3iv(index: UInt32; var v: Int32);
begin
z_VertexAttribI3iv_ovr_0(index, v);
end;
public z_VertexAttribI3iv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI3iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI3iv(index: UInt32; v: IntPtr);
begin
z_VertexAttribI3iv_ovr_2(index, v);
end;
// added in gl3.0
public z_VertexAttribI3ui_adr := GetFuncAdr('glVertexAttribI3ui');
public 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);
begin
z_VertexAttribI3ui_ovr_0(index, x, y, z);
end;
// added in gl3.0
public z_VertexAttribI3uiv_adr := GetFuncAdr('glVertexAttribI3uiv');
public z_VertexAttribI3uiv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt32)>(z_VertexAttribI3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI3uiv(index: UInt32; v: array of UInt32);
begin
z_VertexAttribI3uiv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI3uiv(index: UInt32; var v: UInt32);
begin
z_VertexAttribI3uiv_ovr_0(index, v);
end;
public z_VertexAttribI3uiv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI3uiv(index: UInt32; v: IntPtr);
begin
z_VertexAttribI3uiv_ovr_2(index, v);
end;
// added in gl3.0
public z_VertexAttribI4bv_adr := GetFuncAdr('glVertexAttribI4bv');
public z_VertexAttribI4bv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: SByte)>(z_VertexAttribI4bv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4bv(index: UInt32; v: array of SByte);
begin
z_VertexAttribI4bv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4bv(index: UInt32; var v: SByte);
begin
z_VertexAttribI4bv_ovr_0(index, v);
end;
public z_VertexAttribI4bv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI4bv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4bv(index: UInt32; v: IntPtr);
begin
z_VertexAttribI4bv_ovr_2(index, v);
end;
// added in gl3.0
public z_VertexAttribI4i_adr := GetFuncAdr('glVertexAttribI4i');
public 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);
begin
z_VertexAttribI4i_ovr_0(index, x, y, z, w);
end;
// added in gl3.0
public z_VertexAttribI4iv_adr := GetFuncAdr('glVertexAttribI4iv');
public z_VertexAttribI4iv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int32)>(z_VertexAttribI4iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4iv(index: UInt32; v: array of Int32);
begin
z_VertexAttribI4iv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4iv(index: UInt32; var v: Int32);
begin
z_VertexAttribI4iv_ovr_0(index, v);
end;
public z_VertexAttribI4iv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI4iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4iv(index: UInt32; v: IntPtr);
begin
z_VertexAttribI4iv_ovr_2(index, v);
end;
// added in gl3.0
public z_VertexAttribI4sv_adr := GetFuncAdr('glVertexAttribI4sv');
public z_VertexAttribI4sv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int16)>(z_VertexAttribI4sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4sv(index: UInt32; v: array of Int16);
begin
z_VertexAttribI4sv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4sv(index: UInt32; var v: Int16);
begin
z_VertexAttribI4sv_ovr_0(index, v);
end;
public z_VertexAttribI4sv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI4sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4sv(index: UInt32; v: IntPtr);
begin
z_VertexAttribI4sv_ovr_2(index, v);
end;
// added in gl3.0
public z_VertexAttribI4ubv_adr := GetFuncAdr('glVertexAttribI4ubv');
public z_VertexAttribI4ubv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Byte)>(z_VertexAttribI4ubv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4ubv(index: UInt32; v: array of Byte);
begin
z_VertexAttribI4ubv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4ubv(index: UInt32; var v: Byte);
begin
z_VertexAttribI4ubv_ovr_0(index, v);
end;
public z_VertexAttribI4ubv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI4ubv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4ubv(index: UInt32; v: IntPtr);
begin
z_VertexAttribI4ubv_ovr_2(index, v);
end;
// added in gl3.0
public z_VertexAttribI4ui_adr := GetFuncAdr('glVertexAttribI4ui');
public 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);
begin
z_VertexAttribI4ui_ovr_0(index, x, y, z, w);
end;
// added in gl3.0
public z_VertexAttribI4uiv_adr := GetFuncAdr('glVertexAttribI4uiv');
public z_VertexAttribI4uiv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt32)>(z_VertexAttribI4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4uiv(index: UInt32; v: array of UInt32);
begin
z_VertexAttribI4uiv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4uiv(index: UInt32; var v: UInt32);
begin
z_VertexAttribI4uiv_ovr_0(index, v);
end;
public z_VertexAttribI4uiv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4uiv(index: UInt32; v: IntPtr);
begin
z_VertexAttribI4uiv_ovr_2(index, v);
end;
// added in gl3.0
public z_VertexAttribI4usv_adr := GetFuncAdr('glVertexAttribI4usv');
public z_VertexAttribI4usv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt16)>(z_VertexAttribI4usv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4usv(index: UInt32; v: array of UInt16);
begin
z_VertexAttribI4usv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4usv(index: UInt32; var v: UInt16);
begin
z_VertexAttribI4usv_ovr_0(index, v);
end;
public z_VertexAttribI4usv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribI4usv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribI4usv(index: UInt32; v: IntPtr);
begin
z_VertexAttribI4usv_ovr_2(index, v);
end;
// added in gl4.3
public z_VertexAttribIFormat_adr := GetFuncAdr('glVertexAttribIFormat');
public 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);
begin
z_VertexAttribIFormat_ovr_0(attribindex, size, &type, relativeoffset);
end;
// added in gl3.0
public z_VertexAttribIPointer_adr := GetFuncAdr('glVertexAttribIPointer');
public 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);
begin
z_VertexAttribIPointer_ovr_0(index, size, &type, stride, pointer);
end;
// added in gl4.1
public z_VertexAttribL1d_adr := GetFuncAdr('glVertexAttribL1d');
public z_VertexAttribL1d_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: real)>(z_VertexAttribL1d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1d(index: UInt32; x: real);
begin
z_VertexAttribL1d_ovr_0(index, x);
end;
// added in gl4.1
public z_VertexAttribL1dv_adr := GetFuncAdr('glVertexAttribL1dv');
public z_VertexAttribL1dv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttribL1dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1dv(index: UInt32; v: array of real);
begin
z_VertexAttribL1dv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1dv(index: UInt32; var v: real);
begin
z_VertexAttribL1dv_ovr_0(index, v);
end;
public z_VertexAttribL1dv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribL1dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1dv(index: UInt32; v: IntPtr);
begin
z_VertexAttribL1dv_ovr_2(index, v);
end;
// added in gl4.1
public z_VertexAttribL2d_adr := GetFuncAdr('glVertexAttribL2d');
public 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);
begin
z_VertexAttribL2d_ovr_0(index, x, y);
end;
// added in gl4.1
public z_VertexAttribL2dv_adr := GetFuncAdr('glVertexAttribL2dv');
public z_VertexAttribL2dv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttribL2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2dv(index: UInt32; v: array of real);
begin
z_VertexAttribL2dv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2dv(index: UInt32; var v: real);
begin
z_VertexAttribL2dv_ovr_0(index, v);
end;
public z_VertexAttribL2dv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribL2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2dv(index: UInt32; v: IntPtr);
begin
z_VertexAttribL2dv_ovr_2(index, v);
end;
// added in gl4.1
public z_VertexAttribL3d_adr := GetFuncAdr('glVertexAttribL3d');
public 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);
begin
z_VertexAttribL3d_ovr_0(index, x, y, z);
end;
// added in gl4.1
public z_VertexAttribL3dv_adr := GetFuncAdr('glVertexAttribL3dv');
public z_VertexAttribL3dv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttribL3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3dv(index: UInt32; v: array of real);
begin
z_VertexAttribL3dv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3dv(index: UInt32; var v: real);
begin
z_VertexAttribL3dv_ovr_0(index, v);
end;
public z_VertexAttribL3dv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribL3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3dv(index: UInt32; v: IntPtr);
begin
z_VertexAttribL3dv_ovr_2(index, v);
end;
// added in gl4.1
public z_VertexAttribL4d_adr := GetFuncAdr('glVertexAttribL4d');
public 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);
begin
z_VertexAttribL4d_ovr_0(index, x, y, z, w);
end;
// added in gl4.1
public z_VertexAttribL4dv_adr := GetFuncAdr('glVertexAttribL4dv');
public z_VertexAttribL4dv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttribL4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4dv(index: UInt32; v: array of real);
begin
z_VertexAttribL4dv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4dv(index: UInt32; var v: real);
begin
z_VertexAttribL4dv_ovr_0(index, v);
end;
public z_VertexAttribL4dv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribL4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4dv(index: UInt32; v: IntPtr);
begin
z_VertexAttribL4dv_ovr_2(index, v);
end;
// added in gl4.3
public z_VertexAttribLFormat_adr := GetFuncAdr('glVertexAttribLFormat');
public 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);
begin
z_VertexAttribLFormat_ovr_0(attribindex, size, &type, relativeoffset);
end;
// added in gl4.1
public z_VertexAttribLPointer_adr := GetFuncAdr('glVertexAttribLPointer');
public 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);
begin
z_VertexAttribLPointer_ovr_0(index, size, &type, stride, pointer);
end;
// added in gl3.3
public z_VertexAttribP1ui_adr := GetFuncAdr('glVertexAttribP1ui');
public 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);
begin
z_VertexAttribP1ui_ovr_0(index, &type, normalized, value);
end;
// added in gl3.3
public z_VertexAttribP1uiv_adr := GetFuncAdr('glVertexAttribP1uiv');
public z_VertexAttribP1uiv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; var value: UInt32)>(z_VertexAttribP1uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP1uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: array of UInt32);
begin
z_VertexAttribP1uiv_ovr_0(index, &type, normalized, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP1uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; var value: UInt32);
begin
z_VertexAttribP1uiv_ovr_0(index, &type, normalized, value);
end;
public 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);
begin
z_VertexAttribP1uiv_ovr_2(index, &type, normalized, value);
end;
// added in gl3.3
public z_VertexAttribP2ui_adr := GetFuncAdr('glVertexAttribP2ui');
public 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);
begin
z_VertexAttribP2ui_ovr_0(index, &type, normalized, value);
end;
// added in gl3.3
public z_VertexAttribP2uiv_adr := GetFuncAdr('glVertexAttribP2uiv');
public z_VertexAttribP2uiv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; var value: UInt32)>(z_VertexAttribP2uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP2uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: array of UInt32);
begin
z_VertexAttribP2uiv_ovr_0(index, &type, normalized, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP2uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; var value: UInt32);
begin
z_VertexAttribP2uiv_ovr_0(index, &type, normalized, value);
end;
public 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);
begin
z_VertexAttribP2uiv_ovr_2(index, &type, normalized, value);
end;
// added in gl3.3
public z_VertexAttribP3ui_adr := GetFuncAdr('glVertexAttribP3ui');
public 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);
begin
z_VertexAttribP3ui_ovr_0(index, &type, normalized, value);
end;
// added in gl3.3
public z_VertexAttribP3uiv_adr := GetFuncAdr('glVertexAttribP3uiv');
public z_VertexAttribP3uiv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; var value: UInt32)>(z_VertexAttribP3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP3uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: array of UInt32);
begin
z_VertexAttribP3uiv_ovr_0(index, &type, normalized, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP3uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; var value: UInt32);
begin
z_VertexAttribP3uiv_ovr_0(index, &type, normalized, value);
end;
public 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);
begin
z_VertexAttribP3uiv_ovr_2(index, &type, normalized, value);
end;
// added in gl3.3
public z_VertexAttribP4ui_adr := GetFuncAdr('glVertexAttribP4ui');
public 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);
begin
z_VertexAttribP4ui_ovr_0(index, &type, normalized, value);
end;
// added in gl3.3
public z_VertexAttribP4uiv_adr := GetFuncAdr('glVertexAttribP4uiv');
public z_VertexAttribP4uiv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; var value: UInt32)>(z_VertexAttribP4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP4uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; value: array of UInt32);
begin
z_VertexAttribP4uiv_ovr_0(index, &type, normalized, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribP4uiv(index: UInt32; &type: VertexAttribPointerType; normalized: boolean; var value: UInt32);
begin
z_VertexAttribP4uiv_ovr_0(index, &type, normalized, value);
end;
public 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);
begin
z_VertexAttribP4uiv_ovr_2(index, &type, normalized, value);
end;
// added in gl2.0
public z_VertexAttribPointer_adr := GetFuncAdr('glVertexAttribPointer');
public 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);
begin
z_VertexAttribPointer_ovr_0(index, size, &type, normalized, stride, pointer);
end;
// added in gl4.3
public z_VertexBindingDivisor_adr := GetFuncAdr('glVertexBindingDivisor');
public z_VertexBindingDivisor_ovr_0 := GetFuncOrNil&<procedure(bindingindex: UInt32; divisor: UInt32)>(z_VertexBindingDivisor_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexBindingDivisor(bindingindex: UInt32; divisor: UInt32);
begin
z_VertexBindingDivisor_ovr_0(bindingindex, divisor);
end;
// added in gl3.3
public z_VertexP2ui_adr := GetFuncAdr('glVertexP2ui');
public z_VertexP2ui_ovr_0 := GetFuncOrNil&<procedure(&type: VertexPointerType; value: UInt32)>(z_VertexP2ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP2ui(&type: VertexPointerType; value: UInt32);
begin
z_VertexP2ui_ovr_0(&type, value);
end;
// added in gl3.3
public z_VertexP2uiv_adr := GetFuncAdr('glVertexP2uiv');
public z_VertexP2uiv_ovr_0 := GetFuncOrNil&<procedure(&type: VertexPointerType; var value: UInt32)>(z_VertexP2uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP2uiv(&type: VertexPointerType; value: array of UInt32);
begin
z_VertexP2uiv_ovr_0(&type, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP2uiv(&type: VertexPointerType; var value: UInt32);
begin
z_VertexP2uiv_ovr_0(&type, value);
end;
public z_VertexP2uiv_ovr_2 := GetFuncOrNil&<procedure(&type: VertexPointerType; value: IntPtr)>(z_VertexP2uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP2uiv(&type: VertexPointerType; value: IntPtr);
begin
z_VertexP2uiv_ovr_2(&type, value);
end;
// added in gl3.3
public z_VertexP3ui_adr := GetFuncAdr('glVertexP3ui');
public z_VertexP3ui_ovr_0 := GetFuncOrNil&<procedure(&type: VertexPointerType; value: UInt32)>(z_VertexP3ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP3ui(&type: VertexPointerType; value: UInt32);
begin
z_VertexP3ui_ovr_0(&type, value);
end;
// added in gl3.3
public z_VertexP3uiv_adr := GetFuncAdr('glVertexP3uiv');
public z_VertexP3uiv_ovr_0 := GetFuncOrNil&<procedure(&type: VertexPointerType; var value: UInt32)>(z_VertexP3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP3uiv(&type: VertexPointerType; value: array of UInt32);
begin
z_VertexP3uiv_ovr_0(&type, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP3uiv(&type: VertexPointerType; var value: UInt32);
begin
z_VertexP3uiv_ovr_0(&type, value);
end;
public z_VertexP3uiv_ovr_2 := GetFuncOrNil&<procedure(&type: VertexPointerType; value: IntPtr)>(z_VertexP3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP3uiv(&type: VertexPointerType; value: IntPtr);
begin
z_VertexP3uiv_ovr_2(&type, value);
end;
// added in gl3.3
public z_VertexP4ui_adr := GetFuncAdr('glVertexP4ui');
public z_VertexP4ui_ovr_0 := GetFuncOrNil&<procedure(&type: VertexPointerType; value: UInt32)>(z_VertexP4ui_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP4ui(&type: VertexPointerType; value: UInt32);
begin
z_VertexP4ui_ovr_0(&type, value);
end;
// added in gl3.3
public z_VertexP4uiv_adr := GetFuncAdr('glVertexP4uiv');
public z_VertexP4uiv_ovr_0 := GetFuncOrNil&<procedure(&type: VertexPointerType; var value: UInt32)>(z_VertexP4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP4uiv(&type: VertexPointerType; value: array of UInt32);
begin
z_VertexP4uiv_ovr_0(&type, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP4uiv(&type: VertexPointerType; var value: UInt32);
begin
z_VertexP4uiv_ovr_0(&type, value);
end;
public z_VertexP4uiv_ovr_2 := GetFuncOrNil&<procedure(&type: VertexPointerType; value: IntPtr)>(z_VertexP4uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexP4uiv(&type: VertexPointerType; value: IntPtr);
begin
z_VertexP4uiv_ovr_2(&type, value);
end;
// added in gl1.0
private static procedure _z_Viewport_ovr0(x: Int32; y: Int32; width: Int32; height: Int32);
external 'opengl32.dll' name 'glViewport';
public static z_Viewport_ovr0 := _z_Viewport_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Viewport(x: Int32; y: Int32; width: Int32; height: Int32) := z_Viewport_ovr0(x, y, width, height);
// added in gl4.1
public z_ViewportArrayv_adr := GetFuncAdr('glViewportArrayv');
public z_ViewportArrayv_ovr_0 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var v: single)>(z_ViewportArrayv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ViewportArrayv(first: UInt32; count: Int32; v: array of single);
begin
z_ViewportArrayv_ovr_0(first, count, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ViewportArrayv(first: UInt32; count: Int32; var v: single);
begin
z_ViewportArrayv_ovr_0(first, count, v);
end;
public 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);
begin
z_ViewportArrayv_ovr_2(first, count, v);
end;
// added in gl4.1
public z_ViewportIndexedf_adr := GetFuncAdr('glViewportIndexedf');
public 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);
begin
z_ViewportIndexedf_ovr_0(index, x, y, w, h);
end;
// added in gl4.1
public z_ViewportIndexedfv_adr := GetFuncAdr('glViewportIndexedfv');
public z_ViewportIndexedfv_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: single)>(z_ViewportIndexedfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ViewportIndexedfv(index: UInt32; v: array of single);
begin
z_ViewportIndexedfv_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ViewportIndexedfv(index: UInt32; var v: single);
begin
z_ViewportIndexedfv_ovr_0(index, v);
end;
public z_ViewportIndexedfv_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_ViewportIndexedfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ViewportIndexedfv(index: UInt32; v: IntPtr);
begin
z_ViewportIndexedfv_ovr_2(index, v);
end;
// added in gl3.2
public z_WaitSync_adr := GetFuncAdr('glWaitSync');
public 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);
begin
z_WaitSync_ovr_0(sync, flags, timeout);
end;
end;
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_ovr0(op: AccumOp; value: single);
external 'opengl32.dll' name 'glAccum';
public static z_Accum_ovr0 := _z_Accum_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Accum(op: AccumOp; value: single) := z_Accum_ovr0(op, value);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_AlphaFunc_ovr0(func: AlphaFunction; ref: single);
external 'opengl32.dll' name 'glAlphaFunc';
public static z_AlphaFunc_ovr0 := _z_AlphaFunc_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure AlphaFunc(func: AlphaFunction; ref: single) := z_AlphaFunc_ovr0(func, ref);
// added in gl1.1, deprecated in gl3.2
private static function _z_AreTexturesResident_ovr0(n: Int32; [MarshalAs(UnmanagedType.LPArray)] textures: array of UInt32; [MarshalAs(UnmanagedType.LPArray)] residences: array of boolean): boolean;
external 'opengl32.dll' name 'glAreTexturesResident';
public static z_AreTexturesResident_ovr0 := _z_AreTexturesResident_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResident(n: Int32; textures: array of UInt32; residences: array of boolean): boolean := z_AreTexturesResident_ovr0(n, textures, residences);
private static function _z_AreTexturesResident_ovr1(n: Int32; [MarshalAs(UnmanagedType.LPArray)] textures: array of UInt32; var residences: boolean): boolean;
external 'opengl32.dll' name 'glAreTexturesResident';
public static z_AreTexturesResident_ovr1 := _z_AreTexturesResident_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResident(n: Int32; textures: array of UInt32; var residences: boolean): boolean := z_AreTexturesResident_ovr1(n, textures, residences);
private static function _z_AreTexturesResident_ovr2(n: Int32; [MarshalAs(UnmanagedType.LPArray)] textures: array of UInt32; residences: IntPtr): boolean;
external 'opengl32.dll' name 'glAreTexturesResident';
public static z_AreTexturesResident_ovr2 := _z_AreTexturesResident_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResident(n: Int32; textures: array of UInt32; residences: IntPtr): boolean := z_AreTexturesResident_ovr2(n, textures, residences);
private static function _z_AreTexturesResident_ovr3(n: Int32; var textures: UInt32; [MarshalAs(UnmanagedType.LPArray)] residences: array of boolean): boolean;
external 'opengl32.dll' name 'glAreTexturesResident';
public static z_AreTexturesResident_ovr3 := _z_AreTexturesResident_ovr3;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResident(n: Int32; var textures: UInt32; residences: array of boolean): boolean := z_AreTexturesResident_ovr3(n, textures, residences);
private static function _z_AreTexturesResident_ovr4(n: Int32; var textures: UInt32; var residences: boolean): boolean;
external 'opengl32.dll' name 'glAreTexturesResident';
public static z_AreTexturesResident_ovr4 := _z_AreTexturesResident_ovr4;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResident(n: Int32; var textures: UInt32; var residences: boolean): boolean := z_AreTexturesResident_ovr4(n, textures, residences);
private static function _z_AreTexturesResident_ovr5(n: Int32; var textures: UInt32; residences: IntPtr): boolean;
external 'opengl32.dll' name 'glAreTexturesResident';
public static z_AreTexturesResident_ovr5 := _z_AreTexturesResident_ovr5;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResident(n: Int32; var textures: UInt32; residences: IntPtr): boolean := z_AreTexturesResident_ovr5(n, textures, residences);
private static function _z_AreTexturesResident_ovr6(n: Int32; textures: IntPtr; [MarshalAs(UnmanagedType.LPArray)] residences: array of boolean): boolean;
external 'opengl32.dll' name 'glAreTexturesResident';
public static z_AreTexturesResident_ovr6 := _z_AreTexturesResident_ovr6;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResident(n: Int32; textures: IntPtr; residences: array of boolean): boolean := z_AreTexturesResident_ovr6(n, textures, residences);
private static function _z_AreTexturesResident_ovr7(n: Int32; textures: IntPtr; var residences: boolean): boolean;
external 'opengl32.dll' name 'glAreTexturesResident';
public static z_AreTexturesResident_ovr7 := _z_AreTexturesResident_ovr7;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResident(n: Int32; textures: IntPtr; var residences: boolean): boolean := z_AreTexturesResident_ovr7(n, textures, residences);
private static function _z_AreTexturesResident_ovr8(n: Int32; textures: IntPtr; residences: IntPtr): boolean;
external 'opengl32.dll' name 'glAreTexturesResident';
public static z_AreTexturesResident_ovr8 := _z_AreTexturesResident_ovr8;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResident(n: Int32; textures: IntPtr; residences: IntPtr): boolean := z_AreTexturesResident_ovr8(n, textures, residences);
// added in gl1.1, deprecated in gl3.2
private static procedure _z_ArrayElement_ovr0(i: Int32);
external 'opengl32.dll' name 'glArrayElement';
public static z_ArrayElement_ovr0 := _z_ArrayElement_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ArrayElement(i: Int32) := z_ArrayElement_ovr0(i);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Begin_ovr0(mode: PrimitiveType);
external 'opengl32.dll' name 'glBegin';
public static z_Begin_ovr0 := _z_Begin_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure &Begin(mode: PrimitiveType) := z_Begin_ovr0(mode);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Bitmap_ovr0(width: Int32; height: Int32; xorig: single; yorig: single; xmove: single; ymove: single; [MarshalAs(UnmanagedType.LPArray)] bitmap: array of Byte);
external 'opengl32.dll' name 'glBitmap';
public static z_Bitmap_ovr0 := _z_Bitmap_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Bitmap(width: Int32; height: Int32; xorig: single; yorig: single; xmove: single; ymove: single; bitmap: array of Byte) := z_Bitmap_ovr0(width, height, xorig, yorig, xmove, ymove, bitmap);
private static procedure _z_Bitmap_ovr1(width: Int32; height: Int32; xorig: single; yorig: single; xmove: single; ymove: single; var bitmap: Byte);
external 'opengl32.dll' name 'glBitmap';
public static z_Bitmap_ovr1 := _z_Bitmap_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Bitmap(width: Int32; height: Int32; xorig: single; yorig: single; xmove: single; ymove: single; var bitmap: Byte) := z_Bitmap_ovr1(width, height, xorig, yorig, xmove, ymove, bitmap);
private static procedure _z_Bitmap_ovr2(width: Int32; height: Int32; xorig: single; yorig: single; xmove: single; ymove: single; bitmap: IntPtr);
external 'opengl32.dll' name 'glBitmap';
public static z_Bitmap_ovr2 := _z_Bitmap_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Bitmap(width: Int32; height: Int32; xorig: single; yorig: single; xmove: single; ymove: single; bitmap: IntPtr) := z_Bitmap_ovr2(width, height, xorig, yorig, xmove, ymove, bitmap);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_CallList_ovr0(list: UInt32);
external 'opengl32.dll' name 'glCallList';
public static z_CallList_ovr0 := _z_CallList_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CallList(list: UInt32) := z_CallList_ovr0(list);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_CallLists_ovr0(n: Int32; &type: ListNameType; lists: IntPtr);
external 'opengl32.dll' name 'glCallLists';
public static z_CallLists_ovr0 := _z_CallLists_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CallLists(n: Int32; &type: ListNameType; lists: IntPtr) := z_CallLists_ovr0(n, &type, lists);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_ClearAccum_ovr0(red: single; green: single; blue: single; alpha: single);
external 'opengl32.dll' name 'glClearAccum';
public static z_ClearAccum_ovr0 := _z_ClearAccum_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearAccum(red: single; green: single; blue: single; alpha: single) := z_ClearAccum_ovr0(red, green, blue, alpha);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_ClearIndex_ovr0(c: single);
external 'opengl32.dll' name 'glClearIndex';
public static z_ClearIndex_ovr0 := _z_ClearIndex_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearIndex(c: single) := z_ClearIndex_ovr0(c);
// added in gl1.3, deprecated in gl3.2
public z_ClientActiveTexture_adr := GetFuncAdr('glClientActiveTexture');
public z_ClientActiveTexture_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit)>(z_ClientActiveTexture_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClientActiveTexture(texture: TextureUnit);
begin
z_ClientActiveTexture_ovr_0(texture);
end;
// added in gl1.0, deprecated in gl3.2
private static procedure _z_ClipPlane_ovr0(plane: ClipPlaneName; [MarshalAs(UnmanagedType.LPArray)] equation: array of real);
external 'opengl32.dll' name 'glClipPlane';
public static z_ClipPlane_ovr0 := _z_ClipPlane_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClipPlane(plane: ClipPlaneName; equation: array of real) := z_ClipPlane_ovr0(plane, equation);
private static procedure _z_ClipPlane_ovr1(plane: ClipPlaneName; var equation: real);
external 'opengl32.dll' name 'glClipPlane';
public static z_ClipPlane_ovr1 := _z_ClipPlane_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClipPlane(plane: ClipPlaneName; var equation: real) := z_ClipPlane_ovr1(plane, equation);
private static procedure _z_ClipPlane_ovr2(plane: ClipPlaneName; equation: IntPtr);
external 'opengl32.dll' name 'glClipPlane';
public static z_ClipPlane_ovr2 := _z_ClipPlane_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClipPlane(plane: ClipPlaneName; equation: IntPtr) := z_ClipPlane_ovr2(plane, equation);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color3b_ovr0(red: SByte; green: SByte; blue: SByte);
external 'opengl32.dll' name 'glColor3b';
public static z_Color3b_ovr0 := _z_Color3b_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3b(red: SByte; green: SByte; blue: SByte) := z_Color3b_ovr0(red, green, blue);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color3bv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of SByte);
external 'opengl32.dll' name 'glColor3bv';
public static z_Color3bv_ovr0 := _z_Color3bv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3bv(v: array of SByte) := z_Color3bv_ovr0(v);
private static procedure _z_Color3bv_ovr1(var v: SByte);
external 'opengl32.dll' name 'glColor3bv';
public static z_Color3bv_ovr1 := _z_Color3bv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3bv(var v: SByte) := z_Color3bv_ovr1(v);
private static procedure _z_Color3bv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glColor3bv';
public static z_Color3bv_ovr2 := _z_Color3bv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3bv(v: IntPtr) := z_Color3bv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color3d_ovr0(red: real; green: real; blue: real);
external 'opengl32.dll' name 'glColor3d';
public static z_Color3d_ovr0 := _z_Color3d_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3d(red: real; green: real; blue: real) := z_Color3d_ovr0(red, green, blue);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color3dv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of real);
external 'opengl32.dll' name 'glColor3dv';
public static z_Color3dv_ovr0 := _z_Color3dv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3dv(v: array of real) := z_Color3dv_ovr0(v);
private static procedure _z_Color3dv_ovr1(var v: real);
external 'opengl32.dll' name 'glColor3dv';
public static z_Color3dv_ovr1 := _z_Color3dv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3dv(var v: real) := z_Color3dv_ovr1(v);
private static procedure _z_Color3dv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glColor3dv';
public static z_Color3dv_ovr2 := _z_Color3dv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3dv(v: IntPtr) := z_Color3dv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color3f_ovr0(red: single; green: single; blue: single);
external 'opengl32.dll' name 'glColor3f';
public static z_Color3f_ovr0 := _z_Color3f_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3f(red: single; green: single; blue: single) := z_Color3f_ovr0(red, green, blue);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color3fv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of single);
external 'opengl32.dll' name 'glColor3fv';
public static z_Color3fv_ovr0 := _z_Color3fv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3fv(v: array of single) := z_Color3fv_ovr0(v);
private static procedure _z_Color3fv_ovr1(var v: single);
external 'opengl32.dll' name 'glColor3fv';
public static z_Color3fv_ovr1 := _z_Color3fv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3fv(var v: single) := z_Color3fv_ovr1(v);
private static procedure _z_Color3fv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glColor3fv';
public static z_Color3fv_ovr2 := _z_Color3fv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3fv(v: IntPtr) := z_Color3fv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color3i_ovr0(red: Int32; green: Int32; blue: Int32);
external 'opengl32.dll' name 'glColor3i';
public static z_Color3i_ovr0 := _z_Color3i_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3i(red: Int32; green: Int32; blue: Int32) := z_Color3i_ovr0(red, green, blue);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color3iv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Int32);
external 'opengl32.dll' name 'glColor3iv';
public static z_Color3iv_ovr0 := _z_Color3iv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3iv(v: array of Int32) := z_Color3iv_ovr0(v);
private static procedure _z_Color3iv_ovr1(var v: Int32);
external 'opengl32.dll' name 'glColor3iv';
public static z_Color3iv_ovr1 := _z_Color3iv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3iv(var v: Int32) := z_Color3iv_ovr1(v);
private static procedure _z_Color3iv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glColor3iv';
public static z_Color3iv_ovr2 := _z_Color3iv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3iv(v: IntPtr) := z_Color3iv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color3s_ovr0(red: Int16; green: Int16; blue: Int16);
external 'opengl32.dll' name 'glColor3s';
public static z_Color3s_ovr0 := _z_Color3s_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3s(red: Int16; green: Int16; blue: Int16) := z_Color3s_ovr0(red, green, blue);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color3sv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Int16);
external 'opengl32.dll' name 'glColor3sv';
public static z_Color3sv_ovr0 := _z_Color3sv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3sv(v: array of Int16) := z_Color3sv_ovr0(v);
private static procedure _z_Color3sv_ovr1(var v: Int16);
external 'opengl32.dll' name 'glColor3sv';
public static z_Color3sv_ovr1 := _z_Color3sv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3sv(var v: Int16) := z_Color3sv_ovr1(v);
private static procedure _z_Color3sv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glColor3sv';
public static z_Color3sv_ovr2 := _z_Color3sv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3sv(v: IntPtr) := z_Color3sv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color3ub_ovr0(red: Byte; green: Byte; blue: Byte);
external 'opengl32.dll' name 'glColor3ub';
public static z_Color3ub_ovr0 := _z_Color3ub_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3ub(red: Byte; green: Byte; blue: Byte) := z_Color3ub_ovr0(red, green, blue);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color3ubv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Byte);
external 'opengl32.dll' name 'glColor3ubv';
public static z_Color3ubv_ovr0 := _z_Color3ubv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3ubv(v: array of Byte) := z_Color3ubv_ovr0(v);
private static procedure _z_Color3ubv_ovr1(var v: Byte);
external 'opengl32.dll' name 'glColor3ubv';
public static z_Color3ubv_ovr1 := _z_Color3ubv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3ubv(var v: Byte) := z_Color3ubv_ovr1(v);
private static procedure _z_Color3ubv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glColor3ubv';
public static z_Color3ubv_ovr2 := _z_Color3ubv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3ubv(v: IntPtr) := z_Color3ubv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color3ui_ovr0(red: UInt32; green: UInt32; blue: UInt32);
external 'opengl32.dll' name 'glColor3ui';
public static z_Color3ui_ovr0 := _z_Color3ui_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3ui(red: UInt32; green: UInt32; blue: UInt32) := z_Color3ui_ovr0(red, green, blue);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color3uiv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of UInt32);
external 'opengl32.dll' name 'glColor3uiv';
public static z_Color3uiv_ovr0 := _z_Color3uiv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3uiv(v: array of UInt32) := z_Color3uiv_ovr0(v);
private static procedure _z_Color3uiv_ovr1(var v: UInt32);
external 'opengl32.dll' name 'glColor3uiv';
public static z_Color3uiv_ovr1 := _z_Color3uiv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3uiv(var v: UInt32) := z_Color3uiv_ovr1(v);
private static procedure _z_Color3uiv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glColor3uiv';
public static z_Color3uiv_ovr2 := _z_Color3uiv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3uiv(v: IntPtr) := z_Color3uiv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color3us_ovr0(red: UInt16; green: UInt16; blue: UInt16);
external 'opengl32.dll' name 'glColor3us';
public static z_Color3us_ovr0 := _z_Color3us_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3us(red: UInt16; green: UInt16; blue: UInt16) := z_Color3us_ovr0(red, green, blue);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color3usv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of UInt16);
external 'opengl32.dll' name 'glColor3usv';
public static z_Color3usv_ovr0 := _z_Color3usv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3usv(v: array of UInt16) := z_Color3usv_ovr0(v);
private static procedure _z_Color3usv_ovr1(var v: UInt16);
external 'opengl32.dll' name 'glColor3usv';
public static z_Color3usv_ovr1 := _z_Color3usv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3usv(var v: UInt16) := z_Color3usv_ovr1(v);
private static procedure _z_Color3usv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glColor3usv';
public static z_Color3usv_ovr2 := _z_Color3usv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3usv(v: IntPtr) := z_Color3usv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color4b_ovr0(red: SByte; green: SByte; blue: SByte; alpha: SByte);
external 'opengl32.dll' name 'glColor4b';
public static z_Color4b_ovr0 := _z_Color4b_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4b(red: SByte; green: SByte; blue: SByte; alpha: SByte) := z_Color4b_ovr0(red, green, blue, alpha);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color4bv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of SByte);
external 'opengl32.dll' name 'glColor4bv';
public static z_Color4bv_ovr0 := _z_Color4bv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4bv(v: array of SByte) := z_Color4bv_ovr0(v);
private static procedure _z_Color4bv_ovr1(var v: SByte);
external 'opengl32.dll' name 'glColor4bv';
public static z_Color4bv_ovr1 := _z_Color4bv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4bv(var v: SByte) := z_Color4bv_ovr1(v);
private static procedure _z_Color4bv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glColor4bv';
public static z_Color4bv_ovr2 := _z_Color4bv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4bv(v: IntPtr) := z_Color4bv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color4d_ovr0(red: real; green: real; blue: real; alpha: real);
external 'opengl32.dll' name 'glColor4d';
public static z_Color4d_ovr0 := _z_Color4d_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4d(red: real; green: real; blue: real; alpha: real) := z_Color4d_ovr0(red, green, blue, alpha);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color4dv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of real);
external 'opengl32.dll' name 'glColor4dv';
public static z_Color4dv_ovr0 := _z_Color4dv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4dv(v: array of real) := z_Color4dv_ovr0(v);
private static procedure _z_Color4dv_ovr1(var v: real);
external 'opengl32.dll' name 'glColor4dv';
public static z_Color4dv_ovr1 := _z_Color4dv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4dv(var v: real) := z_Color4dv_ovr1(v);
private static procedure _z_Color4dv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glColor4dv';
public static z_Color4dv_ovr2 := _z_Color4dv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4dv(v: IntPtr) := z_Color4dv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color4f_ovr0(red: single; green: single; blue: single; alpha: single);
external 'opengl32.dll' name 'glColor4f';
public static z_Color4f_ovr0 := _z_Color4f_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4f(red: single; green: single; blue: single; alpha: single) := z_Color4f_ovr0(red, green, blue, alpha);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color4fv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of single);
external 'opengl32.dll' name 'glColor4fv';
public static z_Color4fv_ovr0 := _z_Color4fv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4fv(v: array of single) := z_Color4fv_ovr0(v);
private static procedure _z_Color4fv_ovr1(var v: single);
external 'opengl32.dll' name 'glColor4fv';
public static z_Color4fv_ovr1 := _z_Color4fv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4fv(var v: single) := z_Color4fv_ovr1(v);
private static procedure _z_Color4fv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glColor4fv';
public static z_Color4fv_ovr2 := _z_Color4fv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4fv(v: IntPtr) := z_Color4fv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color4i_ovr0(red: Int32; green: Int32; blue: Int32; alpha: Int32);
external 'opengl32.dll' name 'glColor4i';
public static z_Color4i_ovr0 := _z_Color4i_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4i(red: Int32; green: Int32; blue: Int32; alpha: Int32) := z_Color4i_ovr0(red, green, blue, alpha);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color4iv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Int32);
external 'opengl32.dll' name 'glColor4iv';
public static z_Color4iv_ovr0 := _z_Color4iv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4iv(v: array of Int32) := z_Color4iv_ovr0(v);
private static procedure _z_Color4iv_ovr1(var v: Int32);
external 'opengl32.dll' name 'glColor4iv';
public static z_Color4iv_ovr1 := _z_Color4iv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4iv(var v: Int32) := z_Color4iv_ovr1(v);
private static procedure _z_Color4iv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glColor4iv';
public static z_Color4iv_ovr2 := _z_Color4iv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4iv(v: IntPtr) := z_Color4iv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color4s_ovr0(red: Int16; green: Int16; blue: Int16; alpha: Int16);
external 'opengl32.dll' name 'glColor4s';
public static z_Color4s_ovr0 := _z_Color4s_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4s(red: Int16; green: Int16; blue: Int16; alpha: Int16) := z_Color4s_ovr0(red, green, blue, alpha);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color4sv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Int16);
external 'opengl32.dll' name 'glColor4sv';
public static z_Color4sv_ovr0 := _z_Color4sv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4sv(v: array of Int16) := z_Color4sv_ovr0(v);
private static procedure _z_Color4sv_ovr1(var v: Int16);
external 'opengl32.dll' name 'glColor4sv';
public static z_Color4sv_ovr1 := _z_Color4sv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4sv(var v: Int16) := z_Color4sv_ovr1(v);
private static procedure _z_Color4sv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glColor4sv';
public static z_Color4sv_ovr2 := _z_Color4sv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4sv(v: IntPtr) := z_Color4sv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color4ub_ovr0(red: Byte; green: Byte; blue: Byte; alpha: Byte);
external 'opengl32.dll' name 'glColor4ub';
public static z_Color4ub_ovr0 := _z_Color4ub_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ub(red: Byte; green: Byte; blue: Byte; alpha: Byte) := z_Color4ub_ovr0(red, green, blue, alpha);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color4ubv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Byte);
external 'opengl32.dll' name 'glColor4ubv';
public static z_Color4ubv_ovr0 := _z_Color4ubv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ubv(v: array of Byte) := z_Color4ubv_ovr0(v);
private static procedure _z_Color4ubv_ovr1(var v: Byte);
external 'opengl32.dll' name 'glColor4ubv';
public static z_Color4ubv_ovr1 := _z_Color4ubv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ubv(var v: Byte) := z_Color4ubv_ovr1(v);
private static procedure _z_Color4ubv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glColor4ubv';
public static z_Color4ubv_ovr2 := _z_Color4ubv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ubv(v: IntPtr) := z_Color4ubv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color4ui_ovr0(red: UInt32; green: UInt32; blue: UInt32; alpha: UInt32);
external 'opengl32.dll' name 'glColor4ui';
public static z_Color4ui_ovr0 := _z_Color4ui_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ui(red: UInt32; green: UInt32; blue: UInt32; alpha: UInt32) := z_Color4ui_ovr0(red, green, blue, alpha);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color4uiv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of UInt32);
external 'opengl32.dll' name 'glColor4uiv';
public static z_Color4uiv_ovr0 := _z_Color4uiv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4uiv(v: array of UInt32) := z_Color4uiv_ovr0(v);
private static procedure _z_Color4uiv_ovr1(var v: UInt32);
external 'opengl32.dll' name 'glColor4uiv';
public static z_Color4uiv_ovr1 := _z_Color4uiv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4uiv(var v: UInt32) := z_Color4uiv_ovr1(v);
private static procedure _z_Color4uiv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glColor4uiv';
public static z_Color4uiv_ovr2 := _z_Color4uiv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4uiv(v: IntPtr) := z_Color4uiv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color4us_ovr0(red: UInt16; green: UInt16; blue: UInt16; alpha: UInt16);
external 'opengl32.dll' name 'glColor4us';
public static z_Color4us_ovr0 := _z_Color4us_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4us(red: UInt16; green: UInt16; blue: UInt16; alpha: UInt16) := z_Color4us_ovr0(red, green, blue, alpha);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Color4usv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of UInt16);
external 'opengl32.dll' name 'glColor4usv';
public static z_Color4usv_ovr0 := _z_Color4usv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4usv(v: array of UInt16) := z_Color4usv_ovr0(v);
private static procedure _z_Color4usv_ovr1(var v: UInt16);
external 'opengl32.dll' name 'glColor4usv';
public static z_Color4usv_ovr1 := _z_Color4usv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4usv(var v: UInt16) := z_Color4usv_ovr1(v);
private static procedure _z_Color4usv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glColor4usv';
public static z_Color4usv_ovr2 := _z_Color4usv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4usv(v: IntPtr) := z_Color4usv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_ColorMaterial_ovr0(face: DummyEnum; mode: ColorMaterialParameter);
external 'opengl32.dll' name 'glColorMaterial';
public static z_ColorMaterial_ovr0 := _z_ColorMaterial_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorMaterial(face: DummyEnum; mode: ColorMaterialParameter) := z_ColorMaterial_ovr0(face, mode);
// added in gl1.1, deprecated in gl3.2
private static procedure _z_ColorPointer_ovr0(size: Int32; &type: ColorPointerType; stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glColorPointer';
public static z_ColorPointer_ovr0 := _z_ColorPointer_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorPointer(size: Int32; &type: ColorPointerType; stride: Int32; pointer: IntPtr) := z_ColorPointer_ovr0(size, &type, stride, pointer);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_CopyPixels_ovr0(x: Int32; y: Int32; width: Int32; height: Int32; &type: PixelCopyType);
external 'opengl32.dll' name 'glCopyPixels';
public static z_CopyPixels_ovr0 := _z_CopyPixels_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyPixels(x: Int32; y: Int32; width: Int32; height: Int32; &type: PixelCopyType) := z_CopyPixels_ovr0(x, y, width, height, &type);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_DeleteLists_ovr0(list: UInt32; range: Int32);
external 'opengl32.dll' name 'glDeleteLists';
public static z_DeleteLists_ovr0 := _z_DeleteLists_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteLists(list: UInt32; range: Int32) := z_DeleteLists_ovr0(list, range);
// added in gl1.1, deprecated in gl3.2
private static procedure _z_DisableClientState_ovr0(&array: EnableCap);
external 'opengl32.dll' name 'glDisableClientState';
public static z_DisableClientState_ovr0 := _z_DisableClientState_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DisableClientState(&array: EnableCap) := z_DisableClientState_ovr0(&array);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_DrawPixels_ovr0(width: Int32; height: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
external 'opengl32.dll' name 'glDrawPixels';
public static z_DrawPixels_ovr0 := _z_DrawPixels_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawPixels(width: Int32; height: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr) := z_DrawPixels_ovr0(width, height, format, &type, pixels);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_EdgeFlag_ovr0(flag: boolean);
external 'opengl32.dll' name 'glEdgeFlag';
public static z_EdgeFlag_ovr0 := _z_EdgeFlag_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EdgeFlag(flag: boolean) := z_EdgeFlag_ovr0(flag);
// added in gl1.1, deprecated in gl3.2
private static procedure _z_EdgeFlagPointer_ovr0(stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glEdgeFlagPointer';
public static z_EdgeFlagPointer_ovr0 := _z_EdgeFlagPointer_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EdgeFlagPointer(stride: Int32; pointer: IntPtr) := z_EdgeFlagPointer_ovr0(stride, pointer);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_EdgeFlagv_ovr0([MarshalAs(UnmanagedType.LPArray)] flag: array of boolean);
external 'opengl32.dll' name 'glEdgeFlagv';
public static z_EdgeFlagv_ovr0 := _z_EdgeFlagv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EdgeFlagv(flag: array of boolean) := z_EdgeFlagv_ovr0(flag);
private static procedure _z_EdgeFlagv_ovr1(var flag: boolean);
external 'opengl32.dll' name 'glEdgeFlagv';
public static z_EdgeFlagv_ovr1 := _z_EdgeFlagv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EdgeFlagv(var flag: boolean) := z_EdgeFlagv_ovr1(flag);
private static procedure _z_EdgeFlagv_ovr2(flag: IntPtr);
external 'opengl32.dll' name 'glEdgeFlagv';
public static z_EdgeFlagv_ovr2 := _z_EdgeFlagv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EdgeFlagv(flag: IntPtr) := z_EdgeFlagv_ovr2(flag);
// added in gl1.1, deprecated in gl3.2
private static procedure _z_EnableClientState_ovr0(&array: EnableCap);
external 'opengl32.dll' name 'glEnableClientState';
public static z_EnableClientState_ovr0 := _z_EnableClientState_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EnableClientState(&array: EnableCap) := z_EnableClientState_ovr0(&array);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_End_ovr0;
external 'opengl32.dll' name 'glEnd';
public static z_End_ovr0 := _z_End_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure &End := z_End_ovr0;
// added in gl1.0, deprecated in gl3.2
private static procedure _z_EndList_ovr0;
external 'opengl32.dll' name 'glEndList';
public static z_EndList_ovr0 := _z_EndList_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndList := z_EndList_ovr0;
// added in gl1.0, deprecated in gl3.2
private static procedure _z_EvalCoord1d_ovr0(u: real);
external 'opengl32.dll' name 'glEvalCoord1d';
public static z_EvalCoord1d_ovr0 := _z_EvalCoord1d_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord1d(u: real) := z_EvalCoord1d_ovr0(u);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_EvalCoord1dv_ovr0([MarshalAs(UnmanagedType.LPArray)] u: array of real);
external 'opengl32.dll' name 'glEvalCoord1dv';
public static z_EvalCoord1dv_ovr0 := _z_EvalCoord1dv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord1dv(u: array of real) := z_EvalCoord1dv_ovr0(u);
private static procedure _z_EvalCoord1dv_ovr1(var u: real);
external 'opengl32.dll' name 'glEvalCoord1dv';
public static z_EvalCoord1dv_ovr1 := _z_EvalCoord1dv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord1dv(var u: real) := z_EvalCoord1dv_ovr1(u);
private static procedure _z_EvalCoord1dv_ovr2(u: IntPtr);
external 'opengl32.dll' name 'glEvalCoord1dv';
public static z_EvalCoord1dv_ovr2 := _z_EvalCoord1dv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord1dv(u: IntPtr) := z_EvalCoord1dv_ovr2(u);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_EvalCoord1f_ovr0(u: single);
external 'opengl32.dll' name 'glEvalCoord1f';
public static z_EvalCoord1f_ovr0 := _z_EvalCoord1f_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord1f(u: single) := z_EvalCoord1f_ovr0(u);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_EvalCoord1fv_ovr0([MarshalAs(UnmanagedType.LPArray)] u: array of single);
external 'opengl32.dll' name 'glEvalCoord1fv';
public static z_EvalCoord1fv_ovr0 := _z_EvalCoord1fv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord1fv(u: array of single) := z_EvalCoord1fv_ovr0(u);
private static procedure _z_EvalCoord1fv_ovr1(var u: single);
external 'opengl32.dll' name 'glEvalCoord1fv';
public static z_EvalCoord1fv_ovr1 := _z_EvalCoord1fv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord1fv(var u: single) := z_EvalCoord1fv_ovr1(u);
private static procedure _z_EvalCoord1fv_ovr2(u: IntPtr);
external 'opengl32.dll' name 'glEvalCoord1fv';
public static z_EvalCoord1fv_ovr2 := _z_EvalCoord1fv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord1fv(u: IntPtr) := z_EvalCoord1fv_ovr2(u);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_EvalCoord2d_ovr0(u: real; v: real);
external 'opengl32.dll' name 'glEvalCoord2d';
public static z_EvalCoord2d_ovr0 := _z_EvalCoord2d_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord2d(u: real; v: real) := z_EvalCoord2d_ovr0(u, v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_EvalCoord2dv_ovr0([MarshalAs(UnmanagedType.LPArray)] u: array of real);
external 'opengl32.dll' name 'glEvalCoord2dv';
public static z_EvalCoord2dv_ovr0 := _z_EvalCoord2dv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord2dv(u: array of real) := z_EvalCoord2dv_ovr0(u);
private static procedure _z_EvalCoord2dv_ovr1(var u: real);
external 'opengl32.dll' name 'glEvalCoord2dv';
public static z_EvalCoord2dv_ovr1 := _z_EvalCoord2dv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord2dv(var u: real) := z_EvalCoord2dv_ovr1(u);
private static procedure _z_EvalCoord2dv_ovr2(u: IntPtr);
external 'opengl32.dll' name 'glEvalCoord2dv';
public static z_EvalCoord2dv_ovr2 := _z_EvalCoord2dv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord2dv(u: IntPtr) := z_EvalCoord2dv_ovr2(u);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_EvalCoord2f_ovr0(u: single; v: single);
external 'opengl32.dll' name 'glEvalCoord2f';
public static z_EvalCoord2f_ovr0 := _z_EvalCoord2f_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord2f(u: single; v: single) := z_EvalCoord2f_ovr0(u, v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_EvalCoord2fv_ovr0([MarshalAs(UnmanagedType.LPArray)] u: array of single);
external 'opengl32.dll' name 'glEvalCoord2fv';
public static z_EvalCoord2fv_ovr0 := _z_EvalCoord2fv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord2fv(u: array of single) := z_EvalCoord2fv_ovr0(u);
private static procedure _z_EvalCoord2fv_ovr1(var u: single);
external 'opengl32.dll' name 'glEvalCoord2fv';
public static z_EvalCoord2fv_ovr1 := _z_EvalCoord2fv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord2fv(var u: single) := z_EvalCoord2fv_ovr1(u);
private static procedure _z_EvalCoord2fv_ovr2(u: IntPtr);
external 'opengl32.dll' name 'glEvalCoord2fv';
public static z_EvalCoord2fv_ovr2 := _z_EvalCoord2fv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord2fv(u: IntPtr) := z_EvalCoord2fv_ovr2(u);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_EvalMesh1_ovr0(mode: MeshMode1; i1: Int32; i2: Int32);
external 'opengl32.dll' name 'glEvalMesh1';
public static z_EvalMesh1_ovr0 := _z_EvalMesh1_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalMesh1(mode: MeshMode1; i1: Int32; i2: Int32) := z_EvalMesh1_ovr0(mode, i1, i2);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_EvalMesh2_ovr0(mode: MeshMode2; i1: Int32; i2: Int32; j1: Int32; j2: Int32);
external 'opengl32.dll' name 'glEvalMesh2';
public static z_EvalMesh2_ovr0 := _z_EvalMesh2_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalMesh2(mode: MeshMode2; i1: Int32; i2: Int32; j1: Int32; j2: Int32) := z_EvalMesh2_ovr0(mode, i1, i2, j1, j2);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_EvalPoint1_ovr0(i: Int32);
external 'opengl32.dll' name 'glEvalPoint1';
public static z_EvalPoint1_ovr0 := _z_EvalPoint1_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalPoint1(i: Int32) := z_EvalPoint1_ovr0(i);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_EvalPoint2_ovr0(i: Int32; j: Int32);
external 'opengl32.dll' name 'glEvalPoint2';
public static z_EvalPoint2_ovr0 := _z_EvalPoint2_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalPoint2(i: Int32; j: Int32) := z_EvalPoint2_ovr0(i, j);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_FeedbackBuffer_ovr0(size: Int32; &type: FeedbackType; [MarshalAs(UnmanagedType.LPArray)] buffer: array of single);
external 'opengl32.dll' name 'glFeedbackBuffer';
public static z_FeedbackBuffer_ovr0 := _z_FeedbackBuffer_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FeedbackBuffer(size: Int32; &type: FeedbackType; buffer: array of single) := z_FeedbackBuffer_ovr0(size, &type, buffer);
private static procedure _z_FeedbackBuffer_ovr1(size: Int32; &type: FeedbackType; var buffer: single);
external 'opengl32.dll' name 'glFeedbackBuffer';
public static z_FeedbackBuffer_ovr1 := _z_FeedbackBuffer_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FeedbackBuffer(size: Int32; &type: FeedbackType; var buffer: single) := z_FeedbackBuffer_ovr1(size, &type, buffer);
private static procedure _z_FeedbackBuffer_ovr2(size: Int32; &type: FeedbackType; buffer: IntPtr);
external 'opengl32.dll' name 'glFeedbackBuffer';
public static z_FeedbackBuffer_ovr2 := _z_FeedbackBuffer_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FeedbackBuffer(size: Int32; &type: FeedbackType; buffer: IntPtr) := z_FeedbackBuffer_ovr2(size, &type, buffer);
// added in gl1.4, deprecated in gl3.2
public z_FogCoordd_adr := GetFuncAdr('glFogCoordd');
public z_FogCoordd_ovr_0 := GetFuncOrNil&<procedure(coord: real)>(z_FogCoordd_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordd(coord: real);
begin
z_FogCoordd_ovr_0(coord);
end;
// added in gl1.4, deprecated in gl3.2
public z_FogCoorddv_adr := GetFuncAdr('glFogCoorddv');
public z_FogCoorddv_ovr_0 := GetFuncOrNil&<procedure(var coord: real)>(z_FogCoorddv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoorddv(coord: array of real);
begin
z_FogCoorddv_ovr_0(coord[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoorddv(var coord: real);
begin
z_FogCoorddv_ovr_0(coord);
end;
public z_FogCoorddv_ovr_2 := GetFuncOrNil&<procedure(coord: IntPtr)>(z_FogCoorddv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoorddv(coord: IntPtr);
begin
z_FogCoorddv_ovr_2(coord);
end;
// added in gl1.4, deprecated in gl3.2
public z_FogCoordf_adr := GetFuncAdr('glFogCoordf');
public z_FogCoordf_ovr_0 := GetFuncOrNil&<procedure(coord: single)>(z_FogCoordf_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordf(coord: single);
begin
z_FogCoordf_ovr_0(coord);
end;
// added in gl1.4, deprecated in gl3.2
public z_FogCoordfv_adr := GetFuncAdr('glFogCoordfv');
public z_FogCoordfv_ovr_0 := GetFuncOrNil&<procedure(var coord: single)>(z_FogCoordfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordfv(coord: array of single);
begin
z_FogCoordfv_ovr_0(coord[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordfv(var coord: single);
begin
z_FogCoordfv_ovr_0(coord);
end;
public z_FogCoordfv_ovr_2 := GetFuncOrNil&<procedure(coord: IntPtr)>(z_FogCoordfv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordfv(coord: IntPtr);
begin
z_FogCoordfv_ovr_2(coord);
end;
// added in gl1.4, deprecated in gl3.2
public z_FogCoordPointer_adr := GetFuncAdr('glFogCoordPointer');
public 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);
begin
z_FogCoordPointer_ovr_0(&type, stride, pointer);
end;
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Fogf_ovr0(pname: FogParameter; param: single);
external 'opengl32.dll' name 'glFogf';
public static z_Fogf_ovr0 := _z_Fogf_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Fogf(pname: FogParameter; param: single) := z_Fogf_ovr0(pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Fogfv_ovr0(pname: FogParameter; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of single);
external 'opengl32.dll' name 'glFogfv';
public static z_Fogfv_ovr0 := _z_Fogfv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Fogfv(pname: FogParameter; ¶ms: array of single) := z_Fogfv_ovr0(pname, ¶ms);
private static procedure _z_Fogfv_ovr1(pname: FogParameter; var ¶ms: single);
external 'opengl32.dll' name 'glFogfv';
public static z_Fogfv_ovr1 := _z_Fogfv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Fogfv(pname: FogParameter; var ¶ms: single) := z_Fogfv_ovr1(pname, ¶ms);
private static procedure _z_Fogfv_ovr2(pname: FogParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glFogfv';
public static z_Fogfv_ovr2 := _z_Fogfv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Fogfv(pname: FogParameter; ¶ms: IntPtr) := z_Fogfv_ovr2(pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Fogi_ovr0(pname: FogParameter; param: Int32);
external 'opengl32.dll' name 'glFogi';
public static z_Fogi_ovr0 := _z_Fogi_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Fogi(pname: FogParameter; param: Int32) := z_Fogi_ovr0(pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Fogiv_ovr0(pname: FogParameter; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of Int32);
external 'opengl32.dll' name 'glFogiv';
public static z_Fogiv_ovr0 := _z_Fogiv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Fogiv(pname: FogParameter; ¶ms: array of Int32) := z_Fogiv_ovr0(pname, ¶ms);
private static procedure _z_Fogiv_ovr1(pname: FogParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glFogiv';
public static z_Fogiv_ovr1 := _z_Fogiv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Fogiv(pname: FogParameter; var ¶ms: Int32) := z_Fogiv_ovr1(pname, ¶ms);
private static procedure _z_Fogiv_ovr2(pname: FogParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glFogiv';
public static z_Fogiv_ovr2 := _z_Fogiv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Fogiv(pname: FogParameter; ¶ms: IntPtr) := z_Fogiv_ovr2(pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Frustum_ovr0(left: real; right: real; bottom: real; top: real; zNear: real; zFar: real);
external 'opengl32.dll' name 'glFrustum';
public static z_Frustum_ovr0 := _z_Frustum_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Frustum(left: real; right: real; bottom: real; top: real; zNear: real; zFar: real) := z_Frustum_ovr0(left, right, bottom, top, zNear, zFar);
// added in gl1.0, deprecated in gl3.2
private static function _z_GenLists_ovr0(range: Int32): UInt32;
external 'opengl32.dll' name 'glGenLists';
public static z_GenLists_ovr0 := _z_GenLists_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GenLists(range: Int32): UInt32 := z_GenLists_ovr0(range);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_GetClipPlane_ovr0(plane: ClipPlaneName; [MarshalAs(UnmanagedType.LPArray)] equation: array of real);
external 'opengl32.dll' name 'glGetClipPlane';
public static z_GetClipPlane_ovr0 := _z_GetClipPlane_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetClipPlane(plane: ClipPlaneName; equation: array of real) := z_GetClipPlane_ovr0(plane, equation);
private static procedure _z_GetClipPlane_ovr1(plane: ClipPlaneName; var equation: real);
external 'opengl32.dll' name 'glGetClipPlane';
public static z_GetClipPlane_ovr1 := _z_GetClipPlane_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetClipPlane(plane: ClipPlaneName; var equation: real) := z_GetClipPlane_ovr1(plane, equation);
private static procedure _z_GetClipPlane_ovr2(plane: ClipPlaneName; equation: IntPtr);
external 'opengl32.dll' name 'glGetClipPlane';
public static z_GetClipPlane_ovr2 := _z_GetClipPlane_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetClipPlane(plane: ClipPlaneName; equation: IntPtr) := z_GetClipPlane_ovr2(plane, equation);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_GetLightfv_ovr0(light: LightName; pname: LightParameter; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of single);
external 'opengl32.dll' name 'glGetLightfv';
public static z_GetLightfv_ovr0 := _z_GetLightfv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLightfv(light: LightName; pname: LightParameter; ¶ms: array of single) := z_GetLightfv_ovr0(light, pname, ¶ms);
private static procedure _z_GetLightfv_ovr1(light: LightName; pname: LightParameter; var ¶ms: single);
external 'opengl32.dll' name 'glGetLightfv';
public static z_GetLightfv_ovr1 := _z_GetLightfv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLightfv(light: LightName; pname: LightParameter; var ¶ms: single) := z_GetLightfv_ovr1(light, pname, ¶ms);
private static procedure _z_GetLightfv_ovr2(light: LightName; pname: LightParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetLightfv';
public static z_GetLightfv_ovr2 := _z_GetLightfv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLightfv(light: LightName; pname: LightParameter; ¶ms: IntPtr) := z_GetLightfv_ovr2(light, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_GetLightiv_ovr0(light: LightName; pname: LightParameter; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of Int32);
external 'opengl32.dll' name 'glGetLightiv';
public static z_GetLightiv_ovr0 := _z_GetLightiv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLightiv(light: LightName; pname: LightParameter; ¶ms: array of Int32) := z_GetLightiv_ovr0(light, pname, ¶ms);
private static procedure _z_GetLightiv_ovr1(light: LightName; pname: LightParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetLightiv';
public static z_GetLightiv_ovr1 := _z_GetLightiv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLightiv(light: LightName; pname: LightParameter; var ¶ms: Int32) := z_GetLightiv_ovr1(light, pname, ¶ms);
private static procedure _z_GetLightiv_ovr2(light: LightName; pname: LightParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetLightiv';
public static z_GetLightiv_ovr2 := _z_GetLightiv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLightiv(light: LightName; pname: LightParameter; ¶ms: IntPtr) := z_GetLightiv_ovr2(light, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_GetMapdv_ovr0(target: MapTarget; query: GetMapQuery; [MarshalAs(UnmanagedType.LPArray)] v: array of real);
external 'opengl32.dll' name 'glGetMapdv';
public static z_GetMapdv_ovr0 := _z_GetMapdv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapdv(target: MapTarget; query: GetMapQuery; v: array of real) := z_GetMapdv_ovr0(target, query, v);
private static procedure _z_GetMapdv_ovr1(target: MapTarget; query: GetMapQuery; var v: real);
external 'opengl32.dll' name 'glGetMapdv';
public static z_GetMapdv_ovr1 := _z_GetMapdv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapdv(target: MapTarget; query: GetMapQuery; var v: real) := z_GetMapdv_ovr1(target, query, v);
private static procedure _z_GetMapdv_ovr2(target: MapTarget; query: GetMapQuery; v: IntPtr);
external 'opengl32.dll' name 'glGetMapdv';
public static z_GetMapdv_ovr2 := _z_GetMapdv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapdv(target: MapTarget; query: GetMapQuery; v: IntPtr) := z_GetMapdv_ovr2(target, query, v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_GetMapfv_ovr0(target: MapTarget; query: GetMapQuery; [MarshalAs(UnmanagedType.LPArray)] v: array of single);
external 'opengl32.dll' name 'glGetMapfv';
public static z_GetMapfv_ovr0 := _z_GetMapfv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapfv(target: MapTarget; query: GetMapQuery; v: array of single) := z_GetMapfv_ovr0(target, query, v);
private static procedure _z_GetMapfv_ovr1(target: MapTarget; query: GetMapQuery; var v: single);
external 'opengl32.dll' name 'glGetMapfv';
public static z_GetMapfv_ovr1 := _z_GetMapfv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapfv(target: MapTarget; query: GetMapQuery; var v: single) := z_GetMapfv_ovr1(target, query, v);
private static procedure _z_GetMapfv_ovr2(target: MapTarget; query: GetMapQuery; v: IntPtr);
external 'opengl32.dll' name 'glGetMapfv';
public static z_GetMapfv_ovr2 := _z_GetMapfv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapfv(target: MapTarget; query: GetMapQuery; v: IntPtr) := z_GetMapfv_ovr2(target, query, v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_GetMapiv_ovr0(target: MapTarget; query: GetMapQuery; [MarshalAs(UnmanagedType.LPArray)] v: array of Int32);
external 'opengl32.dll' name 'glGetMapiv';
public static z_GetMapiv_ovr0 := _z_GetMapiv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapiv(target: MapTarget; query: GetMapQuery; v: array of Int32) := z_GetMapiv_ovr0(target, query, v);
private static procedure _z_GetMapiv_ovr1(target: MapTarget; query: GetMapQuery; var v: Int32);
external 'opengl32.dll' name 'glGetMapiv';
public static z_GetMapiv_ovr1 := _z_GetMapiv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapiv(target: MapTarget; query: GetMapQuery; var v: Int32) := z_GetMapiv_ovr1(target, query, v);
private static procedure _z_GetMapiv_ovr2(target: MapTarget; query: GetMapQuery; v: IntPtr);
external 'opengl32.dll' name 'glGetMapiv';
public static z_GetMapiv_ovr2 := _z_GetMapiv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapiv(target: MapTarget; query: GetMapQuery; v: IntPtr) := z_GetMapiv_ovr2(target, query, v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_GetMaterialfv_ovr0(face: DummyEnum; pname: MaterialParameter; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of single);
external 'opengl32.dll' name 'glGetMaterialfv';
public static z_GetMaterialfv_ovr0 := _z_GetMaterialfv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMaterialfv(face: DummyEnum; pname: MaterialParameter; ¶ms: array of single) := z_GetMaterialfv_ovr0(face, pname, ¶ms);
private static procedure _z_GetMaterialfv_ovr1(face: DummyEnum; pname: MaterialParameter; var ¶ms: single);
external 'opengl32.dll' name 'glGetMaterialfv';
public static z_GetMaterialfv_ovr1 := _z_GetMaterialfv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMaterialfv(face: DummyEnum; pname: MaterialParameter; var ¶ms: single) := z_GetMaterialfv_ovr1(face, pname, ¶ms);
private static procedure _z_GetMaterialfv_ovr2(face: DummyEnum; pname: MaterialParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMaterialfv';
public static z_GetMaterialfv_ovr2 := _z_GetMaterialfv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMaterialfv(face: DummyEnum; pname: MaterialParameter; ¶ms: IntPtr) := z_GetMaterialfv_ovr2(face, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_GetMaterialiv_ovr0(face: DummyEnum; pname: MaterialParameter; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of Int32);
external 'opengl32.dll' name 'glGetMaterialiv';
public static z_GetMaterialiv_ovr0 := _z_GetMaterialiv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMaterialiv(face: DummyEnum; pname: MaterialParameter; ¶ms: array of Int32) := z_GetMaterialiv_ovr0(face, pname, ¶ms);
private static procedure _z_GetMaterialiv_ovr1(face: DummyEnum; pname: MaterialParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetMaterialiv';
public static z_GetMaterialiv_ovr1 := _z_GetMaterialiv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMaterialiv(face: DummyEnum; pname: MaterialParameter; var ¶ms: Int32) := z_GetMaterialiv_ovr1(face, pname, ¶ms);
private static procedure _z_GetMaterialiv_ovr2(face: DummyEnum; pname: MaterialParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetMaterialiv';
public static z_GetMaterialiv_ovr2 := _z_GetMaterialiv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMaterialiv(face: DummyEnum; pname: MaterialParameter; ¶ms: IntPtr) := z_GetMaterialiv_ovr2(face, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_GetPixelMapfv_ovr0(map: PixelMap; [MarshalAs(UnmanagedType.LPArray)] values: array of single);
external 'opengl32.dll' name 'glGetPixelMapfv';
public static z_GetPixelMapfv_ovr0 := _z_GetPixelMapfv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelMapfv(map: PixelMap; values: array of single) := z_GetPixelMapfv_ovr0(map, values);
private static procedure _z_GetPixelMapfv_ovr1(map: PixelMap; var values: single);
external 'opengl32.dll' name 'glGetPixelMapfv';
public static z_GetPixelMapfv_ovr1 := _z_GetPixelMapfv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelMapfv(map: PixelMap; var values: single) := z_GetPixelMapfv_ovr1(map, values);
private static procedure _z_GetPixelMapfv_ovr2(map: PixelMap; values: IntPtr);
external 'opengl32.dll' name 'glGetPixelMapfv';
public static z_GetPixelMapfv_ovr2 := _z_GetPixelMapfv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelMapfv(map: PixelMap; values: IntPtr) := z_GetPixelMapfv_ovr2(map, values);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_GetPixelMapuiv_ovr0(map: PixelMap; [MarshalAs(UnmanagedType.LPArray)] values: array of UInt32);
external 'opengl32.dll' name 'glGetPixelMapuiv';
public static z_GetPixelMapuiv_ovr0 := _z_GetPixelMapuiv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelMapuiv(map: PixelMap; values: array of UInt32) := z_GetPixelMapuiv_ovr0(map, values);
private static procedure _z_GetPixelMapuiv_ovr1(map: PixelMap; var values: UInt32);
external 'opengl32.dll' name 'glGetPixelMapuiv';
public static z_GetPixelMapuiv_ovr1 := _z_GetPixelMapuiv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelMapuiv(map: PixelMap; var values: UInt32) := z_GetPixelMapuiv_ovr1(map, values);
private static procedure _z_GetPixelMapuiv_ovr2(map: PixelMap; values: IntPtr);
external 'opengl32.dll' name 'glGetPixelMapuiv';
public static z_GetPixelMapuiv_ovr2 := _z_GetPixelMapuiv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelMapuiv(map: PixelMap; values: IntPtr) := z_GetPixelMapuiv_ovr2(map, values);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_GetPixelMapusv_ovr0(map: PixelMap; [MarshalAs(UnmanagedType.LPArray)] values: array of UInt16);
external 'opengl32.dll' name 'glGetPixelMapusv';
public static z_GetPixelMapusv_ovr0 := _z_GetPixelMapusv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelMapusv(map: PixelMap; values: array of UInt16) := z_GetPixelMapusv_ovr0(map, values);
private static procedure _z_GetPixelMapusv_ovr1(map: PixelMap; var values: UInt16);
external 'opengl32.dll' name 'glGetPixelMapusv';
public static z_GetPixelMapusv_ovr1 := _z_GetPixelMapusv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelMapusv(map: PixelMap; var values: UInt16) := z_GetPixelMapusv_ovr1(map, values);
private static procedure _z_GetPixelMapusv_ovr2(map: PixelMap; values: IntPtr);
external 'opengl32.dll' name 'glGetPixelMapusv';
public static z_GetPixelMapusv_ovr2 := _z_GetPixelMapusv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelMapusv(map: PixelMap; values: IntPtr) := z_GetPixelMapusv_ovr2(map, values);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_GetPolygonStipple_ovr0([MarshalAs(UnmanagedType.LPArray)] mask: array of Byte);
external 'opengl32.dll' name 'glGetPolygonStipple';
public static z_GetPolygonStipple_ovr0 := _z_GetPolygonStipple_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPolygonStipple(mask: array of Byte) := z_GetPolygonStipple_ovr0(mask);
private static procedure _z_GetPolygonStipple_ovr1(var mask: Byte);
external 'opengl32.dll' name 'glGetPolygonStipple';
public static z_GetPolygonStipple_ovr1 := _z_GetPolygonStipple_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPolygonStipple(var mask: Byte) := z_GetPolygonStipple_ovr1(mask);
private static procedure _z_GetPolygonStipple_ovr2(mask: IntPtr);
external 'opengl32.dll' name 'glGetPolygonStipple';
public static z_GetPolygonStipple_ovr2 := _z_GetPolygonStipple_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPolygonStipple(mask: IntPtr) := z_GetPolygonStipple_ovr2(mask);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_GetTexEnvfv_ovr0(target: TextureEnvTarget; pname: TextureEnvParameter; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of single);
external 'opengl32.dll' name 'glGetTexEnvfv';
public static z_GetTexEnvfv_ovr0 := _z_GetTexEnvfv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexEnvfv(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: array of single) := z_GetTexEnvfv_ovr0(target, pname, ¶ms);
private static procedure _z_GetTexEnvfv_ovr1(target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: single);
external 'opengl32.dll' name 'glGetTexEnvfv';
public static z_GetTexEnvfv_ovr1 := _z_GetTexEnvfv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexEnvfv(target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: single) := z_GetTexEnvfv_ovr1(target, pname, ¶ms);
private static procedure _z_GetTexEnvfv_ovr2(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexEnvfv';
public static z_GetTexEnvfv_ovr2 := _z_GetTexEnvfv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexEnvfv(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr) := z_GetTexEnvfv_ovr2(target, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_GetTexEnviv_ovr0(target: TextureEnvTarget; pname: TextureEnvParameter; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of Int32);
external 'opengl32.dll' name 'glGetTexEnviv';
public static z_GetTexEnviv_ovr0 := _z_GetTexEnviv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexEnviv(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: array of Int32) := z_GetTexEnviv_ovr0(target, pname, ¶ms);
private static procedure _z_GetTexEnviv_ovr1(target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetTexEnviv';
public static z_GetTexEnviv_ovr1 := _z_GetTexEnviv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexEnviv(target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: Int32) := z_GetTexEnviv_ovr1(target, pname, ¶ms);
private static procedure _z_GetTexEnviv_ovr2(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexEnviv';
public static z_GetTexEnviv_ovr2 := _z_GetTexEnviv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexEnviv(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr) := z_GetTexEnviv_ovr2(target, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_GetTexGendv_ovr0(coord: TextureCoordName; pname: TextureGenParameter; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of real);
external 'opengl32.dll' name 'glGetTexGendv';
public static z_GetTexGendv_ovr0 := _z_GetTexGendv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexGendv(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of real) := z_GetTexGendv_ovr0(coord, pname, ¶ms);
private static procedure _z_GetTexGendv_ovr1(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: real);
external 'opengl32.dll' name 'glGetTexGendv';
public static z_GetTexGendv_ovr1 := _z_GetTexGendv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexGendv(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: real) := z_GetTexGendv_ovr1(coord, pname, ¶ms);
private static procedure _z_GetTexGendv_ovr2(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexGendv';
public static z_GetTexGendv_ovr2 := _z_GetTexGendv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexGendv(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr) := z_GetTexGendv_ovr2(coord, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_GetTexGenfv_ovr0(coord: TextureCoordName; pname: TextureGenParameter; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of single);
external 'opengl32.dll' name 'glGetTexGenfv';
public static z_GetTexGenfv_ovr0 := _z_GetTexGenfv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexGenfv(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of single) := z_GetTexGenfv_ovr0(coord, pname, ¶ms);
private static procedure _z_GetTexGenfv_ovr1(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: single);
external 'opengl32.dll' name 'glGetTexGenfv';
public static z_GetTexGenfv_ovr1 := _z_GetTexGenfv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexGenfv(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: single) := z_GetTexGenfv_ovr1(coord, pname, ¶ms);
private static procedure _z_GetTexGenfv_ovr2(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexGenfv';
public static z_GetTexGenfv_ovr2 := _z_GetTexGenfv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexGenfv(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr) := z_GetTexGenfv_ovr2(coord, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_GetTexGeniv_ovr0(coord: TextureCoordName; pname: TextureGenParameter; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of Int32);
external 'opengl32.dll' name 'glGetTexGeniv';
public static z_GetTexGeniv_ovr0 := _z_GetTexGeniv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexGeniv(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of Int32) := z_GetTexGeniv_ovr0(coord, pname, ¶ms);
private static procedure _z_GetTexGeniv_ovr1(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glGetTexGeniv';
public static z_GetTexGeniv_ovr1 := _z_GetTexGeniv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexGeniv(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: Int32) := z_GetTexGeniv_ovr1(coord, pname, ¶ms);
private static procedure _z_GetTexGeniv_ovr2(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glGetTexGeniv';
public static z_GetTexGeniv_ovr2 := _z_GetTexGeniv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexGeniv(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr) := z_GetTexGeniv_ovr2(coord, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Indexd_ovr0(c: real);
external 'opengl32.dll' name 'glIndexd';
public static z_Indexd_ovr0 := _z_Indexd_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexd(c: real) := z_Indexd_ovr0(c);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Indexdv_ovr0([MarshalAs(UnmanagedType.LPArray)] c: array of real);
external 'opengl32.dll' name 'glIndexdv';
public static z_Indexdv_ovr0 := _z_Indexdv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexdv(c: array of real) := z_Indexdv_ovr0(c);
private static procedure _z_Indexdv_ovr1(var c: real);
external 'opengl32.dll' name 'glIndexdv';
public static z_Indexdv_ovr1 := _z_Indexdv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexdv(var c: real) := z_Indexdv_ovr1(c);
private static procedure _z_Indexdv_ovr2(c: IntPtr);
external 'opengl32.dll' name 'glIndexdv';
public static z_Indexdv_ovr2 := _z_Indexdv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexdv(c: IntPtr) := z_Indexdv_ovr2(c);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Indexf_ovr0(c: single);
external 'opengl32.dll' name 'glIndexf';
public static z_Indexf_ovr0 := _z_Indexf_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexf(c: single) := z_Indexf_ovr0(c);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Indexfv_ovr0([MarshalAs(UnmanagedType.LPArray)] c: array of single);
external 'opengl32.dll' name 'glIndexfv';
public static z_Indexfv_ovr0 := _z_Indexfv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexfv(c: array of single) := z_Indexfv_ovr0(c);
private static procedure _z_Indexfv_ovr1(var c: single);
external 'opengl32.dll' name 'glIndexfv';
public static z_Indexfv_ovr1 := _z_Indexfv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexfv(var c: single) := z_Indexfv_ovr1(c);
private static procedure _z_Indexfv_ovr2(c: IntPtr);
external 'opengl32.dll' name 'glIndexfv';
public static z_Indexfv_ovr2 := _z_Indexfv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexfv(c: IntPtr) := z_Indexfv_ovr2(c);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Indexi_ovr0(c: Int32);
external 'opengl32.dll' name 'glIndexi';
public static z_Indexi_ovr0 := _z_Indexi_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexi(c: Int32) := z_Indexi_ovr0(c);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Indexiv_ovr0([MarshalAs(UnmanagedType.LPArray)] c: array of Int32);
external 'opengl32.dll' name 'glIndexiv';
public static z_Indexiv_ovr0 := _z_Indexiv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexiv(c: array of Int32) := z_Indexiv_ovr0(c);
private static procedure _z_Indexiv_ovr1(var c: Int32);
external 'opengl32.dll' name 'glIndexiv';
public static z_Indexiv_ovr1 := _z_Indexiv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexiv(var c: Int32) := z_Indexiv_ovr1(c);
private static procedure _z_Indexiv_ovr2(c: IntPtr);
external 'opengl32.dll' name 'glIndexiv';
public static z_Indexiv_ovr2 := _z_Indexiv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexiv(c: IntPtr) := z_Indexiv_ovr2(c);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_IndexMask_ovr0(mask: UInt32);
external 'opengl32.dll' name 'glIndexMask';
public static z_IndexMask_ovr0 := _z_IndexMask_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IndexMask(mask: UInt32) := z_IndexMask_ovr0(mask);
// added in gl1.1, deprecated in gl3.2
private static procedure _z_IndexPointer_ovr0(&type: IndexPointerType; stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glIndexPointer';
public static z_IndexPointer_ovr0 := _z_IndexPointer_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IndexPointer(&type: IndexPointerType; stride: Int32; pointer: IntPtr) := z_IndexPointer_ovr0(&type, stride, pointer);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Indexs_ovr0(c: Int16);
external 'opengl32.dll' name 'glIndexs';
public static z_Indexs_ovr0 := _z_Indexs_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexs(c: Int16) := z_Indexs_ovr0(c);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Indexsv_ovr0([MarshalAs(UnmanagedType.LPArray)] c: array of Int16);
external 'opengl32.dll' name 'glIndexsv';
public static z_Indexsv_ovr0 := _z_Indexsv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexsv(c: array of Int16) := z_Indexsv_ovr0(c);
private static procedure _z_Indexsv_ovr1(var c: Int16);
external 'opengl32.dll' name 'glIndexsv';
public static z_Indexsv_ovr1 := _z_Indexsv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexsv(var c: Int16) := z_Indexsv_ovr1(c);
private static procedure _z_Indexsv_ovr2(c: IntPtr);
external 'opengl32.dll' name 'glIndexsv';
public static z_Indexsv_ovr2 := _z_Indexsv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexsv(c: IntPtr) := z_Indexsv_ovr2(c);
// added in gl1.1, deprecated in gl3.2
private static procedure _z_Indexub_ovr0(c: Byte);
external 'opengl32.dll' name 'glIndexub';
public static z_Indexub_ovr0 := _z_Indexub_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexub(c: Byte) := z_Indexub_ovr0(c);
// added in gl1.1, deprecated in gl3.2
private static procedure _z_Indexubv_ovr0([MarshalAs(UnmanagedType.LPArray)] c: array of Byte);
external 'opengl32.dll' name 'glIndexubv';
public static z_Indexubv_ovr0 := _z_Indexubv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexubv(c: array of Byte) := z_Indexubv_ovr0(c);
private static procedure _z_Indexubv_ovr1(var c: Byte);
external 'opengl32.dll' name 'glIndexubv';
public static z_Indexubv_ovr1 := _z_Indexubv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexubv(var c: Byte) := z_Indexubv_ovr1(c);
private static procedure _z_Indexubv_ovr2(c: IntPtr);
external 'opengl32.dll' name 'glIndexubv';
public static z_Indexubv_ovr2 := _z_Indexubv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Indexubv(c: IntPtr) := z_Indexubv_ovr2(c);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_InitNames_ovr0;
external 'opengl32.dll' name 'glInitNames';
public static z_InitNames_ovr0 := _z_InitNames_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InitNames := z_InitNames_ovr0;
// added in gl1.1, deprecated in gl3.2
private static procedure _z_InterleavedArrays_ovr0(format: InterleavedArrayFormat; stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glInterleavedArrays';
public static z_InterleavedArrays_ovr0 := _z_InterleavedArrays_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InterleavedArrays(format: InterleavedArrayFormat; stride: Int32; pointer: IntPtr) := z_InterleavedArrays_ovr0(format, stride, pointer);
// added in gl1.0, deprecated in gl3.2
private static function _z_IsList_ovr0(list: UInt32): boolean;
external 'opengl32.dll' name 'glIsList';
public static z_IsList_ovr0 := _z_IsList_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsList(list: UInt32): boolean := z_IsList_ovr0(list);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Lightf_ovr0(light: LightName; pname: LightParameter; param: single);
external 'opengl32.dll' name 'glLightf';
public static z_Lightf_ovr0 := _z_Lightf_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Lightf(light: LightName; pname: LightParameter; param: single) := z_Lightf_ovr0(light, pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Lightfv_ovr0(light: LightName; pname: LightParameter; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of single);
external 'opengl32.dll' name 'glLightfv';
public static z_Lightfv_ovr0 := _z_Lightfv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Lightfv(light: LightName; pname: LightParameter; ¶ms: array of single) := z_Lightfv_ovr0(light, pname, ¶ms);
private static procedure _z_Lightfv_ovr1(light: LightName; pname: LightParameter; var ¶ms: single);
external 'opengl32.dll' name 'glLightfv';
public static z_Lightfv_ovr1 := _z_Lightfv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Lightfv(light: LightName; pname: LightParameter; var ¶ms: single) := z_Lightfv_ovr1(light, pname, ¶ms);
private static procedure _z_Lightfv_ovr2(light: LightName; pname: LightParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glLightfv';
public static z_Lightfv_ovr2 := _z_Lightfv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Lightfv(light: LightName; pname: LightParameter; ¶ms: IntPtr) := z_Lightfv_ovr2(light, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Lighti_ovr0(light: LightName; pname: LightParameter; param: Int32);
external 'opengl32.dll' name 'glLighti';
public static z_Lighti_ovr0 := _z_Lighti_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Lighti(light: LightName; pname: LightParameter; param: Int32) := z_Lighti_ovr0(light, pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Lightiv_ovr0(light: LightName; pname: LightParameter; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of Int32);
external 'opengl32.dll' name 'glLightiv';
public static z_Lightiv_ovr0 := _z_Lightiv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Lightiv(light: LightName; pname: LightParameter; ¶ms: array of Int32) := z_Lightiv_ovr0(light, pname, ¶ms);
private static procedure _z_Lightiv_ovr1(light: LightName; pname: LightParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glLightiv';
public static z_Lightiv_ovr1 := _z_Lightiv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Lightiv(light: LightName; pname: LightParameter; var ¶ms: Int32) := z_Lightiv_ovr1(light, pname, ¶ms);
private static procedure _z_Lightiv_ovr2(light: LightName; pname: LightParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glLightiv';
public static z_Lightiv_ovr2 := _z_Lightiv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Lightiv(light: LightName; pname: LightParameter; ¶ms: IntPtr) := z_Lightiv_ovr2(light, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_LightModelf_ovr0(pname: LightModelParameter; param: single);
external 'opengl32.dll' name 'glLightModelf';
public static z_LightModelf_ovr0 := _z_LightModelf_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightModelf(pname: LightModelParameter; param: single) := z_LightModelf_ovr0(pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_LightModelfv_ovr0(pname: LightModelParameter; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of single);
external 'opengl32.dll' name 'glLightModelfv';
public static z_LightModelfv_ovr0 := _z_LightModelfv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightModelfv(pname: LightModelParameter; ¶ms: array of single) := z_LightModelfv_ovr0(pname, ¶ms);
private static procedure _z_LightModelfv_ovr1(pname: LightModelParameter; var ¶ms: single);
external 'opengl32.dll' name 'glLightModelfv';
public static z_LightModelfv_ovr1 := _z_LightModelfv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightModelfv(pname: LightModelParameter; var ¶ms: single) := z_LightModelfv_ovr1(pname, ¶ms);
private static procedure _z_LightModelfv_ovr2(pname: LightModelParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glLightModelfv';
public static z_LightModelfv_ovr2 := _z_LightModelfv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightModelfv(pname: LightModelParameter; ¶ms: IntPtr) := z_LightModelfv_ovr2(pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_LightModeli_ovr0(pname: LightModelParameter; param: Int32);
external 'opengl32.dll' name 'glLightModeli';
public static z_LightModeli_ovr0 := _z_LightModeli_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightModeli(pname: LightModelParameter; param: Int32) := z_LightModeli_ovr0(pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_LightModeliv_ovr0(pname: LightModelParameter; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of Int32);
external 'opengl32.dll' name 'glLightModeliv';
public static z_LightModeliv_ovr0 := _z_LightModeliv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightModeliv(pname: LightModelParameter; ¶ms: array of Int32) := z_LightModeliv_ovr0(pname, ¶ms);
private static procedure _z_LightModeliv_ovr1(pname: LightModelParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glLightModeliv';
public static z_LightModeliv_ovr1 := _z_LightModeliv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightModeliv(pname: LightModelParameter; var ¶ms: Int32) := z_LightModeliv_ovr1(pname, ¶ms);
private static procedure _z_LightModeliv_ovr2(pname: LightModelParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glLightModeliv';
public static z_LightModeliv_ovr2 := _z_LightModeliv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightModeliv(pname: LightModelParameter; ¶ms: IntPtr) := z_LightModeliv_ovr2(pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_LineStipple_ovr0(factor: Int32; pattern: UInt16);
external 'opengl32.dll' name 'glLineStipple';
public static z_LineStipple_ovr0 := _z_LineStipple_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LineStipple(factor: Int32; pattern: UInt16) := z_LineStipple_ovr0(factor, pattern);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_ListBase_ovr0(base: UInt32);
external 'opengl32.dll' name 'glListBase';
public static z_ListBase_ovr0 := _z_ListBase_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListBase(base: UInt32) := z_ListBase_ovr0(base);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_LoadIdentity_ovr0;
external 'opengl32.dll' name 'glLoadIdentity';
public static z_LoadIdentity_ovr0 := _z_LoadIdentity_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadIdentity := z_LoadIdentity_ovr0;
// added in gl1.0, deprecated in gl3.2
private static procedure _z_LoadMatrixd_ovr0([MarshalAs(UnmanagedType.LPArray)] m: array of real);
external 'opengl32.dll' name 'glLoadMatrixd';
public static z_LoadMatrixd_ovr0 := _z_LoadMatrixd_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadMatrixd(m: array of real) := z_LoadMatrixd_ovr0(m);
private static procedure _z_LoadMatrixd_ovr1(var m: real);
external 'opengl32.dll' name 'glLoadMatrixd';
public static z_LoadMatrixd_ovr1 := _z_LoadMatrixd_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadMatrixd(var m: real) := z_LoadMatrixd_ovr1(m);
private static procedure _z_LoadMatrixd_ovr2(m: IntPtr);
external 'opengl32.dll' name 'glLoadMatrixd';
public static z_LoadMatrixd_ovr2 := _z_LoadMatrixd_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadMatrixd(m: IntPtr) := z_LoadMatrixd_ovr2(m);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_LoadMatrixf_ovr0([MarshalAs(UnmanagedType.LPArray)] m: array of single);
external 'opengl32.dll' name 'glLoadMatrixf';
public static z_LoadMatrixf_ovr0 := _z_LoadMatrixf_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadMatrixf(m: array of single) := z_LoadMatrixf_ovr0(m);
private static procedure _z_LoadMatrixf_ovr1(var m: single);
external 'opengl32.dll' name 'glLoadMatrixf';
public static z_LoadMatrixf_ovr1 := _z_LoadMatrixf_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadMatrixf(var m: single) := z_LoadMatrixf_ovr1(m);
private static procedure _z_LoadMatrixf_ovr2(m: IntPtr);
external 'opengl32.dll' name 'glLoadMatrixf';
public static z_LoadMatrixf_ovr2 := _z_LoadMatrixf_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadMatrixf(m: IntPtr) := z_LoadMatrixf_ovr2(m);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_LoadName_ovr0(name: UInt32);
external 'opengl32.dll' name 'glLoadName';
public static z_LoadName_ovr0 := _z_LoadName_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadName(name: UInt32) := z_LoadName_ovr0(name);
// added in gl1.3, deprecated in gl3.2
public z_LoadTransposeMatrixd_adr := GetFuncAdr('glLoadTransposeMatrixd');
public z_LoadTransposeMatrixd_ovr_0 := GetFuncOrNil&<procedure(var m: real)>(z_LoadTransposeMatrixd_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixd(m: array of real);
begin
z_LoadTransposeMatrixd_ovr_0(m[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixd(var m: real);
begin
z_LoadTransposeMatrixd_ovr_0(m);
end;
public z_LoadTransposeMatrixd_ovr_2 := GetFuncOrNil&<procedure(m: IntPtr)>(z_LoadTransposeMatrixd_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixd(m: IntPtr);
begin
z_LoadTransposeMatrixd_ovr_2(m);
end;
// added in gl1.3, deprecated in gl3.2
public z_LoadTransposeMatrixf_adr := GetFuncAdr('glLoadTransposeMatrixf');
public z_LoadTransposeMatrixf_ovr_0 := GetFuncOrNil&<procedure(var m: single)>(z_LoadTransposeMatrixf_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixf(m: array of single);
begin
z_LoadTransposeMatrixf_ovr_0(m[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixf(var m: single);
begin
z_LoadTransposeMatrixf_ovr_0(m);
end;
public z_LoadTransposeMatrixf_ovr_2 := GetFuncOrNil&<procedure(m: IntPtr)>(z_LoadTransposeMatrixf_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixf(m: IntPtr);
begin
z_LoadTransposeMatrixf_ovr_2(m);
end;
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Map1d_ovr0(target: MapTarget; u1: real; u2: real; stride: Int32; order: Int32; [MarshalAs(UnmanagedType.LPArray)] points: array of real);
external 'opengl32.dll' name 'glMap1d';
public static z_Map1d_ovr0 := _z_Map1d_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Map1d(target: MapTarget; u1: real; u2: real; stride: Int32; order: Int32; points: array of real) := z_Map1d_ovr0(target, u1, u2, stride, order, points);
private static procedure _z_Map1d_ovr1(target: MapTarget; u1: real; u2: real; stride: Int32; order: Int32; var points: real);
external 'opengl32.dll' name 'glMap1d';
public static z_Map1d_ovr1 := _z_Map1d_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Map1d(target: MapTarget; u1: real; u2: real; stride: Int32; order: Int32; var points: real) := z_Map1d_ovr1(target, u1, u2, stride, order, points);
private static procedure _z_Map1d_ovr2(target: MapTarget; u1: real; u2: real; stride: Int32; order: Int32; points: IntPtr);
external 'opengl32.dll' name 'glMap1d';
public static z_Map1d_ovr2 := _z_Map1d_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Map1d(target: MapTarget; u1: real; u2: real; stride: Int32; order: Int32; points: IntPtr) := z_Map1d_ovr2(target, u1, u2, stride, order, points);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Map1f_ovr0(target: MapTarget; u1: single; u2: single; stride: Int32; order: Int32; [MarshalAs(UnmanagedType.LPArray)] points: array of single);
external 'opengl32.dll' name 'glMap1f';
public static z_Map1f_ovr0 := _z_Map1f_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Map1f(target: MapTarget; u1: single; u2: single; stride: Int32; order: Int32; points: array of single) := z_Map1f_ovr0(target, u1, u2, stride, order, points);
private static procedure _z_Map1f_ovr1(target: MapTarget; u1: single; u2: single; stride: Int32; order: Int32; var points: single);
external 'opengl32.dll' name 'glMap1f';
public static z_Map1f_ovr1 := _z_Map1f_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Map1f(target: MapTarget; u1: single; u2: single; stride: Int32; order: Int32; var points: single) := z_Map1f_ovr1(target, u1, u2, stride, order, points);
private static procedure _z_Map1f_ovr2(target: MapTarget; u1: single; u2: single; stride: Int32; order: Int32; points: IntPtr);
external 'opengl32.dll' name 'glMap1f';
public static z_Map1f_ovr2 := _z_Map1f_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Map1f(target: MapTarget; u1: single; u2: single; stride: Int32; order: Int32; points: IntPtr) := z_Map1f_ovr2(target, u1, u2, stride, order, points);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Map2d_ovr0(target: MapTarget; u1: real; u2: real; ustride: Int32; uorder: Int32; v1: real; v2: real; vstride: Int32; vorder: Int32; [MarshalAs(UnmanagedType.LPArray)] points: array of real);
external 'opengl32.dll' name 'glMap2d';
public static z_Map2d_ovr0 := _z_Map2d_ovr0;
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) := z_Map2d_ovr0(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
private static procedure _z_Map2d_ovr1(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';
public static z_Map2d_ovr1 := _z_Map2d_ovr1;
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_ovr1(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
private static procedure _z_Map2d_ovr2(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 static z_Map2d_ovr2 := _z_Map2d_ovr2;
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_ovr2(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Map2f_ovr0(target: MapTarget; u1: single; u2: single; ustride: Int32; uorder: Int32; v1: single; v2: single; vstride: Int32; vorder: Int32; [MarshalAs(UnmanagedType.LPArray)] points: array of single);
external 'opengl32.dll' name 'glMap2f';
public static z_Map2f_ovr0 := _z_Map2f_ovr0;
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) := z_Map2f_ovr0(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
private static procedure _z_Map2f_ovr1(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';
public static z_Map2f_ovr1 := _z_Map2f_ovr1;
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_ovr1(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
private static procedure _z_Map2f_ovr2(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 static z_Map2f_ovr2 := _z_Map2f_ovr2;
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_ovr2(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_MapGrid1d_ovr0(un: Int32; u1: real; u2: real);
external 'opengl32.dll' name 'glMapGrid1d';
public static z_MapGrid1d_ovr0 := _z_MapGrid1d_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapGrid1d(un: Int32; u1: real; u2: real) := z_MapGrid1d_ovr0(un, u1, u2);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_MapGrid1f_ovr0(un: Int32; u1: single; u2: single);
external 'opengl32.dll' name 'glMapGrid1f';
public static z_MapGrid1f_ovr0 := _z_MapGrid1f_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapGrid1f(un: Int32; u1: single; u2: single) := z_MapGrid1f_ovr0(un, u1, u2);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_MapGrid2d_ovr0(un: Int32; u1: real; u2: real; vn: Int32; v1: real; v2: real);
external 'opengl32.dll' name 'glMapGrid2d';
public static z_MapGrid2d_ovr0 := _z_MapGrid2d_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapGrid2d(un: Int32; u1: real; u2: real; vn: Int32; v1: real; v2: real) := z_MapGrid2d_ovr0(un, u1, u2, vn, v1, v2);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_MapGrid2f_ovr0(un: Int32; u1: single; u2: single; vn: Int32; v1: single; v2: single);
external 'opengl32.dll' name 'glMapGrid2f';
public static z_MapGrid2f_ovr0 := _z_MapGrid2f_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapGrid2f(un: Int32; u1: single; u2: single; vn: Int32; v1: single; v2: single) := z_MapGrid2f_ovr0(un, u1, u2, vn, v1, v2);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Materialf_ovr0(face: DummyEnum; pname: MaterialParameter; param: single);
external 'opengl32.dll' name 'glMaterialf';
public static z_Materialf_ovr0 := _z_Materialf_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Materialf(face: DummyEnum; pname: MaterialParameter; param: single) := z_Materialf_ovr0(face, pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Materialfv_ovr0(face: DummyEnum; pname: MaterialParameter; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of single);
external 'opengl32.dll' name 'glMaterialfv';
public static z_Materialfv_ovr0 := _z_Materialfv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Materialfv(face: DummyEnum; pname: MaterialParameter; ¶ms: array of single) := z_Materialfv_ovr0(face, pname, ¶ms);
private static procedure _z_Materialfv_ovr1(face: DummyEnum; pname: MaterialParameter; var ¶ms: single);
external 'opengl32.dll' name 'glMaterialfv';
public static z_Materialfv_ovr1 := _z_Materialfv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Materialfv(face: DummyEnum; pname: MaterialParameter; var ¶ms: single) := z_Materialfv_ovr1(face, pname, ¶ms);
private static procedure _z_Materialfv_ovr2(face: DummyEnum; pname: MaterialParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMaterialfv';
public static z_Materialfv_ovr2 := _z_Materialfv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Materialfv(face: DummyEnum; pname: MaterialParameter; ¶ms: IntPtr) := z_Materialfv_ovr2(face, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Materiali_ovr0(face: DummyEnum; pname: MaterialParameter; param: Int32);
external 'opengl32.dll' name 'glMateriali';
public static z_Materiali_ovr0 := _z_Materiali_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Materiali(face: DummyEnum; pname: MaterialParameter; param: Int32) := z_Materiali_ovr0(face, pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Materialiv_ovr0(face: DummyEnum; pname: MaterialParameter; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of Int32);
external 'opengl32.dll' name 'glMaterialiv';
public static z_Materialiv_ovr0 := _z_Materialiv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Materialiv(face: DummyEnum; pname: MaterialParameter; ¶ms: array of Int32) := z_Materialiv_ovr0(face, pname, ¶ms);
private static procedure _z_Materialiv_ovr1(face: DummyEnum; pname: MaterialParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glMaterialiv';
public static z_Materialiv_ovr1 := _z_Materialiv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Materialiv(face: DummyEnum; pname: MaterialParameter; var ¶ms: Int32) := z_Materialiv_ovr1(face, pname, ¶ms);
private static procedure _z_Materialiv_ovr2(face: DummyEnum; pname: MaterialParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glMaterialiv';
public static z_Materialiv_ovr2 := _z_Materialiv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Materialiv(face: DummyEnum; pname: MaterialParameter; ¶ms: IntPtr) := z_Materialiv_ovr2(face, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_MatrixMode_ovr0(mode: OpenGL.MatrixMode);
external 'opengl32.dll' name 'glMatrixMode';
public static z_MatrixMode_ovr0 := _z_MatrixMode_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMode(mode: OpenGL.MatrixMode) := z_MatrixMode_ovr0(mode);
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord1d_adr := GetFuncAdr('glMultiTexCoord1d');
public z_MultiTexCoord1d_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: real)>(z_MultiTexCoord1d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1d(target: TextureUnit; s: real);
begin
z_MultiTexCoord1d_ovr_0(target, s);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord1dv_adr := GetFuncAdr('glMultiTexCoord1dv');
public z_MultiTexCoord1dv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: real)>(z_MultiTexCoord1dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1dv(target: TextureUnit; v: array of real);
begin
z_MultiTexCoord1dv_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1dv(target: TextureUnit; var v: real);
begin
z_MultiTexCoord1dv_ovr_0(target, v);
end;
public z_MultiTexCoord1dv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord1dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1dv(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord1dv_ovr_2(target, v);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord1f_adr := GetFuncAdr('glMultiTexCoord1f');
public z_MultiTexCoord1f_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: single)>(z_MultiTexCoord1f_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1f(target: TextureUnit; s: single);
begin
z_MultiTexCoord1f_ovr_0(target, s);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord1fv_adr := GetFuncAdr('glMultiTexCoord1fv');
public z_MultiTexCoord1fv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: single)>(z_MultiTexCoord1fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1fv(target: TextureUnit; v: array of single);
begin
z_MultiTexCoord1fv_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1fv(target: TextureUnit; var v: single);
begin
z_MultiTexCoord1fv_ovr_0(target, v);
end;
public z_MultiTexCoord1fv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord1fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1fv(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord1fv_ovr_2(target, v);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord1i_adr := GetFuncAdr('glMultiTexCoord1i');
public z_MultiTexCoord1i_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: Int32)>(z_MultiTexCoord1i_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1i(target: TextureUnit; s: Int32);
begin
z_MultiTexCoord1i_ovr_0(target, s);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord1iv_adr := GetFuncAdr('glMultiTexCoord1iv');
public z_MultiTexCoord1iv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Int32)>(z_MultiTexCoord1iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1iv(target: TextureUnit; v: array of Int32);
begin
z_MultiTexCoord1iv_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1iv(target: TextureUnit; var v: Int32);
begin
z_MultiTexCoord1iv_ovr_0(target, v);
end;
public z_MultiTexCoord1iv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord1iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1iv(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord1iv_ovr_2(target, v);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord1s_adr := GetFuncAdr('glMultiTexCoord1s');
public z_MultiTexCoord1s_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: Int16)>(z_MultiTexCoord1s_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1s(target: TextureUnit; s: Int16);
begin
z_MultiTexCoord1s_ovr_0(target, s);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord1sv_adr := GetFuncAdr('glMultiTexCoord1sv');
public z_MultiTexCoord1sv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Int16)>(z_MultiTexCoord1sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1sv(target: TextureUnit; v: array of Int16);
begin
z_MultiTexCoord1sv_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1sv(target: TextureUnit; var v: Int16);
begin
z_MultiTexCoord1sv_ovr_0(target, v);
end;
public z_MultiTexCoord1sv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord1sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1sv(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord1sv_ovr_2(target, v);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord2d_adr := GetFuncAdr('glMultiTexCoord2d');
public 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);
begin
z_MultiTexCoord2d_ovr_0(target, s, t);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord2dv_adr := GetFuncAdr('glMultiTexCoord2dv');
public z_MultiTexCoord2dv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: real)>(z_MultiTexCoord2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2dv(target: TextureUnit; v: array of real);
begin
z_MultiTexCoord2dv_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2dv(target: TextureUnit; var v: real);
begin
z_MultiTexCoord2dv_ovr_0(target, v);
end;
public z_MultiTexCoord2dv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2dv(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord2dv_ovr_2(target, v);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord2f_adr := GetFuncAdr('glMultiTexCoord2f');
public 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);
begin
z_MultiTexCoord2f_ovr_0(target, s, t);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord2fv_adr := GetFuncAdr('glMultiTexCoord2fv');
public z_MultiTexCoord2fv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: single)>(z_MultiTexCoord2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2fv(target: TextureUnit; v: array of single);
begin
z_MultiTexCoord2fv_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2fv(target: TextureUnit; var v: single);
begin
z_MultiTexCoord2fv_ovr_0(target, v);
end;
public z_MultiTexCoord2fv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2fv(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord2fv_ovr_2(target, v);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord2i_adr := GetFuncAdr('glMultiTexCoord2i');
public 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);
begin
z_MultiTexCoord2i_ovr_0(target, s, t);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord2iv_adr := GetFuncAdr('glMultiTexCoord2iv');
public z_MultiTexCoord2iv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Int32)>(z_MultiTexCoord2iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2iv(target: TextureUnit; v: array of Int32);
begin
z_MultiTexCoord2iv_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2iv(target: TextureUnit; var v: Int32);
begin
z_MultiTexCoord2iv_ovr_0(target, v);
end;
public z_MultiTexCoord2iv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord2iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2iv(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord2iv_ovr_2(target, v);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord2s_adr := GetFuncAdr('glMultiTexCoord2s');
public 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);
begin
z_MultiTexCoord2s_ovr_0(target, s, t);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord2sv_adr := GetFuncAdr('glMultiTexCoord2sv');
public z_MultiTexCoord2sv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Int16)>(z_MultiTexCoord2sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2sv(target: TextureUnit; v: array of Int16);
begin
z_MultiTexCoord2sv_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2sv(target: TextureUnit; var v: Int16);
begin
z_MultiTexCoord2sv_ovr_0(target, v);
end;
public z_MultiTexCoord2sv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord2sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2sv(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord2sv_ovr_2(target, v);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord3d_adr := GetFuncAdr('glMultiTexCoord3d');
public 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);
begin
z_MultiTexCoord3d_ovr_0(target, s, t, r);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord3dv_adr := GetFuncAdr('glMultiTexCoord3dv');
public z_MultiTexCoord3dv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: real)>(z_MultiTexCoord3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3dv(target: TextureUnit; v: array of real);
begin
z_MultiTexCoord3dv_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3dv(target: TextureUnit; var v: real);
begin
z_MultiTexCoord3dv_ovr_0(target, v);
end;
public z_MultiTexCoord3dv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3dv(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord3dv_ovr_2(target, v);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord3f_adr := GetFuncAdr('glMultiTexCoord3f');
public 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);
begin
z_MultiTexCoord3f_ovr_0(target, s, t, r);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord3fv_adr := GetFuncAdr('glMultiTexCoord3fv');
public z_MultiTexCoord3fv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: single)>(z_MultiTexCoord3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3fv(target: TextureUnit; v: array of single);
begin
z_MultiTexCoord3fv_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3fv(target: TextureUnit; var v: single);
begin
z_MultiTexCoord3fv_ovr_0(target, v);
end;
public z_MultiTexCoord3fv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3fv(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord3fv_ovr_2(target, v);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord3i_adr := GetFuncAdr('glMultiTexCoord3i');
public 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);
begin
z_MultiTexCoord3i_ovr_0(target, s, t, r);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord3iv_adr := GetFuncAdr('glMultiTexCoord3iv');
public z_MultiTexCoord3iv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Int32)>(z_MultiTexCoord3iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3iv(target: TextureUnit; v: array of Int32);
begin
z_MultiTexCoord3iv_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3iv(target: TextureUnit; var v: Int32);
begin
z_MultiTexCoord3iv_ovr_0(target, v);
end;
public z_MultiTexCoord3iv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord3iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3iv(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord3iv_ovr_2(target, v);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord3s_adr := GetFuncAdr('glMultiTexCoord3s');
public 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);
begin
z_MultiTexCoord3s_ovr_0(target, s, t, r);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord3sv_adr := GetFuncAdr('glMultiTexCoord3sv');
public z_MultiTexCoord3sv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Int16)>(z_MultiTexCoord3sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3sv(target: TextureUnit; v: array of Int16);
begin
z_MultiTexCoord3sv_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3sv(target: TextureUnit; var v: Int16);
begin
z_MultiTexCoord3sv_ovr_0(target, v);
end;
public z_MultiTexCoord3sv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord3sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3sv(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord3sv_ovr_2(target, v);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord4d_adr := GetFuncAdr('glMultiTexCoord4d');
public 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);
begin
z_MultiTexCoord4d_ovr_0(target, s, t, r, q);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord4dv_adr := GetFuncAdr('glMultiTexCoord4dv');
public z_MultiTexCoord4dv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: real)>(z_MultiTexCoord4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4dv(target: TextureUnit; v: array of real);
begin
z_MultiTexCoord4dv_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4dv(target: TextureUnit; var v: real);
begin
z_MultiTexCoord4dv_ovr_0(target, v);
end;
public z_MultiTexCoord4dv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord4dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4dv(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord4dv_ovr_2(target, v);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord4f_adr := GetFuncAdr('glMultiTexCoord4f');
public 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);
begin
z_MultiTexCoord4f_ovr_0(target, s, t, r, q);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord4fv_adr := GetFuncAdr('glMultiTexCoord4fv');
public z_MultiTexCoord4fv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: single)>(z_MultiTexCoord4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4fv(target: TextureUnit; v: array of single);
begin
z_MultiTexCoord4fv_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4fv(target: TextureUnit; var v: single);
begin
z_MultiTexCoord4fv_ovr_0(target, v);
end;
public z_MultiTexCoord4fv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord4fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4fv(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord4fv_ovr_2(target, v);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord4i_adr := GetFuncAdr('glMultiTexCoord4i');
public 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);
begin
z_MultiTexCoord4i_ovr_0(target, s, t, r, q);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord4iv_adr := GetFuncAdr('glMultiTexCoord4iv');
public z_MultiTexCoord4iv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Int32)>(z_MultiTexCoord4iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4iv(target: TextureUnit; v: array of Int32);
begin
z_MultiTexCoord4iv_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4iv(target: TextureUnit; var v: Int32);
begin
z_MultiTexCoord4iv_ovr_0(target, v);
end;
public z_MultiTexCoord4iv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord4iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4iv(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord4iv_ovr_2(target, v);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord4s_adr := GetFuncAdr('glMultiTexCoord4s');
public 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);
begin
z_MultiTexCoord4s_ovr_0(target, s, t, r, q);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultiTexCoord4sv_adr := GetFuncAdr('glMultiTexCoord4sv');
public z_MultiTexCoord4sv_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Int16)>(z_MultiTexCoord4sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4sv(target: TextureUnit; v: array of Int16);
begin
z_MultiTexCoord4sv_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4sv(target: TextureUnit; var v: Int16);
begin
z_MultiTexCoord4sv_ovr_0(target, v);
end;
public z_MultiTexCoord4sv_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord4sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4sv(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord4sv_ovr_2(target, v);
end;
// added in gl1.0, deprecated in gl3.2
private static procedure _z_MultMatrixd_ovr0([MarshalAs(UnmanagedType.LPArray)] m: array of real);
external 'opengl32.dll' name 'glMultMatrixd';
public static z_MultMatrixd_ovr0 := _z_MultMatrixd_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultMatrixd(m: array of real) := z_MultMatrixd_ovr0(m);
private static procedure _z_MultMatrixd_ovr1(var m: real);
external 'opengl32.dll' name 'glMultMatrixd';
public static z_MultMatrixd_ovr1 := _z_MultMatrixd_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultMatrixd(var m: real) := z_MultMatrixd_ovr1(m);
private static procedure _z_MultMatrixd_ovr2(m: IntPtr);
external 'opengl32.dll' name 'glMultMatrixd';
public static z_MultMatrixd_ovr2 := _z_MultMatrixd_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultMatrixd(m: IntPtr) := z_MultMatrixd_ovr2(m);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_MultMatrixf_ovr0([MarshalAs(UnmanagedType.LPArray)] m: array of single);
external 'opengl32.dll' name 'glMultMatrixf';
public static z_MultMatrixf_ovr0 := _z_MultMatrixf_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultMatrixf(m: array of single) := z_MultMatrixf_ovr0(m);
private static procedure _z_MultMatrixf_ovr1(var m: single);
external 'opengl32.dll' name 'glMultMatrixf';
public static z_MultMatrixf_ovr1 := _z_MultMatrixf_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultMatrixf(var m: single) := z_MultMatrixf_ovr1(m);
private static procedure _z_MultMatrixf_ovr2(m: IntPtr);
external 'opengl32.dll' name 'glMultMatrixf';
public static z_MultMatrixf_ovr2 := _z_MultMatrixf_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultMatrixf(m: IntPtr) := z_MultMatrixf_ovr2(m);
// added in gl1.3, deprecated in gl3.2
public z_MultTransposeMatrixd_adr := GetFuncAdr('glMultTransposeMatrixd');
public z_MultTransposeMatrixd_ovr_0 := GetFuncOrNil&<procedure(var m: real)>(z_MultTransposeMatrixd_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixd(m: array of real);
begin
z_MultTransposeMatrixd_ovr_0(m[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixd(var m: real);
begin
z_MultTransposeMatrixd_ovr_0(m);
end;
public z_MultTransposeMatrixd_ovr_2 := GetFuncOrNil&<procedure(m: IntPtr)>(z_MultTransposeMatrixd_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixd(m: IntPtr);
begin
z_MultTransposeMatrixd_ovr_2(m);
end;
// added in gl1.3, deprecated in gl3.2
public z_MultTransposeMatrixf_adr := GetFuncAdr('glMultTransposeMatrixf');
public z_MultTransposeMatrixf_ovr_0 := GetFuncOrNil&<procedure(var m: single)>(z_MultTransposeMatrixf_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixf(m: array of single);
begin
z_MultTransposeMatrixf_ovr_0(m[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixf(var m: single);
begin
z_MultTransposeMatrixf_ovr_0(m);
end;
public z_MultTransposeMatrixf_ovr_2 := GetFuncOrNil&<procedure(m: IntPtr)>(z_MultTransposeMatrixf_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixf(m: IntPtr);
begin
z_MultTransposeMatrixf_ovr_2(m);
end;
// added in gl1.0, deprecated in gl3.2
private static procedure _z_NewList_ovr0(list: UInt32; mode: ListMode);
external 'opengl32.dll' name 'glNewList';
public static z_NewList_ovr0 := _z_NewList_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NewList(list: UInt32; mode: ListMode) := z_NewList_ovr0(list, mode);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Normal3b_ovr0(nx: SByte; ny: SByte; nz: SByte);
external 'opengl32.dll' name 'glNormal3b';
public static z_Normal3b_ovr0 := _z_Normal3b_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3b(nx: SByte; ny: SByte; nz: SByte) := z_Normal3b_ovr0(nx, ny, nz);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Normal3bv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of SByte);
external 'opengl32.dll' name 'glNormal3bv';
public static z_Normal3bv_ovr0 := _z_Normal3bv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3bv(v: array of SByte) := z_Normal3bv_ovr0(v);
private static procedure _z_Normal3bv_ovr1(var v: SByte);
external 'opengl32.dll' name 'glNormal3bv';
public static z_Normal3bv_ovr1 := _z_Normal3bv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3bv(var v: SByte) := z_Normal3bv_ovr1(v);
private static procedure _z_Normal3bv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glNormal3bv';
public static z_Normal3bv_ovr2 := _z_Normal3bv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3bv(v: IntPtr) := z_Normal3bv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Normal3d_ovr0(nx: real; ny: real; nz: real);
external 'opengl32.dll' name 'glNormal3d';
public static z_Normal3d_ovr0 := _z_Normal3d_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3d(nx: real; ny: real; nz: real) := z_Normal3d_ovr0(nx, ny, nz);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Normal3dv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of real);
external 'opengl32.dll' name 'glNormal3dv';
public static z_Normal3dv_ovr0 := _z_Normal3dv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3dv(v: array of real) := z_Normal3dv_ovr0(v);
private static procedure _z_Normal3dv_ovr1(var v: real);
external 'opengl32.dll' name 'glNormal3dv';
public static z_Normal3dv_ovr1 := _z_Normal3dv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3dv(var v: real) := z_Normal3dv_ovr1(v);
private static procedure _z_Normal3dv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glNormal3dv';
public static z_Normal3dv_ovr2 := _z_Normal3dv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3dv(v: IntPtr) := z_Normal3dv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Normal3f_ovr0(nx: single; ny: single; nz: single);
external 'opengl32.dll' name 'glNormal3f';
public static z_Normal3f_ovr0 := _z_Normal3f_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3f(nx: single; ny: single; nz: single) := z_Normal3f_ovr0(nx, ny, nz);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Normal3fv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of single);
external 'opengl32.dll' name 'glNormal3fv';
public static z_Normal3fv_ovr0 := _z_Normal3fv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3fv(v: array of single) := z_Normal3fv_ovr0(v);
private static procedure _z_Normal3fv_ovr1(var v: single);
external 'opengl32.dll' name 'glNormal3fv';
public static z_Normal3fv_ovr1 := _z_Normal3fv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3fv(var v: single) := z_Normal3fv_ovr1(v);
private static procedure _z_Normal3fv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glNormal3fv';
public static z_Normal3fv_ovr2 := _z_Normal3fv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3fv(v: IntPtr) := z_Normal3fv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Normal3i_ovr0(nx: Int32; ny: Int32; nz: Int32);
external 'opengl32.dll' name 'glNormal3i';
public static z_Normal3i_ovr0 := _z_Normal3i_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3i(nx: Int32; ny: Int32; nz: Int32) := z_Normal3i_ovr0(nx, ny, nz);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Normal3iv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Int32);
external 'opengl32.dll' name 'glNormal3iv';
public static z_Normal3iv_ovr0 := _z_Normal3iv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3iv(v: array of Int32) := z_Normal3iv_ovr0(v);
private static procedure _z_Normal3iv_ovr1(var v: Int32);
external 'opengl32.dll' name 'glNormal3iv';
public static z_Normal3iv_ovr1 := _z_Normal3iv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3iv(var v: Int32) := z_Normal3iv_ovr1(v);
private static procedure _z_Normal3iv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glNormal3iv';
public static z_Normal3iv_ovr2 := _z_Normal3iv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3iv(v: IntPtr) := z_Normal3iv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Normal3s_ovr0(nx: Int16; ny: Int16; nz: Int16);
external 'opengl32.dll' name 'glNormal3s';
public static z_Normal3s_ovr0 := _z_Normal3s_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3s(nx: Int16; ny: Int16; nz: Int16) := z_Normal3s_ovr0(nx, ny, nz);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Normal3sv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Int16);
external 'opengl32.dll' name 'glNormal3sv';
public static z_Normal3sv_ovr0 := _z_Normal3sv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3sv(v: array of Int16) := z_Normal3sv_ovr0(v);
private static procedure _z_Normal3sv_ovr1(var v: Int16);
external 'opengl32.dll' name 'glNormal3sv';
public static z_Normal3sv_ovr1 := _z_Normal3sv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3sv(var v: Int16) := z_Normal3sv_ovr1(v);
private static procedure _z_Normal3sv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glNormal3sv';
public static z_Normal3sv_ovr2 := _z_Normal3sv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3sv(v: IntPtr) := z_Normal3sv_ovr2(v);
// added in gl1.1, deprecated in gl3.2
private static procedure _z_NormalPointer_ovr0(&type: NormalPointerType; stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glNormalPointer';
public static z_NormalPointer_ovr0 := _z_NormalPointer_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalPointer(&type: NormalPointerType; stride: Int32; pointer: IntPtr) := z_NormalPointer_ovr0(&type, stride, pointer);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Ortho_ovr0(left: real; right: real; bottom: real; top: real; zNear: real; zFar: real);
external 'opengl32.dll' name 'glOrtho';
public static z_Ortho_ovr0 := _z_Ortho_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Ortho(left: real; right: real; bottom: real; top: real; zNear: real; zFar: real) := z_Ortho_ovr0(left, right, bottom, top, zNear, zFar);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_PassThrough_ovr0(token: single);
external 'opengl32.dll' name 'glPassThrough';
public static z_PassThrough_ovr0 := _z_PassThrough_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PassThrough(token: single) := z_PassThrough_ovr0(token);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_PixelMapfv_ovr0(map: PixelMap; mapsize: Int32; [MarshalAs(UnmanagedType.LPArray)] values: array of single);
external 'opengl32.dll' name 'glPixelMapfv';
public static z_PixelMapfv_ovr0 := _z_PixelMapfv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelMapfv(map: PixelMap; mapsize: Int32; values: array of single) := z_PixelMapfv_ovr0(map, mapsize, values);
private static procedure _z_PixelMapfv_ovr1(map: PixelMap; mapsize: Int32; var values: single);
external 'opengl32.dll' name 'glPixelMapfv';
public static z_PixelMapfv_ovr1 := _z_PixelMapfv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelMapfv(map: PixelMap; mapsize: Int32; var values: single) := z_PixelMapfv_ovr1(map, mapsize, values);
private static procedure _z_PixelMapfv_ovr2(map: PixelMap; mapsize: Int32; values: IntPtr);
external 'opengl32.dll' name 'glPixelMapfv';
public static z_PixelMapfv_ovr2 := _z_PixelMapfv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelMapfv(map: PixelMap; mapsize: Int32; values: IntPtr) := z_PixelMapfv_ovr2(map, mapsize, values);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_PixelMapuiv_ovr0(map: PixelMap; mapsize: Int32; [MarshalAs(UnmanagedType.LPArray)] values: array of UInt32);
external 'opengl32.dll' name 'glPixelMapuiv';
public static z_PixelMapuiv_ovr0 := _z_PixelMapuiv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelMapuiv(map: PixelMap; mapsize: Int32; values: array of UInt32) := z_PixelMapuiv_ovr0(map, mapsize, values);
private static procedure _z_PixelMapuiv_ovr1(map: PixelMap; mapsize: Int32; var values: UInt32);
external 'opengl32.dll' name 'glPixelMapuiv';
public static z_PixelMapuiv_ovr1 := _z_PixelMapuiv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelMapuiv(map: PixelMap; mapsize: Int32; var values: UInt32) := z_PixelMapuiv_ovr1(map, mapsize, values);
private static procedure _z_PixelMapuiv_ovr2(map: PixelMap; mapsize: Int32; values: IntPtr);
external 'opengl32.dll' name 'glPixelMapuiv';
public static z_PixelMapuiv_ovr2 := _z_PixelMapuiv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelMapuiv(map: PixelMap; mapsize: Int32; values: IntPtr) := z_PixelMapuiv_ovr2(map, mapsize, values);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_PixelMapusv_ovr0(map: PixelMap; mapsize: Int32; [MarshalAs(UnmanagedType.LPArray)] values: array of UInt16);
external 'opengl32.dll' name 'glPixelMapusv';
public static z_PixelMapusv_ovr0 := _z_PixelMapusv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelMapusv(map: PixelMap; mapsize: Int32; values: array of UInt16) := z_PixelMapusv_ovr0(map, mapsize, values);
private static procedure _z_PixelMapusv_ovr1(map: PixelMap; mapsize: Int32; var values: UInt16);
external 'opengl32.dll' name 'glPixelMapusv';
public static z_PixelMapusv_ovr1 := _z_PixelMapusv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelMapusv(map: PixelMap; mapsize: Int32; var values: UInt16) := z_PixelMapusv_ovr1(map, mapsize, values);
private static procedure _z_PixelMapusv_ovr2(map: PixelMap; mapsize: Int32; values: IntPtr);
external 'opengl32.dll' name 'glPixelMapusv';
public static z_PixelMapusv_ovr2 := _z_PixelMapusv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelMapusv(map: PixelMap; mapsize: Int32; values: IntPtr) := z_PixelMapusv_ovr2(map, mapsize, values);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_PixelTransferf_ovr0(pname: PixelTransferParameter; param: single);
external 'opengl32.dll' name 'glPixelTransferf';
public static z_PixelTransferf_ovr0 := _z_PixelTransferf_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTransferf(pname: PixelTransferParameter; param: single) := z_PixelTransferf_ovr0(pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_PixelTransferi_ovr0(pname: PixelTransferParameter; param: Int32);
external 'opengl32.dll' name 'glPixelTransferi';
public static z_PixelTransferi_ovr0 := _z_PixelTransferi_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTransferi(pname: PixelTransferParameter; param: Int32) := z_PixelTransferi_ovr0(pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_PixelZoom_ovr0(xfactor: single; yfactor: single);
external 'opengl32.dll' name 'glPixelZoom';
public static z_PixelZoom_ovr0 := _z_PixelZoom_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelZoom(xfactor: single; yfactor: single) := z_PixelZoom_ovr0(xfactor, yfactor);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_PolygonStipple_ovr0([MarshalAs(UnmanagedType.LPArray)] mask: array of Byte);
external 'opengl32.dll' name 'glPolygonStipple';
public static z_PolygonStipple_ovr0 := _z_PolygonStipple_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PolygonStipple(mask: array of Byte) := z_PolygonStipple_ovr0(mask);
private static procedure _z_PolygonStipple_ovr1(var mask: Byte);
external 'opengl32.dll' name 'glPolygonStipple';
public static z_PolygonStipple_ovr1 := _z_PolygonStipple_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PolygonStipple(var mask: Byte) := z_PolygonStipple_ovr1(mask);
private static procedure _z_PolygonStipple_ovr2(mask: IntPtr);
external 'opengl32.dll' name 'glPolygonStipple';
public static z_PolygonStipple_ovr2 := _z_PolygonStipple_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PolygonStipple(mask: IntPtr) := z_PolygonStipple_ovr2(mask);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_PopAttrib_ovr0;
external 'opengl32.dll' name 'glPopAttrib';
public static z_PopAttrib_ovr0 := _z_PopAttrib_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PopAttrib := z_PopAttrib_ovr0;
// added in gl1.1, deprecated in gl3.2
private static procedure _z_PopClientAttrib_ovr0;
external 'opengl32.dll' name 'glPopClientAttrib';
public static z_PopClientAttrib_ovr0 := _z_PopClientAttrib_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PopClientAttrib := z_PopClientAttrib_ovr0;
// added in gl1.0, deprecated in gl3.2
private static procedure _z_PopMatrix_ovr0;
external 'opengl32.dll' name 'glPopMatrix';
public static z_PopMatrix_ovr0 := _z_PopMatrix_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PopMatrix := z_PopMatrix_ovr0;
// added in gl1.0, deprecated in gl3.2
private static procedure _z_PopName_ovr0;
external 'opengl32.dll' name 'glPopName';
public static z_PopName_ovr0 := _z_PopName_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PopName := z_PopName_ovr0;
// added in gl1.1, deprecated in gl3.2
private static procedure _z_PrioritizeTextures_ovr0(n: Int32; [MarshalAs(UnmanagedType.LPArray)] textures: array of UInt32; [MarshalAs(UnmanagedType.LPArray)] priorities: array of single);
external 'opengl32.dll' name 'glPrioritizeTextures';
public static z_PrioritizeTextures_ovr0 := _z_PrioritizeTextures_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTextures(n: Int32; textures: array of UInt32; priorities: array of single) := z_PrioritizeTextures_ovr0(n, textures, priorities);
private static procedure _z_PrioritizeTextures_ovr1(n: Int32; [MarshalAs(UnmanagedType.LPArray)] textures: array of UInt32; var priorities: single);
external 'opengl32.dll' name 'glPrioritizeTextures';
public static z_PrioritizeTextures_ovr1 := _z_PrioritizeTextures_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTextures(n: Int32; textures: array of UInt32; var priorities: single) := z_PrioritizeTextures_ovr1(n, textures, priorities);
private static procedure _z_PrioritizeTextures_ovr2(n: Int32; [MarshalAs(UnmanagedType.LPArray)] textures: array of UInt32; priorities: IntPtr);
external 'opengl32.dll' name 'glPrioritizeTextures';
public static z_PrioritizeTextures_ovr2 := _z_PrioritizeTextures_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTextures(n: Int32; textures: array of UInt32; priorities: IntPtr) := z_PrioritizeTextures_ovr2(n, textures, priorities);
private static procedure _z_PrioritizeTextures_ovr3(n: Int32; var textures: UInt32; [MarshalAs(UnmanagedType.LPArray)] priorities: array of single);
external 'opengl32.dll' name 'glPrioritizeTextures';
public static z_PrioritizeTextures_ovr3 := _z_PrioritizeTextures_ovr3;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTextures(n: Int32; var textures: UInt32; priorities: array of single) := z_PrioritizeTextures_ovr3(n, textures, priorities);
private static procedure _z_PrioritizeTextures_ovr4(n: Int32; var textures: UInt32; var priorities: single);
external 'opengl32.dll' name 'glPrioritizeTextures';
public static z_PrioritizeTextures_ovr4 := _z_PrioritizeTextures_ovr4;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTextures(n: Int32; var textures: UInt32; var priorities: single) := z_PrioritizeTextures_ovr4(n, textures, priorities);
private static procedure _z_PrioritizeTextures_ovr5(n: Int32; var textures: UInt32; priorities: IntPtr);
external 'opengl32.dll' name 'glPrioritizeTextures';
public static z_PrioritizeTextures_ovr5 := _z_PrioritizeTextures_ovr5;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTextures(n: Int32; var textures: UInt32; priorities: IntPtr) := z_PrioritizeTextures_ovr5(n, textures, priorities);
private static procedure _z_PrioritizeTextures_ovr6(n: Int32; textures: IntPtr; [MarshalAs(UnmanagedType.LPArray)] priorities: array of single);
external 'opengl32.dll' name 'glPrioritizeTextures';
public static z_PrioritizeTextures_ovr6 := _z_PrioritizeTextures_ovr6;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTextures(n: Int32; textures: IntPtr; priorities: array of single) := z_PrioritizeTextures_ovr6(n, textures, priorities);
private static procedure _z_PrioritizeTextures_ovr7(n: Int32; textures: IntPtr; var priorities: single);
external 'opengl32.dll' name 'glPrioritizeTextures';
public static z_PrioritizeTextures_ovr7 := _z_PrioritizeTextures_ovr7;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTextures(n: Int32; textures: IntPtr; var priorities: single) := z_PrioritizeTextures_ovr7(n, textures, priorities);
private static procedure _z_PrioritizeTextures_ovr8(n: Int32; textures: IntPtr; priorities: IntPtr);
external 'opengl32.dll' name 'glPrioritizeTextures';
public static z_PrioritizeTextures_ovr8 := _z_PrioritizeTextures_ovr8;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTextures(n: Int32; textures: IntPtr; priorities: IntPtr) := z_PrioritizeTextures_ovr8(n, textures, priorities);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_PushAttrib_ovr0(mask: AttribMask);
external 'opengl32.dll' name 'glPushAttrib';
public static z_PushAttrib_ovr0 := _z_PushAttrib_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PushAttrib(mask: AttribMask) := z_PushAttrib_ovr0(mask);
// added in gl1.1, deprecated in gl3.2
private static procedure _z_PushClientAttrib_ovr0(mask: ClientAttribMask);
external 'opengl32.dll' name 'glPushClientAttrib';
public static z_PushClientAttrib_ovr0 := _z_PushClientAttrib_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PushClientAttrib(mask: ClientAttribMask) := z_PushClientAttrib_ovr0(mask);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_PushMatrix_ovr0;
external 'opengl32.dll' name 'glPushMatrix';
public static z_PushMatrix_ovr0 := _z_PushMatrix_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PushMatrix := z_PushMatrix_ovr0;
// added in gl1.0, deprecated in gl3.2
private static procedure _z_PushName_ovr0(name: UInt32);
external 'opengl32.dll' name 'glPushName';
public static z_PushName_ovr0 := _z_PushName_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PushName(name: UInt32) := z_PushName_ovr0(name);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_RasterPos2d_ovr0(x: real; y: real);
external 'opengl32.dll' name 'glRasterPos2d';
public static z_RasterPos2d_ovr0 := _z_RasterPos2d_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2d(x: real; y: real) := z_RasterPos2d_ovr0(x, y);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_RasterPos2dv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of real);
external 'opengl32.dll' name 'glRasterPos2dv';
public static z_RasterPos2dv_ovr0 := _z_RasterPos2dv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2dv(v: array of real) := z_RasterPos2dv_ovr0(v);
private static procedure _z_RasterPos2dv_ovr1(var v: real);
external 'opengl32.dll' name 'glRasterPos2dv';
public static z_RasterPos2dv_ovr1 := _z_RasterPos2dv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2dv(var v: real) := z_RasterPos2dv_ovr1(v);
private static procedure _z_RasterPos2dv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos2dv';
public static z_RasterPos2dv_ovr2 := _z_RasterPos2dv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2dv(v: IntPtr) := z_RasterPos2dv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_RasterPos2f_ovr0(x: single; y: single);
external 'opengl32.dll' name 'glRasterPos2f';
public static z_RasterPos2f_ovr0 := _z_RasterPos2f_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2f(x: single; y: single) := z_RasterPos2f_ovr0(x, y);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_RasterPos2fv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of single);
external 'opengl32.dll' name 'glRasterPos2fv';
public static z_RasterPos2fv_ovr0 := _z_RasterPos2fv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2fv(v: array of single) := z_RasterPos2fv_ovr0(v);
private static procedure _z_RasterPos2fv_ovr1(var v: single);
external 'opengl32.dll' name 'glRasterPos2fv';
public static z_RasterPos2fv_ovr1 := _z_RasterPos2fv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2fv(var v: single) := z_RasterPos2fv_ovr1(v);
private static procedure _z_RasterPos2fv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos2fv';
public static z_RasterPos2fv_ovr2 := _z_RasterPos2fv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2fv(v: IntPtr) := z_RasterPos2fv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_RasterPos2i_ovr0(x: Int32; y: Int32);
external 'opengl32.dll' name 'glRasterPos2i';
public static z_RasterPos2i_ovr0 := _z_RasterPos2i_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2i(x: Int32; y: Int32) := z_RasterPos2i_ovr0(x, y);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_RasterPos2iv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Int32);
external 'opengl32.dll' name 'glRasterPos2iv';
public static z_RasterPos2iv_ovr0 := _z_RasterPos2iv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2iv(v: array of Int32) := z_RasterPos2iv_ovr0(v);
private static procedure _z_RasterPos2iv_ovr1(var v: Int32);
external 'opengl32.dll' name 'glRasterPos2iv';
public static z_RasterPos2iv_ovr1 := _z_RasterPos2iv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2iv(var v: Int32) := z_RasterPos2iv_ovr1(v);
private static procedure _z_RasterPos2iv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos2iv';
public static z_RasterPos2iv_ovr2 := _z_RasterPos2iv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2iv(v: IntPtr) := z_RasterPos2iv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_RasterPos2s_ovr0(x: Int16; y: Int16);
external 'opengl32.dll' name 'glRasterPos2s';
public static z_RasterPos2s_ovr0 := _z_RasterPos2s_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2s(x: Int16; y: Int16) := z_RasterPos2s_ovr0(x, y);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_RasterPos2sv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Int16);
external 'opengl32.dll' name 'glRasterPos2sv';
public static z_RasterPos2sv_ovr0 := _z_RasterPos2sv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2sv(v: array of Int16) := z_RasterPos2sv_ovr0(v);
private static procedure _z_RasterPos2sv_ovr1(var v: Int16);
external 'opengl32.dll' name 'glRasterPos2sv';
public static z_RasterPos2sv_ovr1 := _z_RasterPos2sv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2sv(var v: Int16) := z_RasterPos2sv_ovr1(v);
private static procedure _z_RasterPos2sv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos2sv';
public static z_RasterPos2sv_ovr2 := _z_RasterPos2sv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2sv(v: IntPtr) := z_RasterPos2sv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_RasterPos3d_ovr0(x: real; y: real; z: real);
external 'opengl32.dll' name 'glRasterPos3d';
public static z_RasterPos3d_ovr0 := _z_RasterPos3d_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3d(x: real; y: real; z: real) := z_RasterPos3d_ovr0(x, y, z);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_RasterPos3dv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of real);
external 'opengl32.dll' name 'glRasterPos3dv';
public static z_RasterPos3dv_ovr0 := _z_RasterPos3dv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3dv(v: array of real) := z_RasterPos3dv_ovr0(v);
private static procedure _z_RasterPos3dv_ovr1(var v: real);
external 'opengl32.dll' name 'glRasterPos3dv';
public static z_RasterPos3dv_ovr1 := _z_RasterPos3dv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3dv(var v: real) := z_RasterPos3dv_ovr1(v);
private static procedure _z_RasterPos3dv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos3dv';
public static z_RasterPos3dv_ovr2 := _z_RasterPos3dv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3dv(v: IntPtr) := z_RasterPos3dv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_RasterPos3f_ovr0(x: single; y: single; z: single);
external 'opengl32.dll' name 'glRasterPos3f';
public static z_RasterPos3f_ovr0 := _z_RasterPos3f_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3f(x: single; y: single; z: single) := z_RasterPos3f_ovr0(x, y, z);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_RasterPos3fv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of single);
external 'opengl32.dll' name 'glRasterPos3fv';
public static z_RasterPos3fv_ovr0 := _z_RasterPos3fv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3fv(v: array of single) := z_RasterPos3fv_ovr0(v);
private static procedure _z_RasterPos3fv_ovr1(var v: single);
external 'opengl32.dll' name 'glRasterPos3fv';
public static z_RasterPos3fv_ovr1 := _z_RasterPos3fv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3fv(var v: single) := z_RasterPos3fv_ovr1(v);
private static procedure _z_RasterPos3fv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos3fv';
public static z_RasterPos3fv_ovr2 := _z_RasterPos3fv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3fv(v: IntPtr) := z_RasterPos3fv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_RasterPos3i_ovr0(x: Int32; y: Int32; z: Int32);
external 'opengl32.dll' name 'glRasterPos3i';
public static z_RasterPos3i_ovr0 := _z_RasterPos3i_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3i(x: Int32; y: Int32; z: Int32) := z_RasterPos3i_ovr0(x, y, z);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_RasterPos3iv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Int32);
external 'opengl32.dll' name 'glRasterPos3iv';
public static z_RasterPos3iv_ovr0 := _z_RasterPos3iv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3iv(v: array of Int32) := z_RasterPos3iv_ovr0(v);
private static procedure _z_RasterPos3iv_ovr1(var v: Int32);
external 'opengl32.dll' name 'glRasterPos3iv';
public static z_RasterPos3iv_ovr1 := _z_RasterPos3iv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3iv(var v: Int32) := z_RasterPos3iv_ovr1(v);
private static procedure _z_RasterPos3iv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos3iv';
public static z_RasterPos3iv_ovr2 := _z_RasterPos3iv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3iv(v: IntPtr) := z_RasterPos3iv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_RasterPos3s_ovr0(x: Int16; y: Int16; z: Int16);
external 'opengl32.dll' name 'glRasterPos3s';
public static z_RasterPos3s_ovr0 := _z_RasterPos3s_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3s(x: Int16; y: Int16; z: Int16) := z_RasterPos3s_ovr0(x, y, z);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_RasterPos3sv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Int16);
external 'opengl32.dll' name 'glRasterPos3sv';
public static z_RasterPos3sv_ovr0 := _z_RasterPos3sv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3sv(v: array of Int16) := z_RasterPos3sv_ovr0(v);
private static procedure _z_RasterPos3sv_ovr1(var v: Int16);
external 'opengl32.dll' name 'glRasterPos3sv';
public static z_RasterPos3sv_ovr1 := _z_RasterPos3sv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3sv(var v: Int16) := z_RasterPos3sv_ovr1(v);
private static procedure _z_RasterPos3sv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos3sv';
public static z_RasterPos3sv_ovr2 := _z_RasterPos3sv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3sv(v: IntPtr) := z_RasterPos3sv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_RasterPos4d_ovr0(x: real; y: real; z: real; w: real);
external 'opengl32.dll' name 'glRasterPos4d';
public static z_RasterPos4d_ovr0 := _z_RasterPos4d_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4d(x: real; y: real; z: real; w: real) := z_RasterPos4d_ovr0(x, y, z, w);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_RasterPos4dv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of real);
external 'opengl32.dll' name 'glRasterPos4dv';
public static z_RasterPos4dv_ovr0 := _z_RasterPos4dv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4dv(v: array of real) := z_RasterPos4dv_ovr0(v);
private static procedure _z_RasterPos4dv_ovr1(var v: real);
external 'opengl32.dll' name 'glRasterPos4dv';
public static z_RasterPos4dv_ovr1 := _z_RasterPos4dv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4dv(var v: real) := z_RasterPos4dv_ovr1(v);
private static procedure _z_RasterPos4dv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos4dv';
public static z_RasterPos4dv_ovr2 := _z_RasterPos4dv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4dv(v: IntPtr) := z_RasterPos4dv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_RasterPos4f_ovr0(x: single; y: single; z: single; w: single);
external 'opengl32.dll' name 'glRasterPos4f';
public static z_RasterPos4f_ovr0 := _z_RasterPos4f_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4f(x: single; y: single; z: single; w: single) := z_RasterPos4f_ovr0(x, y, z, w);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_RasterPos4fv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of single);
external 'opengl32.dll' name 'glRasterPos4fv';
public static z_RasterPos4fv_ovr0 := _z_RasterPos4fv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4fv(v: array of single) := z_RasterPos4fv_ovr0(v);
private static procedure _z_RasterPos4fv_ovr1(var v: single);
external 'opengl32.dll' name 'glRasterPos4fv';
public static z_RasterPos4fv_ovr1 := _z_RasterPos4fv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4fv(var v: single) := z_RasterPos4fv_ovr1(v);
private static procedure _z_RasterPos4fv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos4fv';
public static z_RasterPos4fv_ovr2 := _z_RasterPos4fv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4fv(v: IntPtr) := z_RasterPos4fv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_RasterPos4i_ovr0(x: Int32; y: Int32; z: Int32; w: Int32);
external 'opengl32.dll' name 'glRasterPos4i';
public static z_RasterPos4i_ovr0 := _z_RasterPos4i_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4i(x: Int32; y: Int32; z: Int32; w: Int32) := z_RasterPos4i_ovr0(x, y, z, w);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_RasterPos4iv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Int32);
external 'opengl32.dll' name 'glRasterPos4iv';
public static z_RasterPos4iv_ovr0 := _z_RasterPos4iv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4iv(v: array of Int32) := z_RasterPos4iv_ovr0(v);
private static procedure _z_RasterPos4iv_ovr1(var v: Int32);
external 'opengl32.dll' name 'glRasterPos4iv';
public static z_RasterPos4iv_ovr1 := _z_RasterPos4iv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4iv(var v: Int32) := z_RasterPos4iv_ovr1(v);
private static procedure _z_RasterPos4iv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos4iv';
public static z_RasterPos4iv_ovr2 := _z_RasterPos4iv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4iv(v: IntPtr) := z_RasterPos4iv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_RasterPos4s_ovr0(x: Int16; y: Int16; z: Int16; w: Int16);
external 'opengl32.dll' name 'glRasterPos4s';
public static z_RasterPos4s_ovr0 := _z_RasterPos4s_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4s(x: Int16; y: Int16; z: Int16; w: Int16) := z_RasterPos4s_ovr0(x, y, z, w);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_RasterPos4sv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Int16);
external 'opengl32.dll' name 'glRasterPos4sv';
public static z_RasterPos4sv_ovr0 := _z_RasterPos4sv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4sv(v: array of Int16) := z_RasterPos4sv_ovr0(v);
private static procedure _z_RasterPos4sv_ovr1(var v: Int16);
external 'opengl32.dll' name 'glRasterPos4sv';
public static z_RasterPos4sv_ovr1 := _z_RasterPos4sv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4sv(var v: Int16) := z_RasterPos4sv_ovr1(v);
private static procedure _z_RasterPos4sv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glRasterPos4sv';
public static z_RasterPos4sv_ovr2 := _z_RasterPos4sv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4sv(v: IntPtr) := z_RasterPos4sv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Rectd_ovr0(x1: real; y1: real; x2: real; y2: real);
external 'opengl32.dll' name 'glRectd';
public static z_Rectd_ovr0 := _z_Rectd_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectd(x1: real; y1: real; x2: real; y2: real) := z_Rectd_ovr0(x1, y1, x2, y2);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Rectdv_ovr0([MarshalAs(UnmanagedType.LPArray)] v1: array of real; [MarshalAs(UnmanagedType.LPArray)] v2: array of real);
external 'opengl32.dll' name 'glRectdv';
public static z_Rectdv_ovr0 := _z_Rectdv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectdv(v1: array of real; v2: array of real) := z_Rectdv_ovr0(v1, v2);
private static procedure _z_Rectdv_ovr1([MarshalAs(UnmanagedType.LPArray)] v1: array of real; var v2: real);
external 'opengl32.dll' name 'glRectdv';
public static z_Rectdv_ovr1 := _z_Rectdv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectdv(v1: array of real; var v2: real) := z_Rectdv_ovr1(v1, v2);
private static procedure _z_Rectdv_ovr2([MarshalAs(UnmanagedType.LPArray)] v1: array of real; v2: IntPtr);
external 'opengl32.dll' name 'glRectdv';
public static z_Rectdv_ovr2 := _z_Rectdv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectdv(v1: array of real; v2: IntPtr) := z_Rectdv_ovr2(v1, v2);
private static procedure _z_Rectdv_ovr3(var v1: real; [MarshalAs(UnmanagedType.LPArray)] v2: array of real);
external 'opengl32.dll' name 'glRectdv';
public static z_Rectdv_ovr3 := _z_Rectdv_ovr3;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectdv(var v1: real; v2: array of real) := z_Rectdv_ovr3(v1, v2);
private static procedure _z_Rectdv_ovr4(var v1: real; var v2: real);
external 'opengl32.dll' name 'glRectdv';
public static z_Rectdv_ovr4 := _z_Rectdv_ovr4;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectdv(var v1: real; var v2: real) := z_Rectdv_ovr4(v1, v2);
private static procedure _z_Rectdv_ovr5(var v1: real; v2: IntPtr);
external 'opengl32.dll' name 'glRectdv';
public static z_Rectdv_ovr5 := _z_Rectdv_ovr5;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectdv(var v1: real; v2: IntPtr) := z_Rectdv_ovr5(v1, v2);
private static procedure _z_Rectdv_ovr6(v1: IntPtr; [MarshalAs(UnmanagedType.LPArray)] v2: array of real);
external 'opengl32.dll' name 'glRectdv';
public static z_Rectdv_ovr6 := _z_Rectdv_ovr6;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectdv(v1: IntPtr; v2: array of real) := z_Rectdv_ovr6(v1, v2);
private static procedure _z_Rectdv_ovr7(v1: IntPtr; var v2: real);
external 'opengl32.dll' name 'glRectdv';
public static z_Rectdv_ovr7 := _z_Rectdv_ovr7;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectdv(v1: IntPtr; var v2: real) := z_Rectdv_ovr7(v1, v2);
private static procedure _z_Rectdv_ovr8(v1: IntPtr; v2: IntPtr);
external 'opengl32.dll' name 'glRectdv';
public static z_Rectdv_ovr8 := _z_Rectdv_ovr8;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectdv(v1: IntPtr; v2: IntPtr) := z_Rectdv_ovr8(v1, v2);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Rectf_ovr0(x1: single; y1: single; x2: single; y2: single);
external 'opengl32.dll' name 'glRectf';
public static z_Rectf_ovr0 := _z_Rectf_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectf(x1: single; y1: single; x2: single; y2: single) := z_Rectf_ovr0(x1, y1, x2, y2);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Rectfv_ovr0([MarshalAs(UnmanagedType.LPArray)] v1: array of single; [MarshalAs(UnmanagedType.LPArray)] v2: array of single);
external 'opengl32.dll' name 'glRectfv';
public static z_Rectfv_ovr0 := _z_Rectfv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectfv(v1: array of single; v2: array of single) := z_Rectfv_ovr0(v1, v2);
private static procedure _z_Rectfv_ovr1([MarshalAs(UnmanagedType.LPArray)] v1: array of single; var v2: single);
external 'opengl32.dll' name 'glRectfv';
public static z_Rectfv_ovr1 := _z_Rectfv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectfv(v1: array of single; var v2: single) := z_Rectfv_ovr1(v1, v2);
private static procedure _z_Rectfv_ovr2([MarshalAs(UnmanagedType.LPArray)] v1: array of single; v2: IntPtr);
external 'opengl32.dll' name 'glRectfv';
public static z_Rectfv_ovr2 := _z_Rectfv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectfv(v1: array of single; v2: IntPtr) := z_Rectfv_ovr2(v1, v2);
private static procedure _z_Rectfv_ovr3(var v1: single; [MarshalAs(UnmanagedType.LPArray)] v2: array of single);
external 'opengl32.dll' name 'glRectfv';
public static z_Rectfv_ovr3 := _z_Rectfv_ovr3;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectfv(var v1: single; v2: array of single) := z_Rectfv_ovr3(v1, v2);
private static procedure _z_Rectfv_ovr4(var v1: single; var v2: single);
external 'opengl32.dll' name 'glRectfv';
public static z_Rectfv_ovr4 := _z_Rectfv_ovr4;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectfv(var v1: single; var v2: single) := z_Rectfv_ovr4(v1, v2);
private static procedure _z_Rectfv_ovr5(var v1: single; v2: IntPtr);
external 'opengl32.dll' name 'glRectfv';
public static z_Rectfv_ovr5 := _z_Rectfv_ovr5;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectfv(var v1: single; v2: IntPtr) := z_Rectfv_ovr5(v1, v2);
private static procedure _z_Rectfv_ovr6(v1: IntPtr; [MarshalAs(UnmanagedType.LPArray)] v2: array of single);
external 'opengl32.dll' name 'glRectfv';
public static z_Rectfv_ovr6 := _z_Rectfv_ovr6;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectfv(v1: IntPtr; v2: array of single) := z_Rectfv_ovr6(v1, v2);
private static procedure _z_Rectfv_ovr7(v1: IntPtr; var v2: single);
external 'opengl32.dll' name 'glRectfv';
public static z_Rectfv_ovr7 := _z_Rectfv_ovr7;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectfv(v1: IntPtr; var v2: single) := z_Rectfv_ovr7(v1, v2);
private static procedure _z_Rectfv_ovr8(v1: IntPtr; v2: IntPtr);
external 'opengl32.dll' name 'glRectfv';
public static z_Rectfv_ovr8 := _z_Rectfv_ovr8;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectfv(v1: IntPtr; v2: IntPtr) := z_Rectfv_ovr8(v1, v2);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Recti_ovr0(x1: Int32; y1: Int32; x2: Int32; y2: Int32);
external 'opengl32.dll' name 'glRecti';
public static z_Recti_ovr0 := _z_Recti_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Recti(x1: Int32; y1: Int32; x2: Int32; y2: Int32) := z_Recti_ovr0(x1, y1, x2, y2);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Rectiv_ovr0([MarshalAs(UnmanagedType.LPArray)] v1: array of Int32; [MarshalAs(UnmanagedType.LPArray)] v2: array of Int32);
external 'opengl32.dll' name 'glRectiv';
public static z_Rectiv_ovr0 := _z_Rectiv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectiv(v1: array of Int32; v2: array of Int32) := z_Rectiv_ovr0(v1, v2);
private static procedure _z_Rectiv_ovr1([MarshalAs(UnmanagedType.LPArray)] v1: array of Int32; var v2: Int32);
external 'opengl32.dll' name 'glRectiv';
public static z_Rectiv_ovr1 := _z_Rectiv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectiv(v1: array of Int32; var v2: Int32) := z_Rectiv_ovr1(v1, v2);
private static procedure _z_Rectiv_ovr2([MarshalAs(UnmanagedType.LPArray)] v1: array of Int32; v2: IntPtr);
external 'opengl32.dll' name 'glRectiv';
public static z_Rectiv_ovr2 := _z_Rectiv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectiv(v1: array of Int32; v2: IntPtr) := z_Rectiv_ovr2(v1, v2);
private static procedure _z_Rectiv_ovr3(var v1: Int32; [MarshalAs(UnmanagedType.LPArray)] v2: array of Int32);
external 'opengl32.dll' name 'glRectiv';
public static z_Rectiv_ovr3 := _z_Rectiv_ovr3;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectiv(var v1: Int32; v2: array of Int32) := z_Rectiv_ovr3(v1, v2);
private static procedure _z_Rectiv_ovr4(var v1: Int32; var v2: Int32);
external 'opengl32.dll' name 'glRectiv';
public static z_Rectiv_ovr4 := _z_Rectiv_ovr4;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectiv(var v1: Int32; var v2: Int32) := z_Rectiv_ovr4(v1, v2);
private static procedure _z_Rectiv_ovr5(var v1: Int32; v2: IntPtr);
external 'opengl32.dll' name 'glRectiv';
public static z_Rectiv_ovr5 := _z_Rectiv_ovr5;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectiv(var v1: Int32; v2: IntPtr) := z_Rectiv_ovr5(v1, v2);
private static procedure _z_Rectiv_ovr6(v1: IntPtr; [MarshalAs(UnmanagedType.LPArray)] v2: array of Int32);
external 'opengl32.dll' name 'glRectiv';
public static z_Rectiv_ovr6 := _z_Rectiv_ovr6;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectiv(v1: IntPtr; v2: array of Int32) := z_Rectiv_ovr6(v1, v2);
private static procedure _z_Rectiv_ovr7(v1: IntPtr; var v2: Int32);
external 'opengl32.dll' name 'glRectiv';
public static z_Rectiv_ovr7 := _z_Rectiv_ovr7;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectiv(v1: IntPtr; var v2: Int32) := z_Rectiv_ovr7(v1, v2);
private static procedure _z_Rectiv_ovr8(v1: IntPtr; v2: IntPtr);
external 'opengl32.dll' name 'glRectiv';
public static z_Rectiv_ovr8 := _z_Rectiv_ovr8;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectiv(v1: IntPtr; v2: IntPtr) := z_Rectiv_ovr8(v1, v2);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Rects_ovr0(x1: Int16; y1: Int16; x2: Int16; y2: Int16);
external 'opengl32.dll' name 'glRects';
public static z_Rects_ovr0 := _z_Rects_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rects(x1: Int16; y1: Int16; x2: Int16; y2: Int16) := z_Rects_ovr0(x1, y1, x2, y2);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Rectsv_ovr0([MarshalAs(UnmanagedType.LPArray)] v1: array of Int16; [MarshalAs(UnmanagedType.LPArray)] v2: array of Int16);
external 'opengl32.dll' name 'glRectsv';
public static z_Rectsv_ovr0 := _z_Rectsv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectsv(v1: array of Int16; v2: array of Int16) := z_Rectsv_ovr0(v1, v2);
private static procedure _z_Rectsv_ovr1([MarshalAs(UnmanagedType.LPArray)] v1: array of Int16; var v2: Int16);
external 'opengl32.dll' name 'glRectsv';
public static z_Rectsv_ovr1 := _z_Rectsv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectsv(v1: array of Int16; var v2: Int16) := z_Rectsv_ovr1(v1, v2);
private static procedure _z_Rectsv_ovr2([MarshalAs(UnmanagedType.LPArray)] v1: array of Int16; v2: IntPtr);
external 'opengl32.dll' name 'glRectsv';
public static z_Rectsv_ovr2 := _z_Rectsv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectsv(v1: array of Int16; v2: IntPtr) := z_Rectsv_ovr2(v1, v2);
private static procedure _z_Rectsv_ovr3(var v1: Int16; [MarshalAs(UnmanagedType.LPArray)] v2: array of Int16);
external 'opengl32.dll' name 'glRectsv';
public static z_Rectsv_ovr3 := _z_Rectsv_ovr3;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectsv(var v1: Int16; v2: array of Int16) := z_Rectsv_ovr3(v1, v2);
private static procedure _z_Rectsv_ovr4(var v1: Int16; var v2: Int16);
external 'opengl32.dll' name 'glRectsv';
public static z_Rectsv_ovr4 := _z_Rectsv_ovr4;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectsv(var v1: Int16; var v2: Int16) := z_Rectsv_ovr4(v1, v2);
private static procedure _z_Rectsv_ovr5(var v1: Int16; v2: IntPtr);
external 'opengl32.dll' name 'glRectsv';
public static z_Rectsv_ovr5 := _z_Rectsv_ovr5;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectsv(var v1: Int16; v2: IntPtr) := z_Rectsv_ovr5(v1, v2);
private static procedure _z_Rectsv_ovr6(v1: IntPtr; [MarshalAs(UnmanagedType.LPArray)] v2: array of Int16);
external 'opengl32.dll' name 'glRectsv';
public static z_Rectsv_ovr6 := _z_Rectsv_ovr6;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectsv(v1: IntPtr; v2: array of Int16) := z_Rectsv_ovr6(v1, v2);
private static procedure _z_Rectsv_ovr7(v1: IntPtr; var v2: Int16);
external 'opengl32.dll' name 'glRectsv';
public static z_Rectsv_ovr7 := _z_Rectsv_ovr7;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectsv(v1: IntPtr; var v2: Int16) := z_Rectsv_ovr7(v1, v2);
private static procedure _z_Rectsv_ovr8(v1: IntPtr; v2: IntPtr);
external 'opengl32.dll' name 'glRectsv';
public static z_Rectsv_ovr8 := _z_Rectsv_ovr8;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rectsv(v1: IntPtr; v2: IntPtr) := z_Rectsv_ovr8(v1, v2);
// added in gl1.0, deprecated in gl3.2
private static function _z_RenderMode_ovr0(mode: RenderingMode): Int32;
external 'opengl32.dll' name 'glRenderMode';
public static z_RenderMode_ovr0 := _z_RenderMode_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function RenderMode(mode: RenderingMode): Int32 := z_RenderMode_ovr0(mode);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Rotated_ovr0(angle: real; x: real; y: real; z: real);
external 'opengl32.dll' name 'glRotated';
public static z_Rotated_ovr0 := _z_Rotated_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rotated(angle: real; x: real; y: real; z: real) := z_Rotated_ovr0(angle, x, y, z);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Rotatef_ovr0(angle: single; x: single; y: single; z: single);
external 'opengl32.dll' name 'glRotatef';
public static z_Rotatef_ovr0 := _z_Rotatef_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Rotatef(angle: single; x: single; y: single; z: single) := z_Rotatef_ovr0(angle, x, y, z);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Scaled_ovr0(x: real; y: real; z: real);
external 'opengl32.dll' name 'glScaled';
public static z_Scaled_ovr0 := _z_Scaled_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Scaled(x: real; y: real; z: real) := z_Scaled_ovr0(x, y, z);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Scalef_ovr0(x: single; y: single; z: single);
external 'opengl32.dll' name 'glScalef';
public static z_Scalef_ovr0 := _z_Scalef_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Scalef(x: single; y: single; z: single) := z_Scalef_ovr0(x, y, z);
// added in gl1.4, deprecated in gl3.2
public z_SecondaryColor3b_adr := GetFuncAdr('glSecondaryColor3b');
public 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);
begin
z_SecondaryColor3b_ovr_0(red, green, blue);
end;
// added in gl1.4, deprecated in gl3.2
public z_SecondaryColor3bv_adr := GetFuncAdr('glSecondaryColor3bv');
public z_SecondaryColor3bv_ovr_0 := GetFuncOrNil&<procedure(var v: SByte)>(z_SecondaryColor3bv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3bv(v: array of SByte);
begin
z_SecondaryColor3bv_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3bv(var v: SByte);
begin
z_SecondaryColor3bv_ovr_0(v);
end;
public z_SecondaryColor3bv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3bv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3bv(v: IntPtr);
begin
z_SecondaryColor3bv_ovr_2(v);
end;
// added in gl1.4, deprecated in gl3.2
public z_SecondaryColor3d_adr := GetFuncAdr('glSecondaryColor3d');
public 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);
begin
z_SecondaryColor3d_ovr_0(red, green, blue);
end;
// added in gl1.4, deprecated in gl3.2
public z_SecondaryColor3dv_adr := GetFuncAdr('glSecondaryColor3dv');
public z_SecondaryColor3dv_ovr_0 := GetFuncOrNil&<procedure(var v: real)>(z_SecondaryColor3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3dv(v: array of real);
begin
z_SecondaryColor3dv_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3dv(var v: real);
begin
z_SecondaryColor3dv_ovr_0(v);
end;
public z_SecondaryColor3dv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3dv(v: IntPtr);
begin
z_SecondaryColor3dv_ovr_2(v);
end;
// added in gl1.4, deprecated in gl3.2
public z_SecondaryColor3f_adr := GetFuncAdr('glSecondaryColor3f');
public 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);
begin
z_SecondaryColor3f_ovr_0(red, green, blue);
end;
// added in gl1.4, deprecated in gl3.2
public z_SecondaryColor3fv_adr := GetFuncAdr('glSecondaryColor3fv');
public z_SecondaryColor3fv_ovr_0 := GetFuncOrNil&<procedure(var v: single)>(z_SecondaryColor3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3fv(v: array of single);
begin
z_SecondaryColor3fv_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3fv(var v: single);
begin
z_SecondaryColor3fv_ovr_0(v);
end;
public z_SecondaryColor3fv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3fv(v: IntPtr);
begin
z_SecondaryColor3fv_ovr_2(v);
end;
// added in gl1.4, deprecated in gl3.2
public z_SecondaryColor3i_adr := GetFuncAdr('glSecondaryColor3i');
public 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);
begin
z_SecondaryColor3i_ovr_0(red, green, blue);
end;
// added in gl1.4, deprecated in gl3.2
public z_SecondaryColor3iv_adr := GetFuncAdr('glSecondaryColor3iv');
public z_SecondaryColor3iv_ovr_0 := GetFuncOrNil&<procedure(var v: Int32)>(z_SecondaryColor3iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3iv(v: array of Int32);
begin
z_SecondaryColor3iv_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3iv(var v: Int32);
begin
z_SecondaryColor3iv_ovr_0(v);
end;
public z_SecondaryColor3iv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3iv(v: IntPtr);
begin
z_SecondaryColor3iv_ovr_2(v);
end;
// added in gl1.4, deprecated in gl3.2
public z_SecondaryColor3s_adr := GetFuncAdr('glSecondaryColor3s');
public 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);
begin
z_SecondaryColor3s_ovr_0(red, green, blue);
end;
// added in gl1.4, deprecated in gl3.2
public z_SecondaryColor3sv_adr := GetFuncAdr('glSecondaryColor3sv');
public z_SecondaryColor3sv_ovr_0 := GetFuncOrNil&<procedure(var v: Int16)>(z_SecondaryColor3sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3sv(v: array of Int16);
begin
z_SecondaryColor3sv_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3sv(var v: Int16);
begin
z_SecondaryColor3sv_ovr_0(v);
end;
public z_SecondaryColor3sv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3sv(v: IntPtr);
begin
z_SecondaryColor3sv_ovr_2(v);
end;
// added in gl1.4, deprecated in gl3.2
public z_SecondaryColor3ub_adr := GetFuncAdr('glSecondaryColor3ub');
public 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);
begin
z_SecondaryColor3ub_ovr_0(red, green, blue);
end;
// added in gl1.4, deprecated in gl3.2
public z_SecondaryColor3ubv_adr := GetFuncAdr('glSecondaryColor3ubv');
public z_SecondaryColor3ubv_ovr_0 := GetFuncOrNil&<procedure(var v: Byte)>(z_SecondaryColor3ubv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3ubv(v: array of Byte);
begin
z_SecondaryColor3ubv_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3ubv(var v: Byte);
begin
z_SecondaryColor3ubv_ovr_0(v);
end;
public z_SecondaryColor3ubv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3ubv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3ubv(v: IntPtr);
begin
z_SecondaryColor3ubv_ovr_2(v);
end;
// added in gl1.4, deprecated in gl3.2
public z_SecondaryColor3ui_adr := GetFuncAdr('glSecondaryColor3ui');
public 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);
begin
z_SecondaryColor3ui_ovr_0(red, green, blue);
end;
// added in gl1.4, deprecated in gl3.2
public z_SecondaryColor3uiv_adr := GetFuncAdr('glSecondaryColor3uiv');
public z_SecondaryColor3uiv_ovr_0 := GetFuncOrNil&<procedure(var v: UInt32)>(z_SecondaryColor3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3uiv(v: array of UInt32);
begin
z_SecondaryColor3uiv_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3uiv(var v: UInt32);
begin
z_SecondaryColor3uiv_ovr_0(v);
end;
public z_SecondaryColor3uiv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3uiv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3uiv(v: IntPtr);
begin
z_SecondaryColor3uiv_ovr_2(v);
end;
// added in gl1.4, deprecated in gl3.2
public z_SecondaryColor3us_adr := GetFuncAdr('glSecondaryColor3us');
public 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);
begin
z_SecondaryColor3us_ovr_0(red, green, blue);
end;
// added in gl1.4, deprecated in gl3.2
public z_SecondaryColor3usv_adr := GetFuncAdr('glSecondaryColor3usv');
public z_SecondaryColor3usv_ovr_0 := GetFuncOrNil&<procedure(var v: UInt16)>(z_SecondaryColor3usv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3usv(v: array of UInt16);
begin
z_SecondaryColor3usv_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3usv(var v: UInt16);
begin
z_SecondaryColor3usv_ovr_0(v);
end;
public z_SecondaryColor3usv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3usv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3usv(v: IntPtr);
begin
z_SecondaryColor3usv_ovr_2(v);
end;
// added in gl1.4, deprecated in gl3.2
public z_SecondaryColorPointer_adr := GetFuncAdr('glSecondaryColorPointer');
public 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);
begin
z_SecondaryColorPointer_ovr_0(size, &type, stride, pointer);
end;
// added in gl1.0, deprecated in gl3.2
private static procedure _z_SelectBuffer_ovr0(size: Int32; [MarshalAs(UnmanagedType.LPArray)] buffer: array of UInt32);
external 'opengl32.dll' name 'glSelectBuffer';
public static z_SelectBuffer_ovr0 := _z_SelectBuffer_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SelectBuffer(size: Int32; buffer: array of UInt32) := z_SelectBuffer_ovr0(size, buffer);
private static procedure _z_SelectBuffer_ovr1(size: Int32; var buffer: UInt32);
external 'opengl32.dll' name 'glSelectBuffer';
public static z_SelectBuffer_ovr1 := _z_SelectBuffer_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SelectBuffer(size: Int32; var buffer: UInt32) := z_SelectBuffer_ovr1(size, buffer);
private static procedure _z_SelectBuffer_ovr2(size: Int32; buffer: IntPtr);
external 'opengl32.dll' name 'glSelectBuffer';
public static z_SelectBuffer_ovr2 := _z_SelectBuffer_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SelectBuffer(size: Int32; buffer: IntPtr) := z_SelectBuffer_ovr2(size, buffer);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_ShadeModel_ovr0(mode: ShadingModel);
external 'opengl32.dll' name 'glShadeModel';
public static z_ShadeModel_ovr0 := _z_ShadeModel_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShadeModel(mode: ShadingModel) := z_ShadeModel_ovr0(mode);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord1d_ovr0(s: real);
external 'opengl32.dll' name 'glTexCoord1d';
public static z_TexCoord1d_ovr0 := _z_TexCoord1d_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1d(s: real) := z_TexCoord1d_ovr0(s);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord1dv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of real);
external 'opengl32.dll' name 'glTexCoord1dv';
public static z_TexCoord1dv_ovr0 := _z_TexCoord1dv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1dv(v: array of real) := z_TexCoord1dv_ovr0(v);
private static procedure _z_TexCoord1dv_ovr1(var v: real);
external 'opengl32.dll' name 'glTexCoord1dv';
public static z_TexCoord1dv_ovr1 := _z_TexCoord1dv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1dv(var v: real) := z_TexCoord1dv_ovr1(v);
private static procedure _z_TexCoord1dv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord1dv';
public static z_TexCoord1dv_ovr2 := _z_TexCoord1dv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1dv(v: IntPtr) := z_TexCoord1dv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord1f_ovr0(s: single);
external 'opengl32.dll' name 'glTexCoord1f';
public static z_TexCoord1f_ovr0 := _z_TexCoord1f_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1f(s: single) := z_TexCoord1f_ovr0(s);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord1fv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of single);
external 'opengl32.dll' name 'glTexCoord1fv';
public static z_TexCoord1fv_ovr0 := _z_TexCoord1fv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1fv(v: array of single) := z_TexCoord1fv_ovr0(v);
private static procedure _z_TexCoord1fv_ovr1(var v: single);
external 'opengl32.dll' name 'glTexCoord1fv';
public static z_TexCoord1fv_ovr1 := _z_TexCoord1fv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1fv(var v: single) := z_TexCoord1fv_ovr1(v);
private static procedure _z_TexCoord1fv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord1fv';
public static z_TexCoord1fv_ovr2 := _z_TexCoord1fv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1fv(v: IntPtr) := z_TexCoord1fv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord1i_ovr0(s: Int32);
external 'opengl32.dll' name 'glTexCoord1i';
public static z_TexCoord1i_ovr0 := _z_TexCoord1i_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1i(s: Int32) := z_TexCoord1i_ovr0(s);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord1iv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Int32);
external 'opengl32.dll' name 'glTexCoord1iv';
public static z_TexCoord1iv_ovr0 := _z_TexCoord1iv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1iv(v: array of Int32) := z_TexCoord1iv_ovr0(v);
private static procedure _z_TexCoord1iv_ovr1(var v: Int32);
external 'opengl32.dll' name 'glTexCoord1iv';
public static z_TexCoord1iv_ovr1 := _z_TexCoord1iv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1iv(var v: Int32) := z_TexCoord1iv_ovr1(v);
private static procedure _z_TexCoord1iv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord1iv';
public static z_TexCoord1iv_ovr2 := _z_TexCoord1iv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1iv(v: IntPtr) := z_TexCoord1iv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord1s_ovr0(s: Int16);
external 'opengl32.dll' name 'glTexCoord1s';
public static z_TexCoord1s_ovr0 := _z_TexCoord1s_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1s(s: Int16) := z_TexCoord1s_ovr0(s);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord1sv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Int16);
external 'opengl32.dll' name 'glTexCoord1sv';
public static z_TexCoord1sv_ovr0 := _z_TexCoord1sv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1sv(v: array of Int16) := z_TexCoord1sv_ovr0(v);
private static procedure _z_TexCoord1sv_ovr1(var v: Int16);
external 'opengl32.dll' name 'glTexCoord1sv';
public static z_TexCoord1sv_ovr1 := _z_TexCoord1sv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1sv(var v: Int16) := z_TexCoord1sv_ovr1(v);
private static procedure _z_TexCoord1sv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord1sv';
public static z_TexCoord1sv_ovr2 := _z_TexCoord1sv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1sv(v: IntPtr) := z_TexCoord1sv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord2d_ovr0(s: real; t: real);
external 'opengl32.dll' name 'glTexCoord2d';
public static z_TexCoord2d_ovr0 := _z_TexCoord2d_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2d(s: real; t: real) := z_TexCoord2d_ovr0(s, t);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord2dv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of real);
external 'opengl32.dll' name 'glTexCoord2dv';
public static z_TexCoord2dv_ovr0 := _z_TexCoord2dv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2dv(v: array of real) := z_TexCoord2dv_ovr0(v);
private static procedure _z_TexCoord2dv_ovr1(var v: real);
external 'opengl32.dll' name 'glTexCoord2dv';
public static z_TexCoord2dv_ovr1 := _z_TexCoord2dv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2dv(var v: real) := z_TexCoord2dv_ovr1(v);
private static procedure _z_TexCoord2dv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2dv';
public static z_TexCoord2dv_ovr2 := _z_TexCoord2dv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2dv(v: IntPtr) := z_TexCoord2dv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord2f_ovr0(s: single; t: single);
external 'opengl32.dll' name 'glTexCoord2f';
public static z_TexCoord2f_ovr0 := _z_TexCoord2f_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2f(s: single; t: single) := z_TexCoord2f_ovr0(s, t);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord2fv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of single);
external 'opengl32.dll' name 'glTexCoord2fv';
public static z_TexCoord2fv_ovr0 := _z_TexCoord2fv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fv(v: array of single) := z_TexCoord2fv_ovr0(v);
private static procedure _z_TexCoord2fv_ovr1(var v: single);
external 'opengl32.dll' name 'glTexCoord2fv';
public static z_TexCoord2fv_ovr1 := _z_TexCoord2fv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fv(var v: single) := z_TexCoord2fv_ovr1(v);
private static procedure _z_TexCoord2fv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2fv';
public static z_TexCoord2fv_ovr2 := _z_TexCoord2fv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fv(v: IntPtr) := z_TexCoord2fv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord2i_ovr0(s: Int32; t: Int32);
external 'opengl32.dll' name 'glTexCoord2i';
public static z_TexCoord2i_ovr0 := _z_TexCoord2i_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2i(s: Int32; t: Int32) := z_TexCoord2i_ovr0(s, t);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord2iv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Int32);
external 'opengl32.dll' name 'glTexCoord2iv';
public static z_TexCoord2iv_ovr0 := _z_TexCoord2iv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2iv(v: array of Int32) := z_TexCoord2iv_ovr0(v);
private static procedure _z_TexCoord2iv_ovr1(var v: Int32);
external 'opengl32.dll' name 'glTexCoord2iv';
public static z_TexCoord2iv_ovr1 := _z_TexCoord2iv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2iv(var v: Int32) := z_TexCoord2iv_ovr1(v);
private static procedure _z_TexCoord2iv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2iv';
public static z_TexCoord2iv_ovr2 := _z_TexCoord2iv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2iv(v: IntPtr) := z_TexCoord2iv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord2s_ovr0(s: Int16; t: Int16);
external 'opengl32.dll' name 'glTexCoord2s';
public static z_TexCoord2s_ovr0 := _z_TexCoord2s_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2s(s: Int16; t: Int16) := z_TexCoord2s_ovr0(s, t);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord2sv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Int16);
external 'opengl32.dll' name 'glTexCoord2sv';
public static z_TexCoord2sv_ovr0 := _z_TexCoord2sv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2sv(v: array of Int16) := z_TexCoord2sv_ovr0(v);
private static procedure _z_TexCoord2sv_ovr1(var v: Int16);
external 'opengl32.dll' name 'glTexCoord2sv';
public static z_TexCoord2sv_ovr1 := _z_TexCoord2sv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2sv(var v: Int16) := z_TexCoord2sv_ovr1(v);
private static procedure _z_TexCoord2sv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord2sv';
public static z_TexCoord2sv_ovr2 := _z_TexCoord2sv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2sv(v: IntPtr) := z_TexCoord2sv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord3d_ovr0(s: real; t: real; r: real);
external 'opengl32.dll' name 'glTexCoord3d';
public static z_TexCoord3d_ovr0 := _z_TexCoord3d_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3d(s: real; t: real; r: real) := z_TexCoord3d_ovr0(s, t, r);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord3dv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of real);
external 'opengl32.dll' name 'glTexCoord3dv';
public static z_TexCoord3dv_ovr0 := _z_TexCoord3dv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3dv(v: array of real) := z_TexCoord3dv_ovr0(v);
private static procedure _z_TexCoord3dv_ovr1(var v: real);
external 'opengl32.dll' name 'glTexCoord3dv';
public static z_TexCoord3dv_ovr1 := _z_TexCoord3dv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3dv(var v: real) := z_TexCoord3dv_ovr1(v);
private static procedure _z_TexCoord3dv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord3dv';
public static z_TexCoord3dv_ovr2 := _z_TexCoord3dv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3dv(v: IntPtr) := z_TexCoord3dv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord3f_ovr0(s: single; t: single; r: single);
external 'opengl32.dll' name 'glTexCoord3f';
public static z_TexCoord3f_ovr0 := _z_TexCoord3f_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3f(s: single; t: single; r: single) := z_TexCoord3f_ovr0(s, t, r);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord3fv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of single);
external 'opengl32.dll' name 'glTexCoord3fv';
public static z_TexCoord3fv_ovr0 := _z_TexCoord3fv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3fv(v: array of single) := z_TexCoord3fv_ovr0(v);
private static procedure _z_TexCoord3fv_ovr1(var v: single);
external 'opengl32.dll' name 'glTexCoord3fv';
public static z_TexCoord3fv_ovr1 := _z_TexCoord3fv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3fv(var v: single) := z_TexCoord3fv_ovr1(v);
private static procedure _z_TexCoord3fv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord3fv';
public static z_TexCoord3fv_ovr2 := _z_TexCoord3fv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3fv(v: IntPtr) := z_TexCoord3fv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord3i_ovr0(s: Int32; t: Int32; r: Int32);
external 'opengl32.dll' name 'glTexCoord3i';
public static z_TexCoord3i_ovr0 := _z_TexCoord3i_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3i(s: Int32; t: Int32; r: Int32) := z_TexCoord3i_ovr0(s, t, r);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord3iv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Int32);
external 'opengl32.dll' name 'glTexCoord3iv';
public static z_TexCoord3iv_ovr0 := _z_TexCoord3iv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3iv(v: array of Int32) := z_TexCoord3iv_ovr0(v);
private static procedure _z_TexCoord3iv_ovr1(var v: Int32);
external 'opengl32.dll' name 'glTexCoord3iv';
public static z_TexCoord3iv_ovr1 := _z_TexCoord3iv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3iv(var v: Int32) := z_TexCoord3iv_ovr1(v);
private static procedure _z_TexCoord3iv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord3iv';
public static z_TexCoord3iv_ovr2 := _z_TexCoord3iv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3iv(v: IntPtr) := z_TexCoord3iv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord3s_ovr0(s: Int16; t: Int16; r: Int16);
external 'opengl32.dll' name 'glTexCoord3s';
public static z_TexCoord3s_ovr0 := _z_TexCoord3s_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3s(s: Int16; t: Int16; r: Int16) := z_TexCoord3s_ovr0(s, t, r);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord3sv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Int16);
external 'opengl32.dll' name 'glTexCoord3sv';
public static z_TexCoord3sv_ovr0 := _z_TexCoord3sv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3sv(v: array of Int16) := z_TexCoord3sv_ovr0(v);
private static procedure _z_TexCoord3sv_ovr1(var v: Int16);
external 'opengl32.dll' name 'glTexCoord3sv';
public static z_TexCoord3sv_ovr1 := _z_TexCoord3sv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3sv(var v: Int16) := z_TexCoord3sv_ovr1(v);
private static procedure _z_TexCoord3sv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord3sv';
public static z_TexCoord3sv_ovr2 := _z_TexCoord3sv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3sv(v: IntPtr) := z_TexCoord3sv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord4d_ovr0(s: real; t: real; r: real; q: real);
external 'opengl32.dll' name 'glTexCoord4d';
public static z_TexCoord4d_ovr0 := _z_TexCoord4d_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4d(s: real; t: real; r: real; q: real) := z_TexCoord4d_ovr0(s, t, r, q);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord4dv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of real);
external 'opengl32.dll' name 'glTexCoord4dv';
public static z_TexCoord4dv_ovr0 := _z_TexCoord4dv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4dv(v: array of real) := z_TexCoord4dv_ovr0(v);
private static procedure _z_TexCoord4dv_ovr1(var v: real);
external 'opengl32.dll' name 'glTexCoord4dv';
public static z_TexCoord4dv_ovr1 := _z_TexCoord4dv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4dv(var v: real) := z_TexCoord4dv_ovr1(v);
private static procedure _z_TexCoord4dv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord4dv';
public static z_TexCoord4dv_ovr2 := _z_TexCoord4dv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4dv(v: IntPtr) := z_TexCoord4dv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord4f_ovr0(s: single; t: single; r: single; q: single);
external 'opengl32.dll' name 'glTexCoord4f';
public static z_TexCoord4f_ovr0 := _z_TexCoord4f_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4f(s: single; t: single; r: single; q: single) := z_TexCoord4f_ovr0(s, t, r, q);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord4fv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of single);
external 'opengl32.dll' name 'glTexCoord4fv';
public static z_TexCoord4fv_ovr0 := _z_TexCoord4fv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4fv(v: array of single) := z_TexCoord4fv_ovr0(v);
private static procedure _z_TexCoord4fv_ovr1(var v: single);
external 'opengl32.dll' name 'glTexCoord4fv';
public static z_TexCoord4fv_ovr1 := _z_TexCoord4fv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4fv(var v: single) := z_TexCoord4fv_ovr1(v);
private static procedure _z_TexCoord4fv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord4fv';
public static z_TexCoord4fv_ovr2 := _z_TexCoord4fv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4fv(v: IntPtr) := z_TexCoord4fv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord4i_ovr0(s: Int32; t: Int32; r: Int32; q: Int32);
external 'opengl32.dll' name 'glTexCoord4i';
public static z_TexCoord4i_ovr0 := _z_TexCoord4i_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4i(s: Int32; t: Int32; r: Int32; q: Int32) := z_TexCoord4i_ovr0(s, t, r, q);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord4iv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Int32);
external 'opengl32.dll' name 'glTexCoord4iv';
public static z_TexCoord4iv_ovr0 := _z_TexCoord4iv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4iv(v: array of Int32) := z_TexCoord4iv_ovr0(v);
private static procedure _z_TexCoord4iv_ovr1(var v: Int32);
external 'opengl32.dll' name 'glTexCoord4iv';
public static z_TexCoord4iv_ovr1 := _z_TexCoord4iv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4iv(var v: Int32) := z_TexCoord4iv_ovr1(v);
private static procedure _z_TexCoord4iv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord4iv';
public static z_TexCoord4iv_ovr2 := _z_TexCoord4iv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4iv(v: IntPtr) := z_TexCoord4iv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord4s_ovr0(s: Int16; t: Int16; r: Int16; q: Int16);
external 'opengl32.dll' name 'glTexCoord4s';
public static z_TexCoord4s_ovr0 := _z_TexCoord4s_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4s(s: Int16; t: Int16; r: Int16; q: Int16) := z_TexCoord4s_ovr0(s, t, r, q);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexCoord4sv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Int16);
external 'opengl32.dll' name 'glTexCoord4sv';
public static z_TexCoord4sv_ovr0 := _z_TexCoord4sv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4sv(v: array of Int16) := z_TexCoord4sv_ovr0(v);
private static procedure _z_TexCoord4sv_ovr1(var v: Int16);
external 'opengl32.dll' name 'glTexCoord4sv';
public static z_TexCoord4sv_ovr1 := _z_TexCoord4sv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4sv(var v: Int16) := z_TexCoord4sv_ovr1(v);
private static procedure _z_TexCoord4sv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glTexCoord4sv';
public static z_TexCoord4sv_ovr2 := _z_TexCoord4sv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4sv(v: IntPtr) := z_TexCoord4sv_ovr2(v);
// added in gl1.1, deprecated in gl3.2
private static procedure _z_TexCoordPointer_ovr0(size: Int32; &type: TexCoordPointerType; stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glTexCoordPointer';
public static z_TexCoordPointer_ovr0 := _z_TexCoordPointer_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordPointer(size: Int32; &type: TexCoordPointerType; stride: Int32; pointer: IntPtr) := z_TexCoordPointer_ovr0(size, &type, stride, pointer);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexEnvf_ovr0(target: TextureEnvTarget; pname: TextureEnvParameter; param: single);
external 'opengl32.dll' name 'glTexEnvf';
public static z_TexEnvf_ovr0 := _z_TexEnvf_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexEnvf(target: TextureEnvTarget; pname: TextureEnvParameter; param: single) := z_TexEnvf_ovr0(target, pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexEnvfv_ovr0(target: TextureEnvTarget; pname: TextureEnvParameter; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of single);
external 'opengl32.dll' name 'glTexEnvfv';
public static z_TexEnvfv_ovr0 := _z_TexEnvfv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexEnvfv(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: array of single) := z_TexEnvfv_ovr0(target, pname, ¶ms);
private static procedure _z_TexEnvfv_ovr1(target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: single);
external 'opengl32.dll' name 'glTexEnvfv';
public static z_TexEnvfv_ovr1 := _z_TexEnvfv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexEnvfv(target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: single) := z_TexEnvfv_ovr1(target, pname, ¶ms);
private static procedure _z_TexEnvfv_ovr2(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexEnvfv';
public static z_TexEnvfv_ovr2 := _z_TexEnvfv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexEnvfv(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr) := z_TexEnvfv_ovr2(target, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexEnvi_ovr0(target: TextureEnvTarget; pname: TextureEnvParameter; param: Int32);
external 'opengl32.dll' name 'glTexEnvi';
public static z_TexEnvi_ovr0 := _z_TexEnvi_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexEnvi(target: TextureEnvTarget; pname: TextureEnvParameter; param: Int32) := z_TexEnvi_ovr0(target, pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexEnviv_ovr0(target: TextureEnvTarget; pname: TextureEnvParameter; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of Int32);
external 'opengl32.dll' name 'glTexEnviv';
public static z_TexEnviv_ovr0 := _z_TexEnviv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexEnviv(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: array of Int32) := z_TexEnviv_ovr0(target, pname, ¶ms);
private static procedure _z_TexEnviv_ovr1(target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glTexEnviv';
public static z_TexEnviv_ovr1 := _z_TexEnviv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexEnviv(target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: Int32) := z_TexEnviv_ovr1(target, pname, ¶ms);
private static procedure _z_TexEnviv_ovr2(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexEnviv';
public static z_TexEnviv_ovr2 := _z_TexEnviv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexEnviv(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr) := z_TexEnviv_ovr2(target, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexGend_ovr0(coord: TextureCoordName; pname: TextureGenParameter; param: real);
external 'opengl32.dll' name 'glTexGend';
public static z_TexGend_ovr0 := _z_TexGend_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGend(coord: TextureCoordName; pname: TextureGenParameter; param: real) := z_TexGend_ovr0(coord, pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexGendv_ovr0(coord: TextureCoordName; pname: TextureGenParameter; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of real);
external 'opengl32.dll' name 'glTexGendv';
public static z_TexGendv_ovr0 := _z_TexGendv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGendv(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of real) := z_TexGendv_ovr0(coord, pname, ¶ms);
private static procedure _z_TexGendv_ovr1(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: real);
external 'opengl32.dll' name 'glTexGendv';
public static z_TexGendv_ovr1 := _z_TexGendv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGendv(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: real) := z_TexGendv_ovr1(coord, pname, ¶ms);
private static procedure _z_TexGendv_ovr2(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexGendv';
public static z_TexGendv_ovr2 := _z_TexGendv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGendv(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr) := z_TexGendv_ovr2(coord, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexGenf_ovr0(coord: TextureCoordName; pname: TextureGenParameter; param: single);
external 'opengl32.dll' name 'glTexGenf';
public static z_TexGenf_ovr0 := _z_TexGenf_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGenf(coord: TextureCoordName; pname: TextureGenParameter; param: single) := z_TexGenf_ovr0(coord, pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexGenfv_ovr0(coord: TextureCoordName; pname: TextureGenParameter; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of single);
external 'opengl32.dll' name 'glTexGenfv';
public static z_TexGenfv_ovr0 := _z_TexGenfv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGenfv(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of single) := z_TexGenfv_ovr0(coord, pname, ¶ms);
private static procedure _z_TexGenfv_ovr1(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: single);
external 'opengl32.dll' name 'glTexGenfv';
public static z_TexGenfv_ovr1 := _z_TexGenfv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGenfv(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: single) := z_TexGenfv_ovr1(coord, pname, ¶ms);
private static procedure _z_TexGenfv_ovr2(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexGenfv';
public static z_TexGenfv_ovr2 := _z_TexGenfv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGenfv(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr) := z_TexGenfv_ovr2(coord, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexGeni_ovr0(coord: TextureCoordName; pname: TextureGenParameter; param: Int32);
external 'opengl32.dll' name 'glTexGeni';
public static z_TexGeni_ovr0 := _z_TexGeni_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGeni(coord: TextureCoordName; pname: TextureGenParameter; param: Int32) := z_TexGeni_ovr0(coord, pname, param);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_TexGeniv_ovr0(coord: TextureCoordName; pname: TextureGenParameter; [MarshalAs(UnmanagedType.LPArray)] ¶ms: array of Int32);
external 'opengl32.dll' name 'glTexGeniv';
public static z_TexGeniv_ovr0 := _z_TexGeniv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGeniv(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of Int32) := z_TexGeniv_ovr0(coord, pname, ¶ms);
private static procedure _z_TexGeniv_ovr1(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: Int32);
external 'opengl32.dll' name 'glTexGeniv';
public static z_TexGeniv_ovr1 := _z_TexGeniv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGeniv(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: Int32) := z_TexGeniv_ovr1(coord, pname, ¶ms);
private static procedure _z_TexGeniv_ovr2(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
external 'opengl32.dll' name 'glTexGeniv';
public static z_TexGeniv_ovr2 := _z_TexGeniv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGeniv(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr) := z_TexGeniv_ovr2(coord, pname, ¶ms);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Translated_ovr0(x: real; y: real; z: real);
external 'opengl32.dll' name 'glTranslated';
public static z_Translated_ovr0 := _z_Translated_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Translated(x: real; y: real; z: real) := z_Translated_ovr0(x, y, z);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Translatef_ovr0(x: single; y: single; z: single);
external 'opengl32.dll' name 'glTranslatef';
public static z_Translatef_ovr0 := _z_Translatef_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Translatef(x: single; y: single; z: single) := z_Translatef_ovr0(x, y, z);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Vertex2d_ovr0(x: real; y: real);
external 'opengl32.dll' name 'glVertex2d';
public static z_Vertex2d_ovr0 := _z_Vertex2d_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2d(x: real; y: real) := z_Vertex2d_ovr0(x, y);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Vertex2dv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of real);
external 'opengl32.dll' name 'glVertex2dv';
public static z_Vertex2dv_ovr0 := _z_Vertex2dv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2dv(v: array of real) := z_Vertex2dv_ovr0(v);
private static procedure _z_Vertex2dv_ovr1(var v: real);
external 'opengl32.dll' name 'glVertex2dv';
public static z_Vertex2dv_ovr1 := _z_Vertex2dv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2dv(var v: real) := z_Vertex2dv_ovr1(v);
private static procedure _z_Vertex2dv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glVertex2dv';
public static z_Vertex2dv_ovr2 := _z_Vertex2dv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2dv(v: IntPtr) := z_Vertex2dv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Vertex2f_ovr0(x: single; y: single);
external 'opengl32.dll' name 'glVertex2f';
public static z_Vertex2f_ovr0 := _z_Vertex2f_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2f(x: single; y: single) := z_Vertex2f_ovr0(x, y);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Vertex2fv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of single);
external 'opengl32.dll' name 'glVertex2fv';
public static z_Vertex2fv_ovr0 := _z_Vertex2fv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2fv(v: array of single) := z_Vertex2fv_ovr0(v);
private static procedure _z_Vertex2fv_ovr1(var v: single);
external 'opengl32.dll' name 'glVertex2fv';
public static z_Vertex2fv_ovr1 := _z_Vertex2fv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2fv(var v: single) := z_Vertex2fv_ovr1(v);
private static procedure _z_Vertex2fv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glVertex2fv';
public static z_Vertex2fv_ovr2 := _z_Vertex2fv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2fv(v: IntPtr) := z_Vertex2fv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Vertex2i_ovr0(x: Int32; y: Int32);
external 'opengl32.dll' name 'glVertex2i';
public static z_Vertex2i_ovr0 := _z_Vertex2i_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2i(x: Int32; y: Int32) := z_Vertex2i_ovr0(x, y);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Vertex2iv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Int32);
external 'opengl32.dll' name 'glVertex2iv';
public static z_Vertex2iv_ovr0 := _z_Vertex2iv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2iv(v: array of Int32) := z_Vertex2iv_ovr0(v);
private static procedure _z_Vertex2iv_ovr1(var v: Int32);
external 'opengl32.dll' name 'glVertex2iv';
public static z_Vertex2iv_ovr1 := _z_Vertex2iv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2iv(var v: Int32) := z_Vertex2iv_ovr1(v);
private static procedure _z_Vertex2iv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glVertex2iv';
public static z_Vertex2iv_ovr2 := _z_Vertex2iv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2iv(v: IntPtr) := z_Vertex2iv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Vertex2s_ovr0(x: Int16; y: Int16);
external 'opengl32.dll' name 'glVertex2s';
public static z_Vertex2s_ovr0 := _z_Vertex2s_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2s(x: Int16; y: Int16) := z_Vertex2s_ovr0(x, y);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Vertex2sv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Int16);
external 'opengl32.dll' name 'glVertex2sv';
public static z_Vertex2sv_ovr0 := _z_Vertex2sv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2sv(v: array of Int16) := z_Vertex2sv_ovr0(v);
private static procedure _z_Vertex2sv_ovr1(var v: Int16);
external 'opengl32.dll' name 'glVertex2sv';
public static z_Vertex2sv_ovr1 := _z_Vertex2sv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2sv(var v: Int16) := z_Vertex2sv_ovr1(v);
private static procedure _z_Vertex2sv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glVertex2sv';
public static z_Vertex2sv_ovr2 := _z_Vertex2sv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2sv(v: IntPtr) := z_Vertex2sv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Vertex3d_ovr0(x: real; y: real; z: real);
external 'opengl32.dll' name 'glVertex3d';
public static z_Vertex3d_ovr0 := _z_Vertex3d_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3d(x: real; y: real; z: real) := z_Vertex3d_ovr0(x, y, z);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Vertex3dv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of real);
external 'opengl32.dll' name 'glVertex3dv';
public static z_Vertex3dv_ovr0 := _z_Vertex3dv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3dv(v: array of real) := z_Vertex3dv_ovr0(v);
private static procedure _z_Vertex3dv_ovr1(var v: real);
external 'opengl32.dll' name 'glVertex3dv';
public static z_Vertex3dv_ovr1 := _z_Vertex3dv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3dv(var v: real) := z_Vertex3dv_ovr1(v);
private static procedure _z_Vertex3dv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glVertex3dv';
public static z_Vertex3dv_ovr2 := _z_Vertex3dv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3dv(v: IntPtr) := z_Vertex3dv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Vertex3f_ovr0(x: single; y: single; z: single);
external 'opengl32.dll' name 'glVertex3f';
public static z_Vertex3f_ovr0 := _z_Vertex3f_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3f(x: single; y: single; z: single) := z_Vertex3f_ovr0(x, y, z);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Vertex3fv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of single);
external 'opengl32.dll' name 'glVertex3fv';
public static z_Vertex3fv_ovr0 := _z_Vertex3fv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3fv(v: array of single) := z_Vertex3fv_ovr0(v);
private static procedure _z_Vertex3fv_ovr1(var v: single);
external 'opengl32.dll' name 'glVertex3fv';
public static z_Vertex3fv_ovr1 := _z_Vertex3fv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3fv(var v: single) := z_Vertex3fv_ovr1(v);
private static procedure _z_Vertex3fv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glVertex3fv';
public static z_Vertex3fv_ovr2 := _z_Vertex3fv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3fv(v: IntPtr) := z_Vertex3fv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Vertex3i_ovr0(x: Int32; y: Int32; z: Int32);
external 'opengl32.dll' name 'glVertex3i';
public static z_Vertex3i_ovr0 := _z_Vertex3i_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3i(x: Int32; y: Int32; z: Int32) := z_Vertex3i_ovr0(x, y, z);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Vertex3iv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Int32);
external 'opengl32.dll' name 'glVertex3iv';
public static z_Vertex3iv_ovr0 := _z_Vertex3iv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3iv(v: array of Int32) := z_Vertex3iv_ovr0(v);
private static procedure _z_Vertex3iv_ovr1(var v: Int32);
external 'opengl32.dll' name 'glVertex3iv';
public static z_Vertex3iv_ovr1 := _z_Vertex3iv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3iv(var v: Int32) := z_Vertex3iv_ovr1(v);
private static procedure _z_Vertex3iv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glVertex3iv';
public static z_Vertex3iv_ovr2 := _z_Vertex3iv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3iv(v: IntPtr) := z_Vertex3iv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Vertex3s_ovr0(x: Int16; y: Int16; z: Int16);
external 'opengl32.dll' name 'glVertex3s';
public static z_Vertex3s_ovr0 := _z_Vertex3s_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3s(x: Int16; y: Int16; z: Int16) := z_Vertex3s_ovr0(x, y, z);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Vertex3sv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Int16);
external 'opengl32.dll' name 'glVertex3sv';
public static z_Vertex3sv_ovr0 := _z_Vertex3sv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3sv(v: array of Int16) := z_Vertex3sv_ovr0(v);
private static procedure _z_Vertex3sv_ovr1(var v: Int16);
external 'opengl32.dll' name 'glVertex3sv';
public static z_Vertex3sv_ovr1 := _z_Vertex3sv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3sv(var v: Int16) := z_Vertex3sv_ovr1(v);
private static procedure _z_Vertex3sv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glVertex3sv';
public static z_Vertex3sv_ovr2 := _z_Vertex3sv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3sv(v: IntPtr) := z_Vertex3sv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Vertex4d_ovr0(x: real; y: real; z: real; w: real);
external 'opengl32.dll' name 'glVertex4d';
public static z_Vertex4d_ovr0 := _z_Vertex4d_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4d(x: real; y: real; z: real; w: real) := z_Vertex4d_ovr0(x, y, z, w);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Vertex4dv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of real);
external 'opengl32.dll' name 'glVertex4dv';
public static z_Vertex4dv_ovr0 := _z_Vertex4dv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4dv(v: array of real) := z_Vertex4dv_ovr0(v);
private static procedure _z_Vertex4dv_ovr1(var v: real);
external 'opengl32.dll' name 'glVertex4dv';
public static z_Vertex4dv_ovr1 := _z_Vertex4dv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4dv(var v: real) := z_Vertex4dv_ovr1(v);
private static procedure _z_Vertex4dv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glVertex4dv';
public static z_Vertex4dv_ovr2 := _z_Vertex4dv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4dv(v: IntPtr) := z_Vertex4dv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Vertex4f_ovr0(x: single; y: single; z: single; w: single);
external 'opengl32.dll' name 'glVertex4f';
public static z_Vertex4f_ovr0 := _z_Vertex4f_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4f(x: single; y: single; z: single; w: single) := z_Vertex4f_ovr0(x, y, z, w);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Vertex4fv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of single);
external 'opengl32.dll' name 'glVertex4fv';
public static z_Vertex4fv_ovr0 := _z_Vertex4fv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4fv(v: array of single) := z_Vertex4fv_ovr0(v);
private static procedure _z_Vertex4fv_ovr1(var v: single);
external 'opengl32.dll' name 'glVertex4fv';
public static z_Vertex4fv_ovr1 := _z_Vertex4fv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4fv(var v: single) := z_Vertex4fv_ovr1(v);
private static procedure _z_Vertex4fv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glVertex4fv';
public static z_Vertex4fv_ovr2 := _z_Vertex4fv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4fv(v: IntPtr) := z_Vertex4fv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Vertex4i_ovr0(x: Int32; y: Int32; z: Int32; w: Int32);
external 'opengl32.dll' name 'glVertex4i';
public static z_Vertex4i_ovr0 := _z_Vertex4i_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4i(x: Int32; y: Int32; z: Int32; w: Int32) := z_Vertex4i_ovr0(x, y, z, w);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Vertex4iv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Int32);
external 'opengl32.dll' name 'glVertex4iv';
public static z_Vertex4iv_ovr0 := _z_Vertex4iv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4iv(v: array of Int32) := z_Vertex4iv_ovr0(v);
private static procedure _z_Vertex4iv_ovr1(var v: Int32);
external 'opengl32.dll' name 'glVertex4iv';
public static z_Vertex4iv_ovr1 := _z_Vertex4iv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4iv(var v: Int32) := z_Vertex4iv_ovr1(v);
private static procedure _z_Vertex4iv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glVertex4iv';
public static z_Vertex4iv_ovr2 := _z_Vertex4iv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4iv(v: IntPtr) := z_Vertex4iv_ovr2(v);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Vertex4s_ovr0(x: Int16; y: Int16; z: Int16; w: Int16);
external 'opengl32.dll' name 'glVertex4s';
public static z_Vertex4s_ovr0 := _z_Vertex4s_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4s(x: Int16; y: Int16; z: Int16; w: Int16) := z_Vertex4s_ovr0(x, y, z, w);
// added in gl1.0, deprecated in gl3.2
private static procedure _z_Vertex4sv_ovr0([MarshalAs(UnmanagedType.LPArray)] v: array of Int16);
external 'opengl32.dll' name 'glVertex4sv';
public static z_Vertex4sv_ovr0 := _z_Vertex4sv_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4sv(v: array of Int16) := z_Vertex4sv_ovr0(v);
private static procedure _z_Vertex4sv_ovr1(var v: Int16);
external 'opengl32.dll' name 'glVertex4sv';
public static z_Vertex4sv_ovr1 := _z_Vertex4sv_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4sv(var v: Int16) := z_Vertex4sv_ovr1(v);
private static procedure _z_Vertex4sv_ovr2(v: IntPtr);
external 'opengl32.dll' name 'glVertex4sv';
public static z_Vertex4sv_ovr2 := _z_Vertex4sv_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4sv(v: IntPtr) := z_Vertex4sv_ovr2(v);
// added in gl1.1, deprecated in gl3.2
private static procedure _z_VertexPointer_ovr0(size: Int32; &type: VertexPointerType; stride: Int32; pointer: IntPtr);
external 'opengl32.dll' name 'glVertexPointer';
public static z_VertexPointer_ovr0 := _z_VertexPointer_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexPointer(size: Int32; &type: VertexPointerType; stride: Int32; pointer: IntPtr) := z_VertexPointer_ovr0(size, &type, stride, pointer);
// added in gl1.4, deprecated in gl3.2
public z_WindowPos2d_adr := GetFuncAdr('glWindowPos2d');
public z_WindowPos2d_ovr_0 := GetFuncOrNil&<procedure(x: real; y: real)>(z_WindowPos2d_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2d(x: real; y: real);
begin
z_WindowPos2d_ovr_0(x, y);
end;
// added in gl1.4, deprecated in gl3.2
public z_WindowPos2dv_adr := GetFuncAdr('glWindowPos2dv');
public z_WindowPos2dv_ovr_0 := GetFuncOrNil&<procedure(var v: real)>(z_WindowPos2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2dv(v: array of real);
begin
z_WindowPos2dv_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2dv(var v: real);
begin
z_WindowPos2dv_ovr_0(v);
end;
public z_WindowPos2dv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos2dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2dv(v: IntPtr);
begin
z_WindowPos2dv_ovr_2(v);
end;
// added in gl1.4, deprecated in gl3.2
public z_WindowPos2f_adr := GetFuncAdr('glWindowPos2f');
public z_WindowPos2f_ovr_0 := GetFuncOrNil&<procedure(x: single; y: single)>(z_WindowPos2f_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2f(x: single; y: single);
begin
z_WindowPos2f_ovr_0(x, y);
end;
// added in gl1.4, deprecated in gl3.2
public z_WindowPos2fv_adr := GetFuncAdr('glWindowPos2fv');
public z_WindowPos2fv_ovr_0 := GetFuncOrNil&<procedure(var v: single)>(z_WindowPos2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2fv(v: array of single);
begin
z_WindowPos2fv_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2fv(var v: single);
begin
z_WindowPos2fv_ovr_0(v);
end;
public z_WindowPos2fv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos2fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2fv(v: IntPtr);
begin
z_WindowPos2fv_ovr_2(v);
end;
// added in gl1.4, deprecated in gl3.2
public z_WindowPos2i_adr := GetFuncAdr('glWindowPos2i');
public z_WindowPos2i_ovr_0 := GetFuncOrNil&<procedure(x: Int32; y: Int32)>(z_WindowPos2i_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2i(x: Int32; y: Int32);
begin
z_WindowPos2i_ovr_0(x, y);
end;
// added in gl1.4, deprecated in gl3.2
public z_WindowPos2iv_adr := GetFuncAdr('glWindowPos2iv');
public z_WindowPos2iv_ovr_0 := GetFuncOrNil&<procedure(var v: Int32)>(z_WindowPos2iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2iv(v: array of Int32);
begin
z_WindowPos2iv_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2iv(var v: Int32);
begin
z_WindowPos2iv_ovr_0(v);
end;
public z_WindowPos2iv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos2iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2iv(v: IntPtr);
begin
z_WindowPos2iv_ovr_2(v);
end;
// added in gl1.4, deprecated in gl3.2
public z_WindowPos2s_adr := GetFuncAdr('glWindowPos2s');
public z_WindowPos2s_ovr_0 := GetFuncOrNil&<procedure(x: Int16; y: Int16)>(z_WindowPos2s_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2s(x: Int16; y: Int16);
begin
z_WindowPos2s_ovr_0(x, y);
end;
// added in gl1.4, deprecated in gl3.2
public z_WindowPos2sv_adr := GetFuncAdr('glWindowPos2sv');
public z_WindowPos2sv_ovr_0 := GetFuncOrNil&<procedure(var v: Int16)>(z_WindowPos2sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2sv(v: array of Int16);
begin
z_WindowPos2sv_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2sv(var v: Int16);
begin
z_WindowPos2sv_ovr_0(v);
end;
public z_WindowPos2sv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos2sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2sv(v: IntPtr);
begin
z_WindowPos2sv_ovr_2(v);
end;
// added in gl1.4, deprecated in gl3.2
public z_WindowPos3d_adr := GetFuncAdr('glWindowPos3d');
public 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);
begin
z_WindowPos3d_ovr_0(x, y, z);
end;
// added in gl1.4, deprecated in gl3.2
public z_WindowPos3dv_adr := GetFuncAdr('glWindowPos3dv');
public z_WindowPos3dv_ovr_0 := GetFuncOrNil&<procedure(var v: real)>(z_WindowPos3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3dv(v: array of real);
begin
z_WindowPos3dv_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3dv(var v: real);
begin
z_WindowPos3dv_ovr_0(v);
end;
public z_WindowPos3dv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos3dv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3dv(v: IntPtr);
begin
z_WindowPos3dv_ovr_2(v);
end;
// added in gl1.4, deprecated in gl3.2
public z_WindowPos3f_adr := GetFuncAdr('glWindowPos3f');
public 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);
begin
z_WindowPos3f_ovr_0(x, y, z);
end;
// added in gl1.4, deprecated in gl3.2
public z_WindowPos3fv_adr := GetFuncAdr('glWindowPos3fv');
public z_WindowPos3fv_ovr_0 := GetFuncOrNil&<procedure(var v: single)>(z_WindowPos3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3fv(v: array of single);
begin
z_WindowPos3fv_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3fv(var v: single);
begin
z_WindowPos3fv_ovr_0(v);
end;
public z_WindowPos3fv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos3fv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3fv(v: IntPtr);
begin
z_WindowPos3fv_ovr_2(v);
end;
// added in gl1.4, deprecated in gl3.2
public z_WindowPos3i_adr := GetFuncAdr('glWindowPos3i');
public 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);
begin
z_WindowPos3i_ovr_0(x, y, z);
end;
// added in gl1.4, deprecated in gl3.2
public z_WindowPos3iv_adr := GetFuncAdr('glWindowPos3iv');
public z_WindowPos3iv_ovr_0 := GetFuncOrNil&<procedure(var v: Int32)>(z_WindowPos3iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3iv(v: array of Int32);
begin
z_WindowPos3iv_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3iv(var v: Int32);
begin
z_WindowPos3iv_ovr_0(v);
end;
public z_WindowPos3iv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos3iv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3iv(v: IntPtr);
begin
z_WindowPos3iv_ovr_2(v);
end;
// added in gl1.4, deprecated in gl3.2
public z_WindowPos3s_adr := GetFuncAdr('glWindowPos3s');
public 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);
begin
z_WindowPos3s_ovr_0(x, y, z);
end;
// added in gl1.4, deprecated in gl3.2
public z_WindowPos3sv_adr := GetFuncAdr('glWindowPos3sv');
public z_WindowPos3sv_ovr_0 := GetFuncOrNil&<procedure(var v: Int16)>(z_WindowPos3sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3sv(v: array of Int16);
begin
z_WindowPos3sv_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3sv(var v: Int16);
begin
z_WindowPos3sv_ovr_0(v);
end;
public z_WindowPos3sv_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos3sv_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3sv(v: IntPtr);
begin
z_WindowPos3sv_ovr_2(v);
end;
end;
wgl = static class
// added in wgl1.0
private static function _z_CopyContext_ovr0(hglrcSrc: GLContext; hglrcDst: GLContext; mask: UInt32): UInt32;
external 'opengl32.dll' name 'wglCopyContext';
public static z_CopyContext_ovr0 := _z_CopyContext_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CopyContext(hglrcSrc: GLContext; hglrcDst: GLContext; mask: UInt32): UInt32 := z_CopyContext_ovr0(hglrcSrc, hglrcDst, mask);
// added in wgl1.0
private static function _z_CreateContext_ovr0(hDc: GDI_DC): GLContext;
external 'opengl32.dll' name 'wglCreateContext';
public static z_CreateContext_ovr0 := _z_CreateContext_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateContext(hDc: GDI_DC): GLContext := z_CreateContext_ovr0(hDc);
// added in wgl1.0
private static function _z_CreateLayerContext_ovr0(hDc: GDI_DC; level: Int32): GLContext;
external 'opengl32.dll' name 'wglCreateLayerContext';
public static z_CreateLayerContext_ovr0 := _z_CreateLayerContext_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateLayerContext(hDc: GDI_DC; level: Int32): GLContext := z_CreateLayerContext_ovr0(hDc, level);
// added in wgl1.0
private static function _z_DeleteContext_ovr0(oldContext: GLContext): UInt32;
external 'opengl32.dll' name 'wglDeleteContext';
public static z_DeleteContext_ovr0 := _z_DeleteContext_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DeleteContext(oldContext: GLContext): UInt32 := z_DeleteContext_ovr0(oldContext);
// added in wgl1.0
private static function _z_DescribeLayerPlane_ovr0(hDc: GDI_DC; pixelFormat: Int32; layerPlane: Int32; nBytes: UInt32; [MarshalAs(UnmanagedType.LPArray)] plpd: array of GDI_LayerPlaneDescriptor): UInt32;
external 'opengl32.dll' name 'wglDescribeLayerPlane';
public static z_DescribeLayerPlane_ovr0 := _z_DescribeLayerPlane_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DescribeLayerPlane(hDc: GDI_DC; pixelFormat: Int32; layerPlane: Int32; nBytes: UInt32; plpd: array of GDI_LayerPlaneDescriptor): UInt32 := z_DescribeLayerPlane_ovr0(hDc, pixelFormat, layerPlane, nBytes, plpd);
private static function _z_DescribeLayerPlane_ovr1(hDc: GDI_DC; pixelFormat: Int32; layerPlane: Int32; nBytes: UInt32; var plpd: GDI_LayerPlaneDescriptor): UInt32;
external 'opengl32.dll' name 'wglDescribeLayerPlane';
public static z_DescribeLayerPlane_ovr1 := _z_DescribeLayerPlane_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DescribeLayerPlane(hDc: GDI_DC; pixelFormat: Int32; layerPlane: Int32; nBytes: UInt32; var plpd: GDI_LayerPlaneDescriptor): UInt32 := z_DescribeLayerPlane_ovr1(hDc, pixelFormat, layerPlane, nBytes, plpd);
private static function _z_DescribeLayerPlane_ovr2(hDc: GDI_DC; pixelFormat: Int32; layerPlane: Int32; nBytes: UInt32; plpd: IntPtr): UInt32;
external 'opengl32.dll' name 'wglDescribeLayerPlane';
public static z_DescribeLayerPlane_ovr2 := _z_DescribeLayerPlane_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DescribeLayerPlane(hDc: GDI_DC; pixelFormat: Int32; layerPlane: Int32; nBytes: UInt32; plpd: IntPtr): UInt32 := z_DescribeLayerPlane_ovr2(hDc, pixelFormat, layerPlane, nBytes, plpd);
// added in wgl1.0
private static function _z_GetCurrentContext_ovr0: GLContext;
external 'opengl32.dll' name 'wglGetCurrentContext';
public static z_GetCurrentContext_ovr0: function: GLContext := _z_GetCurrentContext_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetCurrentContext: GLContext := z_GetCurrentContext_ovr0;
// added in wgl1.0
private static function _z_GetCurrentDC_ovr0: GDI_DC;
external 'opengl32.dll' name 'wglGetCurrentDC';
public static z_GetCurrentDC_ovr0: function: GDI_DC := _z_GetCurrentDC_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetCurrentDC: GDI_DC := z_GetCurrentDC_ovr0;
// added in wgl1.0
private static function _z_GetLayerPaletteEntries_ovr0(hdc: GDI_DC; iLayerPlane: Int32; iStart: Int32; cEntries: Int32; [MarshalAs(UnmanagedType.LPArray)] pcr: array of GDI_COLORREF): Int32;
external 'opengl32.dll' name 'wglGetLayerPaletteEntries';
public static z_GetLayerPaletteEntries_ovr0 := _z_GetLayerPaletteEntries_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetLayerPaletteEntries(hdc: GDI_DC; iLayerPlane: Int32; iStart: Int32; cEntries: Int32; pcr: array of GDI_COLORREF): Int32 := z_GetLayerPaletteEntries_ovr0(hdc, iLayerPlane, iStart, cEntries, pcr);
private static function _z_GetLayerPaletteEntries_ovr1(hdc: GDI_DC; iLayerPlane: Int32; iStart: Int32; cEntries: Int32; var pcr: GDI_COLORREF): Int32;
external 'opengl32.dll' name 'wglGetLayerPaletteEntries';
public static z_GetLayerPaletteEntries_ovr1 := _z_GetLayerPaletteEntries_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetLayerPaletteEntries(hdc: GDI_DC; iLayerPlane: Int32; iStart: Int32; cEntries: Int32; var pcr: GDI_COLORREF): Int32 := z_GetLayerPaletteEntries_ovr1(hdc, iLayerPlane, iStart, cEntries, pcr);
private static function _z_GetLayerPaletteEntries_ovr2(hdc: GDI_DC; iLayerPlane: Int32; iStart: Int32; cEntries: Int32; pcr: IntPtr): Int32;
external 'opengl32.dll' name 'wglGetLayerPaletteEntries';
public static z_GetLayerPaletteEntries_ovr2 := _z_GetLayerPaletteEntries_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetLayerPaletteEntries(hdc: GDI_DC; iLayerPlane: Int32; iStart: Int32; cEntries: Int32; pcr: IntPtr): Int32 := z_GetLayerPaletteEntries_ovr2(hdc, iLayerPlane, iStart, cEntries, pcr);
// added in wgl1.0
private static function _z_GetProcAddress_ovr0(lpszProc: IntPtr): IntPtr;
external 'opengl32.dll' name 'wglGetProcAddress';
public static z_GetProcAddress_ovr0 := _z_GetProcAddress_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetProcAddress(lpszProc: IntPtr): IntPtr := z_GetProcAddress_ovr0(lpszProc);
// added in wgl1.0
private static function _z_MakeCurrent_ovr0(hDc: GDI_DC; newContext: GLContext): UInt32;
external 'opengl32.dll' name 'wglMakeCurrent';
public static z_MakeCurrent_ovr0 := _z_MakeCurrent_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function MakeCurrent(hDc: GDI_DC; newContext: GLContext): UInt32 := z_MakeCurrent_ovr0(hDc, newContext);
// added in wgl1.0
private static function _z_RealizeLayerPalette_ovr0(hdc: GDI_DC; iLayerPlane: Int32; bRealize: UInt32): UInt32;
external 'opengl32.dll' name 'wglRealizeLayerPalette';
public static z_RealizeLayerPalette_ovr0 := _z_RealizeLayerPalette_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function RealizeLayerPalette(hdc: GDI_DC; iLayerPlane: Int32; bRealize: UInt32): UInt32 := z_RealizeLayerPalette_ovr0(hdc, iLayerPlane, bRealize);
// added in wgl1.0
private static function _z_SetLayerPaletteEntries_ovr0(hdc: GDI_DC; iLayerPlane: Int32; iStart: Int32; cEntries: Int32; [MarshalAs(UnmanagedType.LPArray)] pcr: array of GDI_COLORREF): Int32;
external 'opengl32.dll' name 'wglSetLayerPaletteEntries';
public static z_SetLayerPaletteEntries_ovr0 := _z_SetLayerPaletteEntries_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetLayerPaletteEntries(hdc: GDI_DC; iLayerPlane: Int32; iStart: Int32; cEntries: Int32; pcr: array of GDI_COLORREF): Int32 := z_SetLayerPaletteEntries_ovr0(hdc, iLayerPlane, iStart, cEntries, pcr);
private static function _z_SetLayerPaletteEntries_ovr1(hdc: GDI_DC; iLayerPlane: Int32; iStart: Int32; cEntries: Int32; var pcr: GDI_COLORREF): Int32;
external 'opengl32.dll' name 'wglSetLayerPaletteEntries';
public static z_SetLayerPaletteEntries_ovr1 := _z_SetLayerPaletteEntries_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetLayerPaletteEntries(hdc: GDI_DC; iLayerPlane: Int32; iStart: Int32; cEntries: Int32; var pcr: GDI_COLORREF): Int32 := z_SetLayerPaletteEntries_ovr1(hdc, iLayerPlane, iStart, cEntries, pcr);
private static function _z_SetLayerPaletteEntries_ovr2(hdc: GDI_DC; iLayerPlane: Int32; iStart: Int32; cEntries: Int32; pcr: IntPtr): Int32;
external 'opengl32.dll' name 'wglSetLayerPaletteEntries';
public static z_SetLayerPaletteEntries_ovr2 := _z_SetLayerPaletteEntries_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetLayerPaletteEntries(hdc: GDI_DC; iLayerPlane: Int32; iStart: Int32; cEntries: Int32; pcr: IntPtr): Int32 := z_SetLayerPaletteEntries_ovr2(hdc, iLayerPlane, iStart, cEntries, pcr);
// added in wgl1.0
private static function _z_ShareLists_ovr0(hrcSrvShare: GLContext; hrcSrvSource: GLContext): UInt32;
external 'opengl32.dll' name 'wglShareLists';
public static z_ShareLists_ovr0 := _z_ShareLists_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ShareLists(hrcSrvShare: GLContext; hrcSrvSource: GLContext): UInt32 := z_ShareLists_ovr0(hrcSrvShare, hrcSrvSource);
// added in wgl1.0
private static function _z_SwapLayerBuffers_ovr0(hdc: GDI_DC; fuFlags: UInt32): UInt32;
external 'opengl32.dll' name 'wglSwapLayerBuffers';
public static z_SwapLayerBuffers_ovr0 := _z_SwapLayerBuffers_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SwapLayerBuffers(hdc: GDI_DC; fuFlags: UInt32): UInt32 := z_SwapLayerBuffers_ovr0(hdc, fuFlags);
// added in wgl1.0
private static function _z_UseFontBitmaps_ovr0(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32): UInt32;
external 'opengl32.dll' name 'wglUseFontBitmaps';
public static z_UseFontBitmaps_ovr0 := _z_UseFontBitmaps_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function UseFontBitmaps(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32): UInt32 := z_UseFontBitmaps_ovr0(hDC, first, count, listBase);
// added in wgl1.0
private static function _z_UseFontBitmapsA_ovr0(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32): UInt32;
external 'opengl32.dll' name 'wglUseFontBitmapsA';
public static z_UseFontBitmapsA_ovr0 := _z_UseFontBitmapsA_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function UseFontBitmapsA(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32): UInt32 := z_UseFontBitmapsA_ovr0(hDC, first, count, listBase);
// added in wgl1.0
private static function _z_UseFontBitmapsW_ovr0(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32): UInt32;
external 'opengl32.dll' name 'wglUseFontBitmapsW';
public static z_UseFontBitmapsW_ovr0 := _z_UseFontBitmapsW_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function UseFontBitmapsW(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32): UInt32 := z_UseFontBitmapsW_ovr0(hDC, first, count, listBase);
// added in wgl1.0
private static function _z_UseFontOutlines_ovr0(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32; deviation: single; extrusion: single; format: Int32; [MarshalAs(UnmanagedType.LPArray)] lpgmf: array of GDI_GlyphmetricsFloat): UInt32;
external 'opengl32.dll' name 'wglUseFontOutlines';
public static z_UseFontOutlines_ovr0 := _z_UseFontOutlines_ovr0;
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 := z_UseFontOutlines_ovr0(hDC, first, count, listBase, deviation, extrusion, format, lpgmf);
private static function _z_UseFontOutlines_ovr1(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';
public static z_UseFontOutlines_ovr1 := _z_UseFontOutlines_ovr1;
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_ovr1(hDC, first, count, listBase, deviation, extrusion, format, lpgmf);
private static function _z_UseFontOutlines_ovr2(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32; deviation: single; extrusion: single; format: Int32; lpgmf: IntPtr): UInt32;
external 'opengl32.dll' name 'wglUseFontOutlines';
public static z_UseFontOutlines_ovr2 := _z_UseFontOutlines_ovr2;
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_ovr2(hDC, first, count, listBase, deviation, extrusion, format, lpgmf);
// added in wgl1.0
private static function _z_UseFontOutlinesA_ovr0(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32; deviation: single; extrusion: single; format: Int32; [MarshalAs(UnmanagedType.LPArray)] lpgmf: array of GDI_GlyphmetricsFloat): UInt32;
external 'opengl32.dll' name 'wglUseFontOutlinesA';
public static z_UseFontOutlinesA_ovr0 := _z_UseFontOutlinesA_ovr0;
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 := z_UseFontOutlinesA_ovr0(hDC, first, count, listBase, deviation, extrusion, format, lpgmf);
private static function _z_UseFontOutlinesA_ovr1(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';
public static z_UseFontOutlinesA_ovr1 := _z_UseFontOutlinesA_ovr1;
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_ovr1(hDC, first, count, listBase, deviation, extrusion, format, lpgmf);
private static function _z_UseFontOutlinesA_ovr2(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32; deviation: single; extrusion: single; format: Int32; lpgmf: IntPtr): UInt32;
external 'opengl32.dll' name 'wglUseFontOutlinesA';
public static z_UseFontOutlinesA_ovr2 := _z_UseFontOutlinesA_ovr2;
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_ovr2(hDC, first, count, listBase, deviation, extrusion, format, lpgmf);
// added in wgl1.0
private static function _z_UseFontOutlinesW_ovr0(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32; deviation: single; extrusion: single; format: Int32; [MarshalAs(UnmanagedType.LPArray)] lpgmf: array of GDI_GlyphmetricsFloat): UInt32;
external 'opengl32.dll' name 'wglUseFontOutlinesW';
public static z_UseFontOutlinesW_ovr0 := _z_UseFontOutlinesW_ovr0;
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 := z_UseFontOutlinesW_ovr0(hDC, first, count, listBase, deviation, extrusion, format, lpgmf);
private static function _z_UseFontOutlinesW_ovr1(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';
public static z_UseFontOutlinesW_ovr1 := _z_UseFontOutlinesW_ovr1;
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_ovr1(hDC, first, count, listBase, deviation, extrusion, format, lpgmf);
private static function _z_UseFontOutlinesW_ovr2(hDC: GDI_DC; first: UInt32; count: UInt32; listBase: UInt32; deviation: single; extrusion: single; format: Int32; lpgmf: IntPtr): UInt32;
external 'opengl32.dll' name 'wglUseFontOutlinesW';
public static z_UseFontOutlinesW_ovr2 := _z_UseFontOutlinesW_ovr2;
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_ovr2(hDC, first, count, listBase, deviation, extrusion, format, lpgmf);
end;
gdi = static class
private static function _z_ChoosePixelFormat_ovr0(hDc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] pPfd: array of GDI_PixelFormatDescriptor): Int32;
external 'gdi32.dll' name 'ChoosePixelFormat';
public static z_ChoosePixelFormat_ovr0 := _z_ChoosePixelFormat_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormat(hDc: GDI_DC; pPfd: array of GDI_PixelFormatDescriptor): Int32 := z_ChoosePixelFormat_ovr0(hDc, pPfd);
private static function _z_ChoosePixelFormat_ovr1(hDc: GDI_DC; var pPfd: GDI_PixelFormatDescriptor): Int32;
external 'gdi32.dll' name 'ChoosePixelFormat';
public static z_ChoosePixelFormat_ovr1 := _z_ChoosePixelFormat_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormat(hDc: GDI_DC; var pPfd: GDI_PixelFormatDescriptor): Int32 := z_ChoosePixelFormat_ovr1(hDc, pPfd);
private static function _z_ChoosePixelFormat_ovr2(hDc: GDI_DC; pPfd: IntPtr): Int32;
external 'gdi32.dll' name 'ChoosePixelFormat';
public static z_ChoosePixelFormat_ovr2 := _z_ChoosePixelFormat_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormat(hDc: GDI_DC; pPfd: IntPtr): Int32 := z_ChoosePixelFormat_ovr2(hDc, pPfd);
private static function _z_DescribePixelFormat_ovr0(hdc: GDI_DC; ipfd: Int32; cjpfd: UInt32; [MarshalAs(UnmanagedType.LPArray)] ppfd: array of GDI_PixelFormatDescriptor): Int32;
external 'gdi32.dll' name 'DescribePixelFormat';
public static z_DescribePixelFormat_ovr0 := _z_DescribePixelFormat_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DescribePixelFormat(hdc: GDI_DC; ipfd: Int32; cjpfd: UInt32; ppfd: array of GDI_PixelFormatDescriptor): Int32 := z_DescribePixelFormat_ovr0(hdc, ipfd, cjpfd, ppfd);
private static function _z_DescribePixelFormat_ovr1(hdc: GDI_DC; ipfd: Int32; cjpfd: UInt32; var ppfd: GDI_PixelFormatDescriptor): Int32;
external 'gdi32.dll' name 'DescribePixelFormat';
public static z_DescribePixelFormat_ovr1 := _z_DescribePixelFormat_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DescribePixelFormat(hdc: GDI_DC; ipfd: Int32; cjpfd: UInt32; var ppfd: GDI_PixelFormatDescriptor): Int32 := z_DescribePixelFormat_ovr1(hdc, ipfd, cjpfd, ppfd);
private static function _z_DescribePixelFormat_ovr2(hdc: GDI_DC; ipfd: Int32; cjpfd: UInt32; ppfd: IntPtr): Int32;
external 'gdi32.dll' name 'DescribePixelFormat';
public static z_DescribePixelFormat_ovr2 := _z_DescribePixelFormat_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DescribePixelFormat(hdc: GDI_DC; ipfd: Int32; cjpfd: UInt32; ppfd: IntPtr): Int32 := z_DescribePixelFormat_ovr2(hdc, ipfd, cjpfd, ppfd);
private static function _z_GetEnhMetaFilePixelFormat_ovr0(hemf: GDI_HENHMetafile; [MarshalAs(UnmanagedType.LPArray)] ppfd: array of GDI_PixelFormatDescriptor): UInt32;
external 'gdi32.dll' name 'GetEnhMetaFilePixelFormat';
public static z_GetEnhMetaFilePixelFormat_ovr0 := _z_GetEnhMetaFilePixelFormat_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetEnhMetaFilePixelFormat(hemf: GDI_HENHMetafile; ppfd: array of GDI_PixelFormatDescriptor): UInt32 := z_GetEnhMetaFilePixelFormat_ovr0(hemf, ppfd);
private static function _z_GetEnhMetaFilePixelFormat_ovr1(hemf: GDI_HENHMetafile; var ppfd: GDI_PixelFormatDescriptor): UInt32;
external 'gdi32.dll' name 'GetEnhMetaFilePixelFormat';
public static z_GetEnhMetaFilePixelFormat_ovr1 := _z_GetEnhMetaFilePixelFormat_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetEnhMetaFilePixelFormat(hemf: GDI_HENHMetafile; var ppfd: GDI_PixelFormatDescriptor): UInt32 := z_GetEnhMetaFilePixelFormat_ovr1(hemf, ppfd);
private static function _z_GetEnhMetaFilePixelFormat_ovr2(hemf: GDI_HENHMetafile; ppfd: IntPtr): UInt32;
external 'gdi32.dll' name 'GetEnhMetaFilePixelFormat';
public static z_GetEnhMetaFilePixelFormat_ovr2 := _z_GetEnhMetaFilePixelFormat_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetEnhMetaFilePixelFormat(hemf: GDI_HENHMetafile; ppfd: IntPtr): UInt32 := z_GetEnhMetaFilePixelFormat_ovr2(hemf, ppfd);
private static function _z_GetPixelFormat_ovr0(hdc: GDI_DC): Int32;
external 'gdi32.dll' name 'GetPixelFormat';
public static z_GetPixelFormat_ovr0 := _z_GetPixelFormat_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormat(hdc: GDI_DC): Int32 := z_GetPixelFormat_ovr0(hdc);
private static function _z_SetPixelFormat_ovr0(hdc: GDI_DC; ipfd: Int32; [MarshalAs(UnmanagedType.LPArray)] ppfd: array of GDI_PixelFormatDescriptor): UInt32;
external 'gdi32.dll' name 'SetPixelFormat';
public static z_SetPixelFormat_ovr0 := _z_SetPixelFormat_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetPixelFormat(hdc: GDI_DC; ipfd: Int32; ppfd: array of GDI_PixelFormatDescriptor): UInt32 := z_SetPixelFormat_ovr0(hdc, ipfd, ppfd);
private static function _z_SetPixelFormat_ovr1(hdc: GDI_DC; ipfd: Int32; var ppfd: GDI_PixelFormatDescriptor): UInt32;
external 'gdi32.dll' name 'SetPixelFormat';
public static z_SetPixelFormat_ovr1 := _z_SetPixelFormat_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetPixelFormat(hdc: GDI_DC; ipfd: Int32; var ppfd: GDI_PixelFormatDescriptor): UInt32 := z_SetPixelFormat_ovr1(hdc, ipfd, ppfd);
private static function _z_SetPixelFormat_ovr2(hdc: GDI_DC; ipfd: Int32; ppfd: IntPtr): UInt32;
external 'gdi32.dll' name 'SetPixelFormat';
public static z_SetPixelFormat_ovr2 := _z_SetPixelFormat_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetPixelFormat(hdc: GDI_DC; ipfd: Int32; ppfd: IntPtr): UInt32 := z_SetPixelFormat_ovr2(hdc, ipfd, ppfd);
private static function _z_SwapBuffers_ovr0(hdc: GDI_DC): UInt32;
external 'gdi32.dll' name 'SwapBuffers';
public static z_SwapBuffers_ovr0 := _z_SwapBuffers_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SwapBuffers(hdc: GDI_DC): UInt32 := z_SwapBuffers_ovr0(hdc);
end;
{region Extensions}
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);
public z_TbufferMask3DFX_adr := GetFuncAdr('glTbufferMask3DFX');
public z_TbufferMask3DFX_ovr_0 := GetFuncOrNil&<procedure(mask: UInt32)>(z_TbufferMask3DFX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TbufferMask3DFX(mask: UInt32);
begin
z_TbufferMask3DFX_ovr_0(mask);
end;
end;
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);
public z_DebugMessageEnableAMD_adr := GetFuncAdr('glDebugMessageEnableAMD');
public z_DebugMessageEnableAMD_ovr_0 := GetFuncOrNil&<procedure(category: DummyEnum; severity: DebugSeverity; count: Int32; var ids: UInt32; enabled: boolean)>(z_DebugMessageEnableAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageEnableAMD(category: DummyEnum; severity: DebugSeverity; count: Int32; ids: array of UInt32; enabled: boolean);
begin
z_DebugMessageEnableAMD_ovr_0(category, severity, count, ids[0], enabled);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageEnableAMD(category: DummyEnum; severity: DebugSeverity; count: Int32; var ids: UInt32; enabled: boolean);
begin
z_DebugMessageEnableAMD_ovr_0(category, severity, count, ids, enabled);
end;
public z_DebugMessageEnableAMD_ovr_2 := GetFuncOrNil&<procedure(category: DummyEnum; severity: DebugSeverity; count: Int32; ids: IntPtr; enabled: boolean)>(z_DebugMessageEnableAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageEnableAMD(category: DummyEnum; severity: DebugSeverity; count: Int32; ids: IntPtr; enabled: boolean);
begin
z_DebugMessageEnableAMD_ovr_2(category, severity, count, ids, enabled);
end;
public z_DebugMessageInsertAMD_adr := GetFuncAdr('glDebugMessageInsertAMD');
public z_DebugMessageInsertAMD_ovr_0 := GetFuncOrNil&<procedure(category: DummyEnum; severity: DebugSeverity; id: UInt32; length: Int32; buf: IntPtr)>(z_DebugMessageInsertAMD_adr);
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);
begin
z_DebugMessageInsertAMD_ovr_0(category, severity, id, length, buf);
end;
public z_DebugMessageCallbackAMD_adr := GetFuncAdr('glDebugMessageCallbackAMD');
public z_DebugMessageCallbackAMD_ovr_0 := GetFuncOrNil&<procedure(callback: GLDEBUGPROC; userParam: IntPtr)>(z_DebugMessageCallbackAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageCallbackAMD(callback: GLDEBUGPROC; userParam: IntPtr);
begin
z_DebugMessageCallbackAMD_ovr_0(callback, userParam);
end;
public z_GetDebugMessageLogAMD_adr := GetFuncAdr('glGetDebugMessageLogAMD');
public z_GetDebugMessageLogAMD_ovr_0 := GetFuncOrNil&<function(count: UInt32; bufSize: Int32; var categories: DummyEnum; var severities: UInt32; var ids: UInt32; var lengths: Int32; message: IntPtr): UInt32>(z_GetDebugMessageLogAMD_adr);
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;
begin
Result := z_GetDebugMessageLogAMD_ovr_0(count, bufSize, categories, severities, ids, lengths, message);
end;
public z_GetDebugMessageLogAMD_ovr_1 := GetFuncOrNil&<function(count: UInt32; bufSize: Int32; categories: IntPtr; severities: IntPtr; ids: IntPtr; lengths: IntPtr; message: IntPtr): UInt32>(z_GetDebugMessageLogAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetDebugMessageLogAMD(count: UInt32; bufSize: Int32; categories: IntPtr; severities: IntPtr; ids: IntPtr; lengths: IntPtr; message: IntPtr): UInt32;
begin
Result := z_GetDebugMessageLogAMD_ovr_1(count, bufSize, categories, severities, ids, lengths, message);
end;
end;
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);
public z_BlendFuncIndexedAMD_adr := GetFuncAdr('glBlendFuncIndexedAMD');
public z_BlendFuncIndexedAMD_ovr_0 := GetFuncOrNil&<procedure(buf: UInt32; src: DummyEnum; dst: DummyEnum)>(z_BlendFuncIndexedAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendFuncIndexedAMD(buf: UInt32; src: DummyEnum; dst: DummyEnum);
begin
z_BlendFuncIndexedAMD_ovr_0(buf, src, dst);
end;
public z_BlendFuncSeparateIndexedAMD_adr := GetFuncAdr('glBlendFuncSeparateIndexedAMD');
public z_BlendFuncSeparateIndexedAMD_ovr_0 := GetFuncOrNil&<procedure(buf: UInt32; srcRGB: BlendingFactor; dstRGB: BlendingFactor; srcAlpha: BlendingFactor; dstAlpha: BlendingFactor)>(z_BlendFuncSeparateIndexedAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendFuncSeparateIndexedAMD(buf: UInt32; srcRGB: BlendingFactor; dstRGB: BlendingFactor; srcAlpha: BlendingFactor; dstAlpha: BlendingFactor);
begin
z_BlendFuncSeparateIndexedAMD_ovr_0(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
end;
public z_BlendEquationIndexedAMD_adr := GetFuncAdr('glBlendEquationIndexedAMD');
public z_BlendEquationIndexedAMD_ovr_0 := GetFuncOrNil&<procedure(buf: UInt32; mode: BlendEquationModeEXT)>(z_BlendEquationIndexedAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendEquationIndexedAMD(buf: UInt32; mode: BlendEquationModeEXT);
begin
z_BlendEquationIndexedAMD_ovr_0(buf, mode);
end;
public z_BlendEquationSeparateIndexedAMD_adr := GetFuncAdr('glBlendEquationSeparateIndexedAMD');
public z_BlendEquationSeparateIndexedAMD_ovr_0 := GetFuncOrNil&<procedure(buf: UInt32; modeRGB: BlendEquationModeEXT; modeAlpha: BlendEquationModeEXT)>(z_BlendEquationSeparateIndexedAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendEquationSeparateIndexedAMD(buf: UInt32; modeRGB: BlendEquationModeEXT; modeAlpha: BlendEquationModeEXT);
begin
z_BlendEquationSeparateIndexedAMD_ovr_0(buf, modeRGB, modeAlpha);
end;
end;
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);
public z_RenderbufferStorageMultisampleAdvancedAMD_adr := GetFuncAdr('glRenderbufferStorageMultisampleAdvancedAMD');
public z_RenderbufferStorageMultisampleAdvancedAMD_ovr_0 := GetFuncOrNil&<procedure(target: RenderbufferTarget; samples: Int32; storageSamples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32)>(z_RenderbufferStorageMultisampleAdvancedAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RenderbufferStorageMultisampleAdvancedAMD(target: RenderbufferTarget; samples: Int32; storageSamples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32);
begin
z_RenderbufferStorageMultisampleAdvancedAMD_ovr_0(target, samples, storageSamples, _internalformat, width, height);
end;
public z_NamedRenderbufferStorageMultisampleAdvancedAMD_adr := GetFuncAdr('glNamedRenderbufferStorageMultisampleAdvancedAMD');
public z_NamedRenderbufferStorageMultisampleAdvancedAMD_ovr_0 := GetFuncOrNil&<procedure(renderbuffer: UInt32; samples: Int32; storageSamples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32)>(z_NamedRenderbufferStorageMultisampleAdvancedAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedRenderbufferStorageMultisampleAdvancedAMD(renderbuffer: UInt32; samples: Int32; storageSamples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32);
begin
z_NamedRenderbufferStorageMultisampleAdvancedAMD_ovr_0(renderbuffer, samples, storageSamples, _internalformat, width, height);
end;
end;
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);
public z_FramebufferSamplePositionsfvAMD_adr := GetFuncAdr('glFramebufferSamplePositionsfvAMD');
public z_FramebufferSamplePositionsfvAMD_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; numsamples: UInt32; pixelindex: UInt32; var values: single)>(z_FramebufferSamplePositionsfvAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferSamplePositionsfvAMD(target: FramebufferTarget; numsamples: UInt32; pixelindex: UInt32; values: array of single);
begin
z_FramebufferSamplePositionsfvAMD_ovr_0(target, numsamples, pixelindex, values[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferSamplePositionsfvAMD(target: FramebufferTarget; numsamples: UInt32; pixelindex: UInt32; var values: single);
begin
z_FramebufferSamplePositionsfvAMD_ovr_0(target, numsamples, pixelindex, values);
end;
public z_FramebufferSamplePositionsfvAMD_ovr_2 := GetFuncOrNil&<procedure(target: FramebufferTarget; numsamples: UInt32; pixelindex: UInt32; values: IntPtr)>(z_FramebufferSamplePositionsfvAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferSamplePositionsfvAMD(target: FramebufferTarget; numsamples: UInt32; pixelindex: UInt32; values: IntPtr);
begin
z_FramebufferSamplePositionsfvAMD_ovr_2(target, numsamples, pixelindex, values);
end;
public z_NamedFramebufferSamplePositionsfvAMD_adr := GetFuncAdr('glNamedFramebufferSamplePositionsfvAMD');
public z_NamedFramebufferSamplePositionsfvAMD_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; numsamples: UInt32; pixelindex: UInt32; var values: single)>(z_NamedFramebufferSamplePositionsfvAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferSamplePositionsfvAMD(framebuffer: UInt32; numsamples: UInt32; pixelindex: UInt32; values: array of single);
begin
z_NamedFramebufferSamplePositionsfvAMD_ovr_0(framebuffer, numsamples, pixelindex, values[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferSamplePositionsfvAMD(framebuffer: UInt32; numsamples: UInt32; pixelindex: UInt32; var values: single);
begin
z_NamedFramebufferSamplePositionsfvAMD_ovr_0(framebuffer, numsamples, pixelindex, values);
end;
public z_NamedFramebufferSamplePositionsfvAMD_ovr_2 := GetFuncOrNil&<procedure(framebuffer: UInt32; numsamples: UInt32; pixelindex: UInt32; values: IntPtr)>(z_NamedFramebufferSamplePositionsfvAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferSamplePositionsfvAMD(framebuffer: UInt32; numsamples: UInt32; pixelindex: UInt32; values: IntPtr);
begin
z_NamedFramebufferSamplePositionsfvAMD_ovr_2(framebuffer, numsamples, pixelindex, values);
end;
public z_GetFramebufferParameterfvAMD_adr := GetFuncAdr('glGetFramebufferParameterfvAMD');
public z_GetFramebufferParameterfvAMD_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; numsamples: UInt32; pixelindex: UInt32; size: Int32; var values: single)>(z_GetFramebufferParameterfvAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferParameterfvAMD(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; numsamples: UInt32; pixelindex: UInt32; size: Int32; values: array of single);
begin
z_GetFramebufferParameterfvAMD_ovr_0(target, pname, numsamples, pixelindex, size, values[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferParameterfvAMD(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; numsamples: UInt32; pixelindex: UInt32; size: Int32; var values: single);
begin
z_GetFramebufferParameterfvAMD_ovr_0(target, pname, numsamples, pixelindex, size, values);
end;
public z_GetFramebufferParameterfvAMD_ovr_2 := GetFuncOrNil&<procedure(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; numsamples: UInt32; pixelindex: UInt32; size: Int32; values: IntPtr)>(z_GetFramebufferParameterfvAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferParameterfvAMD(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; numsamples: UInt32; pixelindex: UInt32; size: Int32; values: IntPtr);
begin
z_GetFramebufferParameterfvAMD_ovr_2(target, pname, numsamples, pixelindex, size, values);
end;
public z_GetNamedFramebufferParameterfvAMD_adr := GetFuncAdr('glGetNamedFramebufferParameterfvAMD');
public z_GetNamedFramebufferParameterfvAMD_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; pname: DummyEnum; numsamples: UInt32; pixelindex: UInt32; size: Int32; var values: single)>(z_GetNamedFramebufferParameterfvAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferParameterfvAMD(framebuffer: UInt32; pname: DummyEnum; numsamples: UInt32; pixelindex: UInt32; size: Int32; values: array of single);
begin
z_GetNamedFramebufferParameterfvAMD_ovr_0(framebuffer, pname, numsamples, pixelindex, size, values[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferParameterfvAMD(framebuffer: UInt32; pname: DummyEnum; numsamples: UInt32; pixelindex: UInt32; size: Int32; var values: single);
begin
z_GetNamedFramebufferParameterfvAMD_ovr_0(framebuffer, pname, numsamples, pixelindex, size, values);
end;
public z_GetNamedFramebufferParameterfvAMD_ovr_2 := GetFuncOrNil&<procedure(framebuffer: UInt32; pname: DummyEnum; numsamples: UInt32; pixelindex: UInt32; size: Int32; values: IntPtr)>(z_GetNamedFramebufferParameterfvAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferParameterfvAMD(framebuffer: UInt32; pname: DummyEnum; numsamples: UInt32; pixelindex: UInt32; size: Int32; values: IntPtr);
begin
z_GetNamedFramebufferParameterfvAMD_ovr_2(framebuffer, pname, numsamples, pixelindex, size, values);
end;
end;
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);
end;
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);
public z_VertexAttribParameteriAMD_adr := GetFuncAdr('glVertexAttribParameteriAMD');
public z_VertexAttribParameteriAMD_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: DummyEnum; param: Int32)>(z_VertexAttribParameteriAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribParameteriAMD(index: UInt32; pname: DummyEnum; param: Int32);
begin
z_VertexAttribParameteriAMD_ovr_0(index, pname, param);
end;
end;
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);
public z_MultiDrawArraysIndirectAMD_adr := GetFuncAdr('glMultiDrawArraysIndirectAMD');
public z_MultiDrawArraysIndirectAMD_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; indirect: IntPtr; primcount: Int32; stride: Int32)>(z_MultiDrawArraysIndirectAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysIndirectAMD(mode: PrimitiveType; indirect: IntPtr; primcount: Int32; stride: Int32);
begin
z_MultiDrawArraysIndirectAMD_ovr_0(mode, indirect, primcount, stride);
end;
public z_MultiDrawElementsIndirectAMD_adr := GetFuncAdr('glMultiDrawElementsIndirectAMD');
public z_MultiDrawElementsIndirectAMD_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; &type: DrawElementsType; indirect: IntPtr; primcount: Int32; stride: Int32)>(z_MultiDrawElementsIndirectAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsIndirectAMD(mode: PrimitiveType; &type: DrawElementsType; indirect: IntPtr; primcount: Int32; stride: Int32);
begin
z_MultiDrawElementsIndirectAMD_ovr_0(mode, &type, indirect, primcount, stride);
end;
end;
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);
public z_GenNamesAMD_adr := GetFuncAdr('glGenNamesAMD');
public z_GenNamesAMD_ovr_0 := GetFuncOrNil&<procedure(identifier: DummyEnum; num: UInt32; var names: UInt32)>(z_GenNamesAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenNamesAMD(identifier: DummyEnum; num: UInt32; names: array of UInt32);
begin
z_GenNamesAMD_ovr_0(identifier, num, names[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenNamesAMD(identifier: DummyEnum; num: UInt32; var names: UInt32);
begin
z_GenNamesAMD_ovr_0(identifier, num, names);
end;
public z_GenNamesAMD_ovr_2 := GetFuncOrNil&<procedure(identifier: DummyEnum; num: UInt32; names: IntPtr)>(z_GenNamesAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenNamesAMD(identifier: DummyEnum; num: UInt32; names: IntPtr);
begin
z_GenNamesAMD_ovr_2(identifier, num, names);
end;
public z_DeleteNamesAMD_adr := GetFuncAdr('glDeleteNamesAMD');
public z_DeleteNamesAMD_ovr_0 := GetFuncOrNil&<procedure(identifier: DummyEnum; num: UInt32; var names: UInt32)>(z_DeleteNamesAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteNamesAMD(identifier: DummyEnum; num: UInt32; names: array of UInt32);
begin
z_DeleteNamesAMD_ovr_0(identifier, num, names[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteNamesAMD(identifier: DummyEnum; num: UInt32; var names: UInt32);
begin
z_DeleteNamesAMD_ovr_0(identifier, num, names);
end;
public z_DeleteNamesAMD_ovr_2 := GetFuncOrNil&<procedure(identifier: DummyEnum; num: UInt32; names: IntPtr)>(z_DeleteNamesAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteNamesAMD(identifier: DummyEnum; num: UInt32; names: IntPtr);
begin
z_DeleteNamesAMD_ovr_2(identifier, num, names);
end;
public z_IsNameAMD_adr := GetFuncAdr('glIsNameAMD');
public z_IsNameAMD_ovr_0 := GetFuncOrNil&<function(identifier: DummyEnum; name: UInt32): boolean>(z_IsNameAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsNameAMD(identifier: DummyEnum; name: UInt32): boolean;
begin
Result := z_IsNameAMD_ovr_0(identifier, name);
end;
end;
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);
public z_QueryObjectParameteruiAMD_adr := GetFuncAdr('glQueryObjectParameteruiAMD');
public z_QueryObjectParameteruiAMD_ovr_0 := GetFuncOrNil&<procedure(target: QueryTarget; id: UInt32; pname: DummyEnum; param: UInt32)>(z_QueryObjectParameteruiAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure QueryObjectParameteruiAMD(target: QueryTarget; id: UInt32; pname: DummyEnum; param: UInt32);
begin
z_QueryObjectParameteruiAMD_ovr_0(target, id, pname, param);
end;
end;
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);
public z_GetPerfMonitorGroupsAMD_adr := GetFuncAdr('glGetPerfMonitorGroupsAMD');
public z_GetPerfMonitorGroupsAMD_ovr_0 := GetFuncOrNil&<procedure(var numGroups: Int32; groupsSize: Int32; var groups: UInt32)>(z_GetPerfMonitorGroupsAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorGroupsAMD(numGroups: array of Int32; groupsSize: Int32; groups: array of UInt32);
begin
z_GetPerfMonitorGroupsAMD_ovr_0(numGroups[0], groupsSize, groups[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorGroupsAMD(numGroups: array of Int32; groupsSize: Int32; var groups: UInt32);
begin
z_GetPerfMonitorGroupsAMD_ovr_0(numGroups[0], groupsSize, groups);
end;
public z_GetPerfMonitorGroupsAMD_ovr_2 := GetFuncOrNil&<procedure(var numGroups: Int32; groupsSize: Int32; groups: IntPtr)>(z_GetPerfMonitorGroupsAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorGroupsAMD(numGroups: array of Int32; groupsSize: Int32; groups: IntPtr);
begin
z_GetPerfMonitorGroupsAMD_ovr_2(numGroups[0], groupsSize, groups);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorGroupsAMD(var numGroups: Int32; groupsSize: Int32; groups: array of UInt32);
begin
z_GetPerfMonitorGroupsAMD_ovr_0(numGroups, groupsSize, groups[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorGroupsAMD(var numGroups: Int32; groupsSize: Int32; var groups: UInt32);
begin
z_GetPerfMonitorGroupsAMD_ovr_0(numGroups, groupsSize, groups);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorGroupsAMD(var numGroups: Int32; groupsSize: Int32; groups: IntPtr);
begin
z_GetPerfMonitorGroupsAMD_ovr_2(numGroups, groupsSize, groups);
end;
public z_GetPerfMonitorGroupsAMD_ovr_6 := GetFuncOrNil&<procedure(numGroups: IntPtr; groupsSize: Int32; var groups: UInt32)>(z_GetPerfMonitorGroupsAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorGroupsAMD(numGroups: IntPtr; groupsSize: Int32; groups: array of UInt32);
begin
z_GetPerfMonitorGroupsAMD_ovr_6(numGroups, groupsSize, groups[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorGroupsAMD(numGroups: IntPtr; groupsSize: Int32; var groups: UInt32);
begin
z_GetPerfMonitorGroupsAMD_ovr_6(numGroups, groupsSize, groups);
end;
public z_GetPerfMonitorGroupsAMD_ovr_8 := GetFuncOrNil&<procedure(numGroups: IntPtr; groupsSize: Int32; groups: IntPtr)>(z_GetPerfMonitorGroupsAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorGroupsAMD(numGroups: IntPtr; groupsSize: Int32; groups: IntPtr);
begin
z_GetPerfMonitorGroupsAMD_ovr_8(numGroups, groupsSize, groups);
end;
public z_GetPerfMonitorCountersAMD_adr := GetFuncAdr('glGetPerfMonitorCountersAMD');
public z_GetPerfMonitorCountersAMD_ovr_0 := GetFuncOrNil&<procedure(group: UInt32; var numCounters: Int32; var maxActiveCounters: Int32; counterSize: Int32; var counters: UInt32)>(z_GetPerfMonitorCountersAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: array of Int32; maxActiveCounters: array of Int32; counterSize: Int32; counters: array of UInt32);
begin
z_GetPerfMonitorCountersAMD_ovr_0(group, numCounters[0], maxActiveCounters[0], counterSize, counters[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: array of Int32; maxActiveCounters: array of Int32; counterSize: Int32; var counters: UInt32);
begin
z_GetPerfMonitorCountersAMD_ovr_0(group, numCounters[0], maxActiveCounters[0], counterSize, counters);
end;
public z_GetPerfMonitorCountersAMD_ovr_2 := GetFuncOrNil&<procedure(group: UInt32; var numCounters: Int32; var maxActiveCounters: Int32; counterSize: Int32; counters: IntPtr)>(z_GetPerfMonitorCountersAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: array of Int32; maxActiveCounters: array of Int32; counterSize: Int32; counters: IntPtr);
begin
z_GetPerfMonitorCountersAMD_ovr_2(group, numCounters[0], maxActiveCounters[0], counterSize, counters);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: array of Int32; var maxActiveCounters: Int32; counterSize: Int32; counters: array of UInt32);
begin
z_GetPerfMonitorCountersAMD_ovr_0(group, numCounters[0], maxActiveCounters, counterSize, counters[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: array of Int32; var maxActiveCounters: Int32; counterSize: Int32; var counters: UInt32);
begin
z_GetPerfMonitorCountersAMD_ovr_0(group, numCounters[0], maxActiveCounters, counterSize, counters);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: array of Int32; var maxActiveCounters: Int32; counterSize: Int32; counters: IntPtr);
begin
z_GetPerfMonitorCountersAMD_ovr_2(group, numCounters[0], maxActiveCounters, counterSize, counters);
end;
public z_GetPerfMonitorCountersAMD_ovr_6 := GetFuncOrNil&<procedure(group: UInt32; var numCounters: Int32; maxActiveCounters: IntPtr; counterSize: Int32; var counters: UInt32)>(z_GetPerfMonitorCountersAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: array of Int32; maxActiveCounters: IntPtr; counterSize: Int32; counters: array of UInt32);
begin
z_GetPerfMonitorCountersAMD_ovr_6(group, numCounters[0], maxActiveCounters, counterSize, counters[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: array of Int32; maxActiveCounters: IntPtr; counterSize: Int32; var counters: UInt32);
begin
z_GetPerfMonitorCountersAMD_ovr_6(group, numCounters[0], maxActiveCounters, counterSize, counters);
end;
public z_GetPerfMonitorCountersAMD_ovr_8 := GetFuncOrNil&<procedure(group: UInt32; var numCounters: Int32; maxActiveCounters: IntPtr; counterSize: Int32; counters: IntPtr)>(z_GetPerfMonitorCountersAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: array of Int32; maxActiveCounters: IntPtr; counterSize: Int32; counters: IntPtr);
begin
z_GetPerfMonitorCountersAMD_ovr_8(group, numCounters[0], maxActiveCounters, counterSize, counters);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; var numCounters: Int32; maxActiveCounters: array of Int32; counterSize: Int32; counters: array of UInt32);
begin
z_GetPerfMonitorCountersAMD_ovr_0(group, numCounters, maxActiveCounters[0], counterSize, counters[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; var numCounters: Int32; maxActiveCounters: array of Int32; counterSize: Int32; var counters: UInt32);
begin
z_GetPerfMonitorCountersAMD_ovr_0(group, numCounters, maxActiveCounters[0], counterSize, counters);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; var numCounters: Int32; maxActiveCounters: array of Int32; counterSize: Int32; counters: IntPtr);
begin
z_GetPerfMonitorCountersAMD_ovr_2(group, numCounters, maxActiveCounters[0], counterSize, counters);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; var numCounters: Int32; var maxActiveCounters: Int32; counterSize: Int32; counters: array of UInt32);
begin
z_GetPerfMonitorCountersAMD_ovr_0(group, numCounters, maxActiveCounters, counterSize, counters[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; var numCounters: Int32; var maxActiveCounters: Int32; counterSize: Int32; var counters: UInt32);
begin
z_GetPerfMonitorCountersAMD_ovr_0(group, numCounters, maxActiveCounters, counterSize, counters);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; var numCounters: Int32; var maxActiveCounters: Int32; counterSize: Int32; counters: IntPtr);
begin
z_GetPerfMonitorCountersAMD_ovr_2(group, numCounters, maxActiveCounters, counterSize, counters);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; var numCounters: Int32; maxActiveCounters: IntPtr; counterSize: Int32; counters: array of UInt32);
begin
z_GetPerfMonitorCountersAMD_ovr_6(group, numCounters, maxActiveCounters, counterSize, counters[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; var numCounters: Int32; maxActiveCounters: IntPtr; counterSize: Int32; var counters: UInt32);
begin
z_GetPerfMonitorCountersAMD_ovr_6(group, numCounters, maxActiveCounters, counterSize, counters);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; var numCounters: Int32; maxActiveCounters: IntPtr; counterSize: Int32; counters: IntPtr);
begin
z_GetPerfMonitorCountersAMD_ovr_8(group, numCounters, maxActiveCounters, counterSize, counters);
end;
public z_GetPerfMonitorCountersAMD_ovr_18 := GetFuncOrNil&<procedure(group: UInt32; numCounters: IntPtr; var maxActiveCounters: Int32; counterSize: Int32; var counters: UInt32)>(z_GetPerfMonitorCountersAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: IntPtr; maxActiveCounters: array of Int32; counterSize: Int32; counters: array of UInt32);
begin
z_GetPerfMonitorCountersAMD_ovr_18(group, numCounters, maxActiveCounters[0], counterSize, counters[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: IntPtr; maxActiveCounters: array of Int32; counterSize: Int32; var counters: UInt32);
begin
z_GetPerfMonitorCountersAMD_ovr_18(group, numCounters, maxActiveCounters[0], counterSize, counters);
end;
public z_GetPerfMonitorCountersAMD_ovr_20 := GetFuncOrNil&<procedure(group: UInt32; numCounters: IntPtr; var maxActiveCounters: Int32; counterSize: Int32; counters: IntPtr)>(z_GetPerfMonitorCountersAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: IntPtr; maxActiveCounters: array of Int32; counterSize: Int32; counters: IntPtr);
begin
z_GetPerfMonitorCountersAMD_ovr_20(group, numCounters, maxActiveCounters[0], counterSize, counters);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: IntPtr; var maxActiveCounters: Int32; counterSize: Int32; counters: array of UInt32);
begin
z_GetPerfMonitorCountersAMD_ovr_18(group, numCounters, maxActiveCounters, counterSize, counters[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: IntPtr; var maxActiveCounters: Int32; counterSize: Int32; var counters: UInt32);
begin
z_GetPerfMonitorCountersAMD_ovr_18(group, numCounters, maxActiveCounters, counterSize, counters);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: IntPtr; var maxActiveCounters: Int32; counterSize: Int32; counters: IntPtr);
begin
z_GetPerfMonitorCountersAMD_ovr_20(group, numCounters, maxActiveCounters, counterSize, counters);
end;
public z_GetPerfMonitorCountersAMD_ovr_24 := GetFuncOrNil&<procedure(group: UInt32; numCounters: IntPtr; maxActiveCounters: IntPtr; counterSize: Int32; var counters: UInt32)>(z_GetPerfMonitorCountersAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: IntPtr; maxActiveCounters: IntPtr; counterSize: Int32; counters: array of UInt32);
begin
z_GetPerfMonitorCountersAMD_ovr_24(group, numCounters, maxActiveCounters, counterSize, counters[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: IntPtr; maxActiveCounters: IntPtr; counterSize: Int32; var counters: UInt32);
begin
z_GetPerfMonitorCountersAMD_ovr_24(group, numCounters, maxActiveCounters, counterSize, counters);
end;
public z_GetPerfMonitorCountersAMD_ovr_26 := GetFuncOrNil&<procedure(group: UInt32; numCounters: IntPtr; maxActiveCounters: IntPtr; counterSize: Int32; counters: IntPtr)>(z_GetPerfMonitorCountersAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCountersAMD(group: UInt32; numCounters: IntPtr; maxActiveCounters: IntPtr; counterSize: Int32; counters: IntPtr);
begin
z_GetPerfMonitorCountersAMD_ovr_26(group, numCounters, maxActiveCounters, counterSize, counters);
end;
public z_GetPerfMonitorGroupStringAMD_adr := GetFuncAdr('glGetPerfMonitorGroupStringAMD');
public z_GetPerfMonitorGroupStringAMD_ovr_0 := GetFuncOrNil&<procedure(group: UInt32; bufSize: Int32; var length: Int32; groupString: IntPtr)>(z_GetPerfMonitorGroupStringAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorGroupStringAMD(group: UInt32; bufSize: Int32; length: array of Int32; groupString: IntPtr);
begin
z_GetPerfMonitorGroupStringAMD_ovr_0(group, bufSize, length[0], groupString);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorGroupStringAMD(group: UInt32; bufSize: Int32; var length: Int32; groupString: IntPtr);
begin
z_GetPerfMonitorGroupStringAMD_ovr_0(group, bufSize, length, groupString);
end;
public z_GetPerfMonitorGroupStringAMD_ovr_2 := GetFuncOrNil&<procedure(group: UInt32; bufSize: Int32; length: IntPtr; groupString: IntPtr)>(z_GetPerfMonitorGroupStringAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorGroupStringAMD(group: UInt32; bufSize: Int32; length: IntPtr; groupString: IntPtr);
begin
z_GetPerfMonitorGroupStringAMD_ovr_2(group, bufSize, length, groupString);
end;
public z_GetPerfMonitorCounterStringAMD_adr := GetFuncAdr('glGetPerfMonitorCounterStringAMD');
public z_GetPerfMonitorCounterStringAMD_ovr_0 := GetFuncOrNil&<procedure(group: UInt32; counter: UInt32; bufSize: Int32; var length: Int32; counterString: IntPtr)>(z_GetPerfMonitorCounterStringAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCounterStringAMD(group: UInt32; counter: UInt32; bufSize: Int32; length: array of Int32; counterString: IntPtr);
begin
z_GetPerfMonitorCounterStringAMD_ovr_0(group, counter, bufSize, length[0], counterString);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCounterStringAMD(group: UInt32; counter: UInt32; bufSize: Int32; var length: Int32; counterString: IntPtr);
begin
z_GetPerfMonitorCounterStringAMD_ovr_0(group, counter, bufSize, length, counterString);
end;
public z_GetPerfMonitorCounterStringAMD_ovr_2 := GetFuncOrNil&<procedure(group: UInt32; counter: UInt32; bufSize: Int32; length: IntPtr; counterString: IntPtr)>(z_GetPerfMonitorCounterStringAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCounterStringAMD(group: UInt32; counter: UInt32; bufSize: Int32; length: IntPtr; counterString: IntPtr);
begin
z_GetPerfMonitorCounterStringAMD_ovr_2(group, counter, bufSize, length, counterString);
end;
public z_GetPerfMonitorCounterInfoAMD_adr := GetFuncAdr('glGetPerfMonitorCounterInfoAMD');
public z_GetPerfMonitorCounterInfoAMD_ovr_0 := GetFuncOrNil&<procedure(group: UInt32; counter: UInt32; pname: DummyEnum; data: IntPtr)>(z_GetPerfMonitorCounterInfoAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCounterInfoAMD(group: UInt32; counter: UInt32; pname: DummyEnum; data: IntPtr);
begin
z_GetPerfMonitorCounterInfoAMD_ovr_0(group, counter, pname, data);
end;
public z_GenPerfMonitorsAMD_adr := GetFuncAdr('glGenPerfMonitorsAMD');
public z_GenPerfMonitorsAMD_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var monitors: UInt32)>(z_GenPerfMonitorsAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenPerfMonitorsAMD(n: Int32; monitors: array of UInt32);
begin
z_GenPerfMonitorsAMD_ovr_0(n, monitors[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenPerfMonitorsAMD(n: Int32; var monitors: UInt32);
begin
z_GenPerfMonitorsAMD_ovr_0(n, monitors);
end;
public z_GenPerfMonitorsAMD_ovr_2 := GetFuncOrNil&<procedure(n: Int32; monitors: IntPtr)>(z_GenPerfMonitorsAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenPerfMonitorsAMD(n: Int32; monitors: IntPtr);
begin
z_GenPerfMonitorsAMD_ovr_2(n, monitors);
end;
public z_DeletePerfMonitorsAMD_adr := GetFuncAdr('glDeletePerfMonitorsAMD');
public z_DeletePerfMonitorsAMD_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var monitors: UInt32)>(z_DeletePerfMonitorsAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeletePerfMonitorsAMD(n: Int32; monitors: array of UInt32);
begin
z_DeletePerfMonitorsAMD_ovr_0(n, monitors[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeletePerfMonitorsAMD(n: Int32; var monitors: UInt32);
begin
z_DeletePerfMonitorsAMD_ovr_0(n, monitors);
end;
public z_DeletePerfMonitorsAMD_ovr_2 := GetFuncOrNil&<procedure(n: Int32; monitors: IntPtr)>(z_DeletePerfMonitorsAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeletePerfMonitorsAMD(n: Int32; monitors: IntPtr);
begin
z_DeletePerfMonitorsAMD_ovr_2(n, monitors);
end;
public z_SelectPerfMonitorCountersAMD_adr := GetFuncAdr('glSelectPerfMonitorCountersAMD');
public z_SelectPerfMonitorCountersAMD_ovr_0 := GetFuncOrNil&<procedure(monitor: UInt32; enable: boolean; group: UInt32; numCounters: Int32; var counterList: UInt32)>(z_SelectPerfMonitorCountersAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SelectPerfMonitorCountersAMD(monitor: UInt32; enable: boolean; group: UInt32; numCounters: Int32; counterList: array of UInt32);
begin
z_SelectPerfMonitorCountersAMD_ovr_0(monitor, enable, group, numCounters, counterList[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SelectPerfMonitorCountersAMD(monitor: UInt32; enable: boolean; group: UInt32; numCounters: Int32; var counterList: UInt32);
begin
z_SelectPerfMonitorCountersAMD_ovr_0(monitor, enable, group, numCounters, counterList);
end;
public z_SelectPerfMonitorCountersAMD_ovr_2 := GetFuncOrNil&<procedure(monitor: UInt32; enable: boolean; group: UInt32; numCounters: Int32; counterList: IntPtr)>(z_SelectPerfMonitorCountersAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SelectPerfMonitorCountersAMD(monitor: UInt32; enable: boolean; group: UInt32; numCounters: Int32; counterList: IntPtr);
begin
z_SelectPerfMonitorCountersAMD_ovr_2(monitor, enable, group, numCounters, counterList);
end;
public z_BeginPerfMonitorAMD_adr := GetFuncAdr('glBeginPerfMonitorAMD');
public z_BeginPerfMonitorAMD_ovr_0 := GetFuncOrNil&<procedure(monitor: UInt32)>(z_BeginPerfMonitorAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginPerfMonitorAMD(monitor: UInt32);
begin
z_BeginPerfMonitorAMD_ovr_0(monitor);
end;
public z_EndPerfMonitorAMD_adr := GetFuncAdr('glEndPerfMonitorAMD');
public z_EndPerfMonitorAMD_ovr_0 := GetFuncOrNil&<procedure(monitor: UInt32)>(z_EndPerfMonitorAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndPerfMonitorAMD(monitor: UInt32);
begin
z_EndPerfMonitorAMD_ovr_0(monitor);
end;
public z_GetPerfMonitorCounterDataAMD_adr := GetFuncAdr('glGetPerfMonitorCounterDataAMD');
public z_GetPerfMonitorCounterDataAMD_ovr_0 := GetFuncOrNil&<procedure(monitor: UInt32; pname: DummyEnum; dataSize: Int32; var data: UInt32; var bytesWritten: Int32)>(z_GetPerfMonitorCounterDataAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCounterDataAMD(monitor: UInt32; pname: DummyEnum; dataSize: Int32; data: array of UInt32; bytesWritten: array of Int32);
begin
z_GetPerfMonitorCounterDataAMD_ovr_0(monitor, pname, dataSize, data[0], bytesWritten[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCounterDataAMD(monitor: UInt32; pname: DummyEnum; dataSize: Int32; data: array of UInt32; var bytesWritten: Int32);
begin
z_GetPerfMonitorCounterDataAMD_ovr_0(monitor, pname, dataSize, data[0], bytesWritten);
end;
public z_GetPerfMonitorCounterDataAMD_ovr_2 := GetFuncOrNil&<procedure(monitor: UInt32; pname: DummyEnum; dataSize: Int32; var data: UInt32; bytesWritten: IntPtr)>(z_GetPerfMonitorCounterDataAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCounterDataAMD(monitor: UInt32; pname: DummyEnum; dataSize: Int32; data: array of UInt32; bytesWritten: IntPtr);
begin
z_GetPerfMonitorCounterDataAMD_ovr_2(monitor, pname, dataSize, data[0], bytesWritten);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCounterDataAMD(monitor: UInt32; pname: DummyEnum; dataSize: Int32; var data: UInt32; bytesWritten: array of Int32);
begin
z_GetPerfMonitorCounterDataAMD_ovr_0(monitor, pname, dataSize, data, bytesWritten[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCounterDataAMD(monitor: UInt32; pname: DummyEnum; dataSize: Int32; var data: UInt32; var bytesWritten: Int32);
begin
z_GetPerfMonitorCounterDataAMD_ovr_0(monitor, pname, dataSize, data, bytesWritten);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCounterDataAMD(monitor: UInt32; pname: DummyEnum; dataSize: Int32; var data: UInt32; bytesWritten: IntPtr);
begin
z_GetPerfMonitorCounterDataAMD_ovr_2(monitor, pname, dataSize, data, bytesWritten);
end;
public z_GetPerfMonitorCounterDataAMD_ovr_6 := GetFuncOrNil&<procedure(monitor: UInt32; pname: DummyEnum; dataSize: Int32; data: IntPtr; var bytesWritten: Int32)>(z_GetPerfMonitorCounterDataAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCounterDataAMD(monitor: UInt32; pname: DummyEnum; dataSize: Int32; data: IntPtr; bytesWritten: array of Int32);
begin
z_GetPerfMonitorCounterDataAMD_ovr_6(monitor, pname, dataSize, data, bytesWritten[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCounterDataAMD(monitor: UInt32; pname: DummyEnum; dataSize: Int32; data: IntPtr; var bytesWritten: Int32);
begin
z_GetPerfMonitorCounterDataAMD_ovr_6(monitor, pname, dataSize, data, bytesWritten);
end;
public z_GetPerfMonitorCounterDataAMD_ovr_8 := GetFuncOrNil&<procedure(monitor: UInt32; pname: DummyEnum; dataSize: Int32; data: IntPtr; bytesWritten: IntPtr)>(z_GetPerfMonitorCounterDataAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfMonitorCounterDataAMD(monitor: UInt32; pname: DummyEnum; dataSize: Int32; data: IntPtr; bytesWritten: IntPtr);
begin
z_GetPerfMonitorCounterDataAMD_ovr_8(monitor, pname, dataSize, data, bytesWritten);
end;
end;
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);
public z_SetMultisamplefvAMD_adr := GetFuncAdr('glSetMultisamplefvAMD');
public z_SetMultisamplefvAMD_ovr_0 := GetFuncOrNil&<procedure(pname: DummyEnum; index: UInt32; var val: single)>(z_SetMultisamplefvAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SetMultisamplefvAMD(pname: DummyEnum; index: UInt32; val: array of single);
begin
z_SetMultisamplefvAMD_ovr_0(pname, index, val[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SetMultisamplefvAMD(pname: DummyEnum; index: UInt32; var val: single);
begin
z_SetMultisamplefvAMD_ovr_0(pname, index, val);
end;
public z_SetMultisamplefvAMD_ovr_2 := GetFuncOrNil&<procedure(pname: DummyEnum; index: UInt32; val: IntPtr)>(z_SetMultisamplefvAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SetMultisamplefvAMD(pname: DummyEnum; index: UInt32; val: IntPtr);
begin
z_SetMultisamplefvAMD_ovr_2(pname, index, val);
end;
end;
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);
public z_TexStorageSparseAMD_adr := GetFuncAdr('glTexStorageSparseAMD');
public z_TexStorageSparseAMD_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; _internalFormat: InternalFormat; width: Int32; height: Int32; depth: Int32; layers: Int32; flags: TextureStorageMaskAMD)>(z_TexStorageSparseAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexStorageSparseAMD(target: TextureTarget; _internalFormat: InternalFormat; width: Int32; height: Int32; depth: Int32; layers: Int32; flags: TextureStorageMaskAMD);
begin
z_TexStorageSparseAMD_ovr_0(target, _internalFormat, width, height, depth, layers, flags);
end;
public z_TextureStorageSparseAMD_adr := GetFuncAdr('glTextureStorageSparseAMD');
public z_TextureStorageSparseAMD_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: DummyEnum; _internalFormat: InternalFormat; width: Int32; height: Int32; depth: Int32; layers: Int32; flags: TextureStorageMaskAMD)>(z_TextureStorageSparseAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorageSparseAMD(texture: UInt32; target: DummyEnum; _internalFormat: InternalFormat; width: Int32; height: Int32; depth: Int32; layers: Int32; flags: TextureStorageMaskAMD);
begin
z_TextureStorageSparseAMD_ovr_0(texture, target, _internalFormat, width, height, depth, layers, flags);
end;
end;
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);
public z_StencilOpValueAMD_adr := GetFuncAdr('glStencilOpValueAMD');
public z_StencilOpValueAMD_ovr_0 := GetFuncOrNil&<procedure(face: StencilFaceDirection; value: UInt32)>(z_StencilOpValueAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilOpValueAMD(face: StencilFaceDirection; value: UInt32);
begin
z_StencilOpValueAMD_ovr_0(face, value);
end;
end;
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);
public z_TessellationFactorAMD_adr := GetFuncAdr('glTessellationFactorAMD');
public z_TessellationFactorAMD_ovr_0 := GetFuncOrNil&<procedure(factor: single)>(z_TessellationFactorAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TessellationFactorAMD(factor: single);
begin
z_TessellationFactorAMD_ovr_0(factor);
end;
public z_TessellationModeAMD_adr := GetFuncAdr('glTessellationModeAMD');
public z_TessellationModeAMD_ovr_0 := GetFuncOrNil&<procedure(mode: DummyEnum)>(z_TessellationModeAMD_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TessellationModeAMD(mode: DummyEnum);
begin
z_TessellationModeAMD_ovr_0(mode);
end;
end;
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);
public z_ElementPointerAPPLE_adr := GetFuncAdr('glElementPointerAPPLE');
public z_ElementPointerAPPLE_ovr_0 := GetFuncOrNil&<procedure(&type: ElementPointerTypeATI; pointer: IntPtr)>(z_ElementPointerAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ElementPointerAPPLE(&type: ElementPointerTypeATI; pointer: IntPtr);
begin
z_ElementPointerAPPLE_ovr_0(&type, pointer);
end;
public z_DrawElementArrayAPPLE_adr := GetFuncAdr('glDrawElementArrayAPPLE');
public z_DrawElementArrayAPPLE_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; first: Int32; count: Int32)>(z_DrawElementArrayAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawElementArrayAPPLE(mode: PrimitiveType; first: Int32; count: Int32);
begin
z_DrawElementArrayAPPLE_ovr_0(mode, first, count);
end;
public z_DrawRangeElementArrayAPPLE_adr := GetFuncAdr('glDrawRangeElementArrayAPPLE');
public z_DrawRangeElementArrayAPPLE_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; start: UInt32; &end: UInt32; first: Int32; count: Int32)>(z_DrawRangeElementArrayAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawRangeElementArrayAPPLE(mode: PrimitiveType; start: UInt32; &end: UInt32; first: Int32; count: Int32);
begin
z_DrawRangeElementArrayAPPLE_ovr_0(mode, start, &end, first, count);
end;
public z_MultiDrawElementArrayAPPLE_adr := GetFuncAdr('glMultiDrawElementArrayAPPLE');
public z_MultiDrawElementArrayAPPLE_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; var first: Int32; var count: Int32; primcount: Int32)>(z_MultiDrawElementArrayAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementArrayAPPLE(mode: PrimitiveType; first: array of Int32; count: array of Int32; primcount: Int32);
begin
z_MultiDrawElementArrayAPPLE_ovr_0(mode, first[0], count[0], primcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementArrayAPPLE(mode: PrimitiveType; first: array of Int32; var count: Int32; primcount: Int32);
begin
z_MultiDrawElementArrayAPPLE_ovr_0(mode, first[0], count, primcount);
end;
public z_MultiDrawElementArrayAPPLE_ovr_2 := GetFuncOrNil&<procedure(mode: PrimitiveType; var first: Int32; count: IntPtr; primcount: Int32)>(z_MultiDrawElementArrayAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementArrayAPPLE(mode: PrimitiveType; first: array of Int32; count: IntPtr; primcount: Int32);
begin
z_MultiDrawElementArrayAPPLE_ovr_2(mode, first[0], count, primcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementArrayAPPLE(mode: PrimitiveType; var first: Int32; count: array of Int32; primcount: Int32);
begin
z_MultiDrawElementArrayAPPLE_ovr_0(mode, first, count[0], primcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementArrayAPPLE(mode: PrimitiveType; var first: Int32; var count: Int32; primcount: Int32);
begin
z_MultiDrawElementArrayAPPLE_ovr_0(mode, first, count, primcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementArrayAPPLE(mode: PrimitiveType; var first: Int32; count: IntPtr; primcount: Int32);
begin
z_MultiDrawElementArrayAPPLE_ovr_2(mode, first, count, primcount);
end;
public z_MultiDrawElementArrayAPPLE_ovr_6 := GetFuncOrNil&<procedure(mode: PrimitiveType; first: IntPtr; var count: Int32; primcount: Int32)>(z_MultiDrawElementArrayAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementArrayAPPLE(mode: PrimitiveType; first: IntPtr; count: array of Int32; primcount: Int32);
begin
z_MultiDrawElementArrayAPPLE_ovr_6(mode, first, count[0], primcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementArrayAPPLE(mode: PrimitiveType; first: IntPtr; var count: Int32; primcount: Int32);
begin
z_MultiDrawElementArrayAPPLE_ovr_6(mode, first, count, primcount);
end;
public z_MultiDrawElementArrayAPPLE_ovr_8 := GetFuncOrNil&<procedure(mode: PrimitiveType; first: IntPtr; count: IntPtr; primcount: Int32)>(z_MultiDrawElementArrayAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementArrayAPPLE(mode: PrimitiveType; first: IntPtr; count: IntPtr; primcount: Int32);
begin
z_MultiDrawElementArrayAPPLE_ovr_8(mode, first, count, primcount);
end;
public z_MultiDrawRangeElementArrayAPPLE_adr := GetFuncAdr('glMultiDrawRangeElementArrayAPPLE');
public z_MultiDrawRangeElementArrayAPPLE_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; start: UInt32; &end: UInt32; var first: Int32; var count: Int32; primcount: Int32)>(z_MultiDrawRangeElementArrayAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawRangeElementArrayAPPLE(mode: PrimitiveType; start: UInt32; &end: UInt32; first: array of Int32; count: array of Int32; primcount: Int32);
begin
z_MultiDrawRangeElementArrayAPPLE_ovr_0(mode, start, &end, first[0], count[0], primcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawRangeElementArrayAPPLE(mode: PrimitiveType; start: UInt32; &end: UInt32; first: array of Int32; var count: Int32; primcount: Int32);
begin
z_MultiDrawRangeElementArrayAPPLE_ovr_0(mode, start, &end, first[0], count, primcount);
end;
public z_MultiDrawRangeElementArrayAPPLE_ovr_2 := GetFuncOrNil&<procedure(mode: PrimitiveType; start: UInt32; &end: UInt32; var first: Int32; count: IntPtr; primcount: Int32)>(z_MultiDrawRangeElementArrayAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawRangeElementArrayAPPLE(mode: PrimitiveType; start: UInt32; &end: UInt32; first: array of Int32; count: IntPtr; primcount: Int32);
begin
z_MultiDrawRangeElementArrayAPPLE_ovr_2(mode, start, &end, first[0], count, primcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawRangeElementArrayAPPLE(mode: PrimitiveType; start: UInt32; &end: UInt32; var first: Int32; count: array of Int32; primcount: Int32);
begin
z_MultiDrawRangeElementArrayAPPLE_ovr_0(mode, start, &end, first, count[0], primcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawRangeElementArrayAPPLE(mode: PrimitiveType; start: UInt32; &end: UInt32; var first: Int32; var count: Int32; primcount: Int32);
begin
z_MultiDrawRangeElementArrayAPPLE_ovr_0(mode, start, &end, first, count, primcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawRangeElementArrayAPPLE(mode: PrimitiveType; start: UInt32; &end: UInt32; var first: Int32; count: IntPtr; primcount: Int32);
begin
z_MultiDrawRangeElementArrayAPPLE_ovr_2(mode, start, &end, first, count, primcount);
end;
public z_MultiDrawRangeElementArrayAPPLE_ovr_6 := GetFuncOrNil&<procedure(mode: PrimitiveType; start: UInt32; &end: UInt32; first: IntPtr; var count: Int32; primcount: Int32)>(z_MultiDrawRangeElementArrayAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawRangeElementArrayAPPLE(mode: PrimitiveType; start: UInt32; &end: UInt32; first: IntPtr; count: array of Int32; primcount: Int32);
begin
z_MultiDrawRangeElementArrayAPPLE_ovr_6(mode, start, &end, first, count[0], primcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawRangeElementArrayAPPLE(mode: PrimitiveType; start: UInt32; &end: UInt32; first: IntPtr; var count: Int32; primcount: Int32);
begin
z_MultiDrawRangeElementArrayAPPLE_ovr_6(mode, start, &end, first, count, primcount);
end;
public z_MultiDrawRangeElementArrayAPPLE_ovr_8 := GetFuncOrNil&<procedure(mode: PrimitiveType; start: UInt32; &end: UInt32; first: IntPtr; count: IntPtr; primcount: Int32)>(z_MultiDrawRangeElementArrayAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawRangeElementArrayAPPLE(mode: PrimitiveType; start: UInt32; &end: UInt32; first: IntPtr; count: IntPtr; primcount: Int32);
begin
z_MultiDrawRangeElementArrayAPPLE_ovr_8(mode, start, &end, first, count, primcount);
end;
end;
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);
public z_GenFencesAPPLE_adr := GetFuncAdr('glGenFencesAPPLE');
public z_GenFencesAPPLE_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var fences: UInt32)>(z_GenFencesAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenFencesAPPLE(n: Int32; fences: array of UInt32);
begin
z_GenFencesAPPLE_ovr_0(n, fences[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenFencesAPPLE(n: Int32; var fences: UInt32);
begin
z_GenFencesAPPLE_ovr_0(n, fences);
end;
public z_GenFencesAPPLE_ovr_2 := GetFuncOrNil&<procedure(n: Int32; fences: IntPtr)>(z_GenFencesAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenFencesAPPLE(n: Int32; fences: IntPtr);
begin
z_GenFencesAPPLE_ovr_2(n, fences);
end;
public z_DeleteFencesAPPLE_adr := GetFuncAdr('glDeleteFencesAPPLE');
public z_DeleteFencesAPPLE_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var fences: UInt32)>(z_DeleteFencesAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFencesAPPLE(n: Int32; fences: array of UInt32);
begin
z_DeleteFencesAPPLE_ovr_0(n, fences[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFencesAPPLE(n: Int32; var fences: UInt32);
begin
z_DeleteFencesAPPLE_ovr_0(n, fences);
end;
public z_DeleteFencesAPPLE_ovr_2 := GetFuncOrNil&<procedure(n: Int32; fences: IntPtr)>(z_DeleteFencesAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFencesAPPLE(n: Int32; fences: IntPtr);
begin
z_DeleteFencesAPPLE_ovr_2(n, fences);
end;
public z_SetFenceAPPLE_adr := GetFuncAdr('glSetFenceAPPLE');
public z_SetFenceAPPLE_ovr_0 := GetFuncOrNil&<procedure(fence: UInt32)>(z_SetFenceAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SetFenceAPPLE(fence: UInt32);
begin
z_SetFenceAPPLE_ovr_0(fence);
end;
public z_IsFenceAPPLE_adr := GetFuncAdr('glIsFenceAPPLE');
public z_IsFenceAPPLE_ovr_0 := GetFuncOrNil&<function(fence: UInt32): boolean>(z_IsFenceAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsFenceAPPLE(fence: UInt32): boolean;
begin
Result := z_IsFenceAPPLE_ovr_0(fence);
end;
public z_TestFenceAPPLE_adr := GetFuncAdr('glTestFenceAPPLE');
public z_TestFenceAPPLE_ovr_0 := GetFuncOrNil&<function(fence: UInt32): boolean>(z_TestFenceAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function TestFenceAPPLE(fence: UInt32): boolean;
begin
Result := z_TestFenceAPPLE_ovr_0(fence);
end;
public z_FinishFenceAPPLE_adr := GetFuncAdr('glFinishFenceAPPLE');
public z_FinishFenceAPPLE_ovr_0 := GetFuncOrNil&<procedure(fence: UInt32)>(z_FinishFenceAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FinishFenceAPPLE(fence: UInt32);
begin
z_FinishFenceAPPLE_ovr_0(fence);
end;
public z_TestObjectAPPLE_adr := GetFuncAdr('glTestObjectAPPLE');
public z_TestObjectAPPLE_ovr_0 := GetFuncOrNil&<function(object: ObjectTypeAPPLE; name: UInt32): boolean>(z_TestObjectAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function TestObjectAPPLE(object: ObjectTypeAPPLE; name: UInt32): boolean;
begin
Result := z_TestObjectAPPLE_ovr_0(object, name);
end;
public z_FinishObjectAPPLE_adr := GetFuncAdr('glFinishObjectAPPLE');
public z_FinishObjectAPPLE_ovr_0 := GetFuncOrNil&<procedure(object: ObjectTypeAPPLE; name: Int32)>(z_FinishObjectAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FinishObjectAPPLE(object: ObjectTypeAPPLE; name: Int32);
begin
z_FinishObjectAPPLE_ovr_0(object, name);
end;
end;
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);
public z_BufferParameteriAPPLE_adr := GetFuncAdr('glBufferParameteriAPPLE');
public z_BufferParameteriAPPLE_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; pname: DummyEnum; param: Int32)>(z_BufferParameteriAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferParameteriAPPLE(target: DummyEnum; pname: DummyEnum; param: Int32);
begin
z_BufferParameteriAPPLE_ovr_0(target, pname, param);
end;
public z_FlushMappedBufferRangeAPPLE_adr := GetFuncAdr('glFlushMappedBufferRangeAPPLE');
public z_FlushMappedBufferRangeAPPLE_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; offset: IntPtr; size: IntPtr)>(z_FlushMappedBufferRangeAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FlushMappedBufferRangeAPPLE(target: BufferTargetARB; offset: IntPtr; size: IntPtr);
begin
z_FlushMappedBufferRangeAPPLE_ovr_0(target, offset, size);
end;
end;
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);
public z_ObjectPurgeableAPPLE_adr := GetFuncAdr('glObjectPurgeableAPPLE');
public z_ObjectPurgeableAPPLE_ovr_0 := GetFuncOrNil&<function(objectType: DummyEnum; name: UInt32; option: DummyEnum): DummyEnum>(z_ObjectPurgeableAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function ObjectPurgeableAPPLE(objectType: DummyEnum; name: UInt32; option: DummyEnum): DummyEnum;
begin
Result := z_ObjectPurgeableAPPLE_ovr_0(objectType, name, option);
end;
public z_ObjectUnpurgeableAPPLE_adr := GetFuncAdr('glObjectUnpurgeableAPPLE');
public z_ObjectUnpurgeableAPPLE_ovr_0 := GetFuncOrNil&<function(objectType: DummyEnum; name: UInt32; option: DummyEnum): DummyEnum>(z_ObjectUnpurgeableAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function ObjectUnpurgeableAPPLE(objectType: DummyEnum; name: UInt32; option: DummyEnum): DummyEnum;
begin
Result := z_ObjectUnpurgeableAPPLE_ovr_0(objectType, name, option);
end;
public z_GetObjectParameterivAPPLE_adr := GetFuncAdr('glGetObjectParameterivAPPLE');
public z_GetObjectParameterivAPPLE_ovr_0 := GetFuncOrNil&<procedure(objectType: DummyEnum; name: UInt32; pname: DummyEnum; var ¶ms: Int32)>(z_GetObjectParameterivAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectParameterivAPPLE(objectType: DummyEnum; name: UInt32; pname: DummyEnum; ¶ms: array of Int32);
begin
z_GetObjectParameterivAPPLE_ovr_0(objectType, name, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectParameterivAPPLE(objectType: DummyEnum; name: UInt32; pname: DummyEnum; var ¶ms: Int32);
begin
z_GetObjectParameterivAPPLE_ovr_0(objectType, name, pname, ¶ms);
end;
public z_GetObjectParameterivAPPLE_ovr_2 := GetFuncOrNil&<procedure(objectType: DummyEnum; name: UInt32; pname: DummyEnum; ¶ms: IntPtr)>(z_GetObjectParameterivAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectParameterivAPPLE(objectType: DummyEnum; name: UInt32; pname: DummyEnum; ¶ms: IntPtr);
begin
z_GetObjectParameterivAPPLE_ovr_2(objectType, name, pname, ¶ms);
end;
end;
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);
public z_TextureRangeAPPLE_adr := GetFuncAdr('glTextureRangeAPPLE');
public z_TextureRangeAPPLE_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; length: Int32; pointer: IntPtr)>(z_TextureRangeAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureRangeAPPLE(target: DummyEnum; length: Int32; pointer: IntPtr);
begin
z_TextureRangeAPPLE_ovr_0(target, length, pointer);
end;
public z_GetTexParameterPointervAPPLE_adr := GetFuncAdr('glGetTexParameterPointervAPPLE');
public z_GetTexParameterPointervAPPLE_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; pname: DummyEnum; var ¶ms: IntPtr)>(z_GetTexParameterPointervAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterPointervAPPLE(target: DummyEnum; pname: DummyEnum; ¶ms: array of IntPtr);
begin
z_GetTexParameterPointervAPPLE_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterPointervAPPLE(target: DummyEnum; pname: DummyEnum; var ¶ms: IntPtr);
begin
z_GetTexParameterPointervAPPLE_ovr_0(target, pname, ¶ms);
end;
public z_GetTexParameterPointervAPPLE_ovr_2 := GetFuncOrNil&<procedure(target: DummyEnum; pname: DummyEnum; ¶ms: pointer)>(z_GetTexParameterPointervAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterPointervAPPLE(target: DummyEnum; pname: DummyEnum; ¶ms: pointer);
begin
z_GetTexParameterPointervAPPLE_ovr_2(target, pname, ¶ms);
end;
end;
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);
public z_BindVertexArrayAPPLE_adr := GetFuncAdr('glBindVertexArrayAPPLE');
public z_BindVertexArrayAPPLE_ovr_0 := GetFuncOrNil&<procedure(&array: UInt32)>(z_BindVertexArrayAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexArrayAPPLE(&array: UInt32);
begin
z_BindVertexArrayAPPLE_ovr_0(&array);
end;
public z_DeleteVertexArraysAPPLE_adr := GetFuncAdr('glDeleteVertexArraysAPPLE');
public z_DeleteVertexArraysAPPLE_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var arrays: UInt32)>(z_DeleteVertexArraysAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteVertexArraysAPPLE(n: Int32; arrays: array of UInt32);
begin
z_DeleteVertexArraysAPPLE_ovr_0(n, arrays[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteVertexArraysAPPLE(n: Int32; var arrays: UInt32);
begin
z_DeleteVertexArraysAPPLE_ovr_0(n, arrays);
end;
public z_DeleteVertexArraysAPPLE_ovr_2 := GetFuncOrNil&<procedure(n: Int32; arrays: IntPtr)>(z_DeleteVertexArraysAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteVertexArraysAPPLE(n: Int32; arrays: IntPtr);
begin
z_DeleteVertexArraysAPPLE_ovr_2(n, arrays);
end;
public z_GenVertexArraysAPPLE_adr := GetFuncAdr('glGenVertexArraysAPPLE');
public z_GenVertexArraysAPPLE_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var arrays: UInt32)>(z_GenVertexArraysAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenVertexArraysAPPLE(n: Int32; arrays: array of UInt32);
begin
z_GenVertexArraysAPPLE_ovr_0(n, arrays[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenVertexArraysAPPLE(n: Int32; var arrays: UInt32);
begin
z_GenVertexArraysAPPLE_ovr_0(n, arrays);
end;
public z_GenVertexArraysAPPLE_ovr_2 := GetFuncOrNil&<procedure(n: Int32; arrays: IntPtr)>(z_GenVertexArraysAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenVertexArraysAPPLE(n: Int32; arrays: IntPtr);
begin
z_GenVertexArraysAPPLE_ovr_2(n, arrays);
end;
public z_IsVertexArrayAPPLE_adr := GetFuncAdr('glIsVertexArrayAPPLE');
public z_IsVertexArrayAPPLE_ovr_0 := GetFuncOrNil&<function(&array: UInt32): boolean>(z_IsVertexArrayAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsVertexArrayAPPLE(&array: UInt32): boolean;
begin
Result := z_IsVertexArrayAPPLE_ovr_0(&array);
end;
end;
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);
public z_VertexArrayRangeAPPLE_adr := GetFuncAdr('glVertexArrayRangeAPPLE');
public z_VertexArrayRangeAPPLE_ovr_0 := GetFuncOrNil&<procedure(length: Int32; pointer: IntPtr)>(z_VertexArrayRangeAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayRangeAPPLE(length: Int32; pointer: IntPtr);
begin
z_VertexArrayRangeAPPLE_ovr_0(length, pointer);
end;
public z_FlushVertexArrayRangeAPPLE_adr := GetFuncAdr('glFlushVertexArrayRangeAPPLE');
public z_FlushVertexArrayRangeAPPLE_ovr_0 := GetFuncOrNil&<procedure(length: Int32; pointer: IntPtr)>(z_FlushVertexArrayRangeAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FlushVertexArrayRangeAPPLE(length: Int32; pointer: IntPtr);
begin
z_FlushVertexArrayRangeAPPLE_ovr_0(length, pointer);
end;
public z_VertexArrayParameteriAPPLE_adr := GetFuncAdr('glVertexArrayParameteriAPPLE');
public z_VertexArrayParameteriAPPLE_ovr_0 := GetFuncOrNil&<procedure(pname: VertexArrayPNameAPPLE; param: Int32)>(z_VertexArrayParameteriAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayParameteriAPPLE(pname: VertexArrayPNameAPPLE; param: Int32);
begin
z_VertexArrayParameteriAPPLE_ovr_0(pname, param);
end;
end;
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);
public z_EnableVertexAttribAPPLE_adr := GetFuncAdr('glEnableVertexAttribAPPLE');
public z_EnableVertexAttribAPPLE_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: DummyEnum)>(z_EnableVertexAttribAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EnableVertexAttribAPPLE(index: UInt32; pname: DummyEnum);
begin
z_EnableVertexAttribAPPLE_ovr_0(index, pname);
end;
public z_DisableVertexAttribAPPLE_adr := GetFuncAdr('glDisableVertexAttribAPPLE');
public z_DisableVertexAttribAPPLE_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: DummyEnum)>(z_DisableVertexAttribAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DisableVertexAttribAPPLE(index: UInt32; pname: DummyEnum);
begin
z_DisableVertexAttribAPPLE_ovr_0(index, pname);
end;
public z_IsVertexAttribEnabledAPPLE_adr := GetFuncAdr('glIsVertexAttribEnabledAPPLE');
public z_IsVertexAttribEnabledAPPLE_ovr_0 := GetFuncOrNil&<function(index: UInt32; pname: DummyEnum): boolean>(z_IsVertexAttribEnabledAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsVertexAttribEnabledAPPLE(index: UInt32; pname: DummyEnum): boolean;
begin
Result := z_IsVertexAttribEnabledAPPLE_ovr_0(index, pname);
end;
public z_MapVertexAttrib1dAPPLE_adr := GetFuncAdr('glMapVertexAttrib1dAPPLE');
public z_MapVertexAttrib1dAPPLE_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; size: UInt32; u1: real; u2: real; stride: Int32; order: Int32; var points: real)>(z_MapVertexAttrib1dAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapVertexAttrib1dAPPLE(index: UInt32; size: UInt32; u1: real; u2: real; stride: Int32; order: Int32; points: array of real);
begin
z_MapVertexAttrib1dAPPLE_ovr_0(index, size, u1, u2, stride, order, points[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapVertexAttrib1dAPPLE(index: UInt32; size: UInt32; u1: real; u2: real; stride: Int32; order: Int32; var points: real);
begin
z_MapVertexAttrib1dAPPLE_ovr_0(index, size, u1, u2, stride, order, points);
end;
public z_MapVertexAttrib1dAPPLE_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; size: UInt32; u1: real; u2: real; stride: Int32; order: Int32; points: IntPtr)>(z_MapVertexAttrib1dAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapVertexAttrib1dAPPLE(index: UInt32; size: UInt32; u1: real; u2: real; stride: Int32; order: Int32; points: IntPtr);
begin
z_MapVertexAttrib1dAPPLE_ovr_2(index, size, u1, u2, stride, order, points);
end;
public z_MapVertexAttrib1fAPPLE_adr := GetFuncAdr('glMapVertexAttrib1fAPPLE');
public z_MapVertexAttrib1fAPPLE_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; size: UInt32; u1: single; u2: single; stride: Int32; order: Int32; var points: single)>(z_MapVertexAttrib1fAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapVertexAttrib1fAPPLE(index: UInt32; size: UInt32; u1: single; u2: single; stride: Int32; order: Int32; points: array of single);
begin
z_MapVertexAttrib1fAPPLE_ovr_0(index, size, u1, u2, stride, order, points[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapVertexAttrib1fAPPLE(index: UInt32; size: UInt32; u1: single; u2: single; stride: Int32; order: Int32; var points: single);
begin
z_MapVertexAttrib1fAPPLE_ovr_0(index, size, u1, u2, stride, order, points);
end;
public z_MapVertexAttrib1fAPPLE_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; size: UInt32; u1: single; u2: single; stride: Int32; order: Int32; points: IntPtr)>(z_MapVertexAttrib1fAPPLE_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapVertexAttrib1fAPPLE(index: UInt32; size: UInt32; u1: single; u2: single; stride: Int32; order: Int32; points: IntPtr);
begin
z_MapVertexAttrib1fAPPLE_ovr_2(index, size, u1, u2, stride, order, points);
end;
public z_MapVertexAttrib2dAPPLE_adr := GetFuncAdr('glMapVertexAttrib2dAPPLE');
public z_MapVertexAttrib2dAPPLE_ovr_0 := GetFuncOrNil&<procedure(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_adr);
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);
begin
z_MapVertexAttrib2dAPPLE_ovr_0(index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points[0]);
end;
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);
begin
z_MapVertexAttrib2dAPPLE_ovr_0(index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
end;
public z_MapVertexAttrib2dAPPLE_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; size: UInt32; u1: real; u2: real; ustride: Int32; uorder: Int32; v1: real; v2: real; vstride: Int32; vorder: Int32; points: IntPtr)>(z_MapVertexAttrib2dAPPLE_adr);
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);
begin
z_MapVertexAttrib2dAPPLE_ovr_2(index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
end;
public z_MapVertexAttrib2fAPPLE_adr := GetFuncAdr('glMapVertexAttrib2fAPPLE');
public z_MapVertexAttrib2fAPPLE_ovr_0 := GetFuncOrNil&<procedure(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_adr);
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);
begin
z_MapVertexAttrib2fAPPLE_ovr_0(index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points[0]);
end;
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);
begin
z_MapVertexAttrib2fAPPLE_ovr_0(index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
end;
public z_MapVertexAttrib2fAPPLE_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; size: UInt32; u1: single; u2: single; ustride: Int32; uorder: Int32; v1: single; v2: single; vstride: Int32; vorder: Int32; points: IntPtr)>(z_MapVertexAttrib2fAPPLE_adr);
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);
begin
z_MapVertexAttrib2fAPPLE_ovr_2(index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
end;
end;
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);
end;
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);
end;
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);
public z_PrimitiveBoundingBoxARB_adr := GetFuncAdr('glPrimitiveBoundingBoxARB');
public z_PrimitiveBoundingBoxARB_ovr_0 := GetFuncOrNil&<procedure(minX: single; minY: single; minZ: single; minW: single; maxX: single; maxY: single; maxZ: single; maxW: single)>(z_PrimitiveBoundingBoxARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrimitiveBoundingBoxARB(minX: single; minY: single; minZ: single; minW: single; maxX: single; maxY: single; maxZ: single; maxW: single);
begin
z_PrimitiveBoundingBoxARB_ovr_0(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
end;
end;
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);
end;
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);
public z_GetTextureHandleARB_adr := GetFuncAdr('glGetTextureHandleARB');
public z_GetTextureHandleARB_ovr_0 := GetFuncOrNil&<function(texture: UInt32): UInt64>(z_GetTextureHandleARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetTextureHandleARB(texture: UInt32): UInt64;
begin
Result := z_GetTextureHandleARB_ovr_0(texture);
end;
public z_GetTextureSamplerHandleARB_adr := GetFuncAdr('glGetTextureSamplerHandleARB');
public z_GetTextureSamplerHandleARB_ovr_0 := GetFuncOrNil&<function(texture: UInt32; sampler: UInt32): UInt64>(z_GetTextureSamplerHandleARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetTextureSamplerHandleARB(texture: UInt32; sampler: UInt32): UInt64;
begin
Result := z_GetTextureSamplerHandleARB_ovr_0(texture, sampler);
end;
public z_MakeTextureHandleResidentARB_adr := GetFuncAdr('glMakeTextureHandleResidentARB');
public z_MakeTextureHandleResidentARB_ovr_0 := GetFuncOrNil&<procedure(handle: UInt64)>(z_MakeTextureHandleResidentARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MakeTextureHandleResidentARB(handle: UInt64);
begin
z_MakeTextureHandleResidentARB_ovr_0(handle);
end;
public z_MakeTextureHandleNonResidentARB_adr := GetFuncAdr('glMakeTextureHandleNonResidentARB');
public z_MakeTextureHandleNonResidentARB_ovr_0 := GetFuncOrNil&<procedure(handle: UInt64)>(z_MakeTextureHandleNonResidentARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MakeTextureHandleNonResidentARB(handle: UInt64);
begin
z_MakeTextureHandleNonResidentARB_ovr_0(handle);
end;
public z_GetImageHandleARB_adr := GetFuncAdr('glGetImageHandleARB');
public z_GetImageHandleARB_ovr_0 := GetFuncOrNil&<function(texture: UInt32; level: Int32; layered: boolean; layer: Int32; format: PixelFormat): UInt64>(z_GetImageHandleARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetImageHandleARB(texture: UInt32; level: Int32; layered: boolean; layer: Int32; format: PixelFormat): UInt64;
begin
Result := z_GetImageHandleARB_ovr_0(texture, level, layered, layer, format);
end;
public z_MakeImageHandleResidentARB_adr := GetFuncAdr('glMakeImageHandleResidentARB');
public z_MakeImageHandleResidentARB_ovr_0 := GetFuncOrNil&<procedure(handle: UInt64; access: DummyEnum)>(z_MakeImageHandleResidentARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MakeImageHandleResidentARB(handle: UInt64; access: DummyEnum);
begin
z_MakeImageHandleResidentARB_ovr_0(handle, access);
end;
public z_MakeImageHandleNonResidentARB_adr := GetFuncAdr('glMakeImageHandleNonResidentARB');
public z_MakeImageHandleNonResidentARB_ovr_0 := GetFuncOrNil&<procedure(handle: UInt64)>(z_MakeImageHandleNonResidentARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MakeImageHandleNonResidentARB(handle: UInt64);
begin
z_MakeImageHandleNonResidentARB_ovr_0(handle);
end;
public z_UniformHandleui64ARB_adr := GetFuncAdr('glUniformHandleui64ARB');
public z_UniformHandleui64ARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; value: UInt64)>(z_UniformHandleui64ARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformHandleui64ARB(location: Int32; value: UInt64);
begin
z_UniformHandleui64ARB_ovr_0(location, value);
end;
public z_UniformHandleui64vARB_adr := GetFuncAdr('glUniformHandleui64vARB');
public z_UniformHandleui64vARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: UInt64)>(z_UniformHandleui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformHandleui64vARB(location: Int32; count: Int32; value: array of UInt64);
begin
z_UniformHandleui64vARB_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformHandleui64vARB(location: Int32; count: Int32; var value: UInt64);
begin
z_UniformHandleui64vARB_ovr_0(location, count, value);
end;
public z_UniformHandleui64vARB_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_UniformHandleui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformHandleui64vARB(location: Int32; count: Int32; value: IntPtr);
begin
z_UniformHandleui64vARB_ovr_2(location, count, value);
end;
public z_ProgramUniformHandleui64ARB_adr := GetFuncAdr('glProgramUniformHandleui64ARB');
public z_ProgramUniformHandleui64ARB_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; value: UInt64)>(z_ProgramUniformHandleui64ARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformHandleui64ARB(&program: UInt32; location: Int32; value: UInt64);
begin
z_ProgramUniformHandleui64ARB_ovr_0(&program, location, value);
end;
public z_ProgramUniformHandleui64vARB_adr := GetFuncAdr('glProgramUniformHandleui64vARB');
public z_ProgramUniformHandleui64vARB_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var values: UInt64)>(z_ProgramUniformHandleui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformHandleui64vARB(&program: UInt32; location: Int32; count: Int32; values: array of UInt64);
begin
z_ProgramUniformHandleui64vARB_ovr_0(&program, location, count, values[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformHandleui64vARB(&program: UInt32; location: Int32; count: Int32; var values: UInt64);
begin
z_ProgramUniformHandleui64vARB_ovr_0(&program, location, count, values);
end;
public z_ProgramUniformHandleui64vARB_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; values: IntPtr)>(z_ProgramUniformHandleui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformHandleui64vARB(&program: UInt32; location: Int32; count: Int32; values: IntPtr);
begin
z_ProgramUniformHandleui64vARB_ovr_2(&program, location, count, values);
end;
public z_IsTextureHandleResidentARB_adr := GetFuncAdr('glIsTextureHandleResidentARB');
public z_IsTextureHandleResidentARB_ovr_0 := GetFuncOrNil&<function(handle: UInt64): boolean>(z_IsTextureHandleResidentARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsTextureHandleResidentARB(handle: UInt64): boolean;
begin
Result := z_IsTextureHandleResidentARB_ovr_0(handle);
end;
public z_IsImageHandleResidentARB_adr := GetFuncAdr('glIsImageHandleResidentARB');
public z_IsImageHandleResidentARB_ovr_0 := GetFuncOrNil&<function(handle: UInt64): boolean>(z_IsImageHandleResidentARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsImageHandleResidentARB(handle: UInt64): boolean;
begin
Result := z_IsImageHandleResidentARB_ovr_0(handle);
end;
public z_VertexAttribL1ui64ARB_adr := GetFuncAdr('glVertexAttribL1ui64ARB');
public z_VertexAttribL1ui64ARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: UInt64)>(z_VertexAttribL1ui64ARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1ui64ARB(index: UInt32; x: UInt64);
begin
z_VertexAttribL1ui64ARB_ovr_0(index, x);
end;
public z_VertexAttribL1ui64vARB_adr := GetFuncAdr('glVertexAttribL1ui64vARB');
public z_VertexAttribL1ui64vARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt64)>(z_VertexAttribL1ui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1ui64vARB(index: UInt32; v: array of UInt64);
begin
z_VertexAttribL1ui64vARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1ui64vARB(index: UInt32; var v: UInt64);
begin
z_VertexAttribL1ui64vARB_ovr_0(index, v);
end;
public z_VertexAttribL1ui64vARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribL1ui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1ui64vARB(index: UInt32; v: IntPtr);
begin
z_VertexAttribL1ui64vARB_ovr_2(index, v);
end;
public z_GetVertexAttribLui64vARB_adr := GetFuncAdr('glGetVertexAttribLui64vARB');
public z_GetVertexAttribLui64vARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnum; var ¶ms: UInt64)>(z_GetVertexAttribLui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLui64vARB(index: UInt32; pname: VertexAttribEnum; ¶ms: array of UInt64);
begin
z_GetVertexAttribLui64vARB_ovr_0(index, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLui64vARB(index: UInt32; pname: VertexAttribEnum; var ¶ms: UInt64);
begin
z_GetVertexAttribLui64vARB_ovr_0(index, pname, ¶ms);
end;
public z_GetVertexAttribLui64vARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr)>(z_GetVertexAttribLui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLui64vARB(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr);
begin
z_GetVertexAttribLui64vARB_ovr_2(index, pname, ¶ms);
end;
end;
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);
end;
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);
end;
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);
public z_CreateSyncFromCLeventARB_adr := GetFuncAdr('glCreateSyncFromCLeventARB');
public z_CreateSyncFromCLeventARB_ovr_0 := GetFuncOrNil&<function(var context: cl_context; var &event: cl_event; flags: DummyFlags): GLsync>(z_CreateSyncFromCLeventARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateSyncFromCLeventARB(context: array of cl_context; &event: array of cl_event; flags: DummyFlags): GLsync;
begin
Result := z_CreateSyncFromCLeventARB_ovr_0(context[0], &event[0], flags);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateSyncFromCLeventARB(context: array of cl_context; var &event: cl_event; flags: DummyFlags): GLsync;
begin
Result := z_CreateSyncFromCLeventARB_ovr_0(context[0], &event, flags);
end;
public z_CreateSyncFromCLeventARB_ovr_2 := GetFuncOrNil&<function(var context: cl_context; &event: IntPtr; flags: DummyFlags): GLsync>(z_CreateSyncFromCLeventARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateSyncFromCLeventARB(context: array of cl_context; &event: IntPtr; flags: DummyFlags): GLsync;
begin
Result := z_CreateSyncFromCLeventARB_ovr_2(context[0], &event, flags);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateSyncFromCLeventARB(var context: cl_context; &event: array of cl_event; flags: DummyFlags): GLsync;
begin
Result := z_CreateSyncFromCLeventARB_ovr_0(context, &event[0], flags);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateSyncFromCLeventARB(var context: cl_context; var &event: cl_event; flags: DummyFlags): GLsync;
begin
Result := z_CreateSyncFromCLeventARB_ovr_0(context, &event, flags);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateSyncFromCLeventARB(var context: cl_context; &event: IntPtr; flags: DummyFlags): GLsync;
begin
Result := z_CreateSyncFromCLeventARB_ovr_2(context, &event, flags);
end;
public z_CreateSyncFromCLeventARB_ovr_6 := GetFuncOrNil&<function(context: IntPtr; var &event: cl_event; flags: DummyFlags): GLsync>(z_CreateSyncFromCLeventARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateSyncFromCLeventARB(context: IntPtr; &event: array of cl_event; flags: DummyFlags): GLsync;
begin
Result := z_CreateSyncFromCLeventARB_ovr_6(context, &event[0], flags);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateSyncFromCLeventARB(context: IntPtr; var &event: cl_event; flags: DummyFlags): GLsync;
begin
Result := z_CreateSyncFromCLeventARB_ovr_6(context, &event, flags);
end;
public z_CreateSyncFromCLeventARB_ovr_8 := GetFuncOrNil&<function(context: IntPtr; &event: IntPtr; flags: DummyFlags): GLsync>(z_CreateSyncFromCLeventARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateSyncFromCLeventARB(context: IntPtr; &event: IntPtr; flags: DummyFlags): GLsync;
begin
Result := z_CreateSyncFromCLeventARB_ovr_8(context, &event, flags);
end;
end;
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);
end;
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);
end;
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);
end;
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);
public z_ClampColorARB_adr := GetFuncAdr('glClampColorARB');
public z_ClampColorARB_ovr_0 := GetFuncOrNil&<procedure(target: ClampColorTargetARB; clamp: ClampColorModeARB)>(z_ClampColorARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClampColorARB(target: ClampColorTargetARB; clamp: ClampColorModeARB);
begin
z_ClampColorARB_ovr_0(target, clamp);
end;
end;
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);
end;
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);
public z_DispatchComputeGroupSizeARB_adr := GetFuncAdr('glDispatchComputeGroupSizeARB');
public z_DispatchComputeGroupSizeARB_ovr_0 := GetFuncOrNil&<procedure(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_adr);
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);
begin
z_DispatchComputeGroupSizeARB_ovr_0(num_groups_x, num_groups_y, num_groups_z, group_size_x, group_size_y, group_size_z);
end;
end;
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);
end;
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);
end;
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);
public z_DebugMessageControlARB_adr := GetFuncAdr('glDebugMessageControlARB');
public z_DebugMessageControlARB_ovr_0 := GetFuncOrNil&<procedure(source: DebugSource; &type: DebugType; severity: DebugSeverity; count: Int32; var ids: UInt32; enabled: boolean)>(z_DebugMessageControlARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageControlARB(source: DebugSource; &type: DebugType; severity: DebugSeverity; count: Int32; ids: array of UInt32; enabled: boolean);
begin
z_DebugMessageControlARB_ovr_0(source, &type, severity, count, ids[0], enabled);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageControlARB(source: DebugSource; &type: DebugType; severity: DebugSeverity; count: Int32; var ids: UInt32; enabled: boolean);
begin
z_DebugMessageControlARB_ovr_0(source, &type, severity, count, ids, enabled);
end;
public z_DebugMessageControlARB_ovr_2 := GetFuncOrNil&<procedure(source: DebugSource; &type: DebugType; severity: DebugSeverity; count: Int32; ids: IntPtr; enabled: boolean)>(z_DebugMessageControlARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageControlARB(source: DebugSource; &type: DebugType; severity: DebugSeverity; count: Int32; ids: IntPtr; enabled: boolean);
begin
z_DebugMessageControlARB_ovr_2(source, &type, severity, count, ids, enabled);
end;
public z_DebugMessageInsertARB_adr := GetFuncAdr('glDebugMessageInsertARB');
public z_DebugMessageInsertARB_ovr_0 := GetFuncOrNil&<procedure(source: DebugSource; &type: DebugType; id: UInt32; severity: DebugSeverity; length: Int32; buf: IntPtr)>(z_DebugMessageInsertARB_adr);
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);
begin
z_DebugMessageInsertARB_ovr_0(source, &type, id, severity, length, buf);
end;
public z_DebugMessageCallbackARB_adr := GetFuncAdr('glDebugMessageCallbackARB');
public z_DebugMessageCallbackARB_ovr_0 := GetFuncOrNil&<procedure(callback: GLDEBUGPROC; userParam: IntPtr)>(z_DebugMessageCallbackARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DebugMessageCallbackARB(callback: GLDEBUGPROC; userParam: IntPtr);
begin
z_DebugMessageCallbackARB_ovr_0(callback, userParam);
end;
public z_GetDebugMessageLogARB_adr := GetFuncAdr('glGetDebugMessageLogARB');
public z_GetDebugMessageLogARB_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_GetDebugMessageLogARB_adr);
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;
begin
Result := z_GetDebugMessageLogARB_ovr_0(count, bufSize, sources, types, ids, severities, lengths, messageLog);
end;
public z_GetDebugMessageLogARB_ovr_1 := GetFuncOrNil&<function(count: UInt32; bufSize: Int32; sources: IntPtr; types: IntPtr; ids: IntPtr; severities: IntPtr; lengths: IntPtr; messageLog: IntPtr): UInt32>(z_GetDebugMessageLogARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetDebugMessageLogARB(count: UInt32; bufSize: Int32; sources: IntPtr; types: IntPtr; ids: IntPtr; severities: IntPtr; lengths: IntPtr; messageLog: IntPtr): UInt32;
begin
Result := z_GetDebugMessageLogARB_ovr_1(count, bufSize, sources, types, ids, severities, lengths, messageLog);
end;
end;
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);
end;
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);
public z_DrawBuffersARB_adr := GetFuncAdr('glDrawBuffersARB');
public z_DrawBuffersARB_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var bufs: DrawBufferMode)>(z_DrawBuffersARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawBuffersARB(n: Int32; bufs: array of DrawBufferMode);
begin
z_DrawBuffersARB_ovr_0(n, bufs[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawBuffersARB(n: Int32; var bufs: DrawBufferMode);
begin
z_DrawBuffersARB_ovr_0(n, bufs);
end;
public z_DrawBuffersARB_ovr_2 := GetFuncOrNil&<procedure(n: Int32; bufs: IntPtr)>(z_DrawBuffersARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawBuffersARB(n: Int32; bufs: IntPtr);
begin
z_DrawBuffersARB_ovr_2(n, bufs);
end;
end;
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);
public z_BlendEquationiARB_adr := GetFuncAdr('glBlendEquationiARB');
public z_BlendEquationiARB_ovr_0 := GetFuncOrNil&<procedure(buf: UInt32; mode: BlendEquationModeEXT)>(z_BlendEquationiARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendEquationiARB(buf: UInt32; mode: BlendEquationModeEXT);
begin
z_BlendEquationiARB_ovr_0(buf, mode);
end;
public z_BlendEquationSeparateiARB_adr := GetFuncAdr('glBlendEquationSeparateiARB');
public z_BlendEquationSeparateiARB_ovr_0 := GetFuncOrNil&<procedure(buf: UInt32; modeRGB: BlendEquationModeEXT; modeAlpha: BlendEquationModeEXT)>(z_BlendEquationSeparateiARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendEquationSeparateiARB(buf: UInt32; modeRGB: BlendEquationModeEXT; modeAlpha: BlendEquationModeEXT);
begin
z_BlendEquationSeparateiARB_ovr_0(buf, modeRGB, modeAlpha);
end;
public z_BlendFunciARB_adr := GetFuncAdr('glBlendFunciARB');
public z_BlendFunciARB_ovr_0 := GetFuncOrNil&<procedure(buf: UInt32; src: BlendingFactor; dst: BlendingFactor)>(z_BlendFunciARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendFunciARB(buf: UInt32; src: BlendingFactor; dst: BlendingFactor);
begin
z_BlendFunciARB_ovr_0(buf, src, dst);
end;
public z_BlendFuncSeparateiARB_adr := GetFuncAdr('glBlendFuncSeparateiARB');
public z_BlendFuncSeparateiARB_ovr_0 := GetFuncOrNil&<procedure(buf: UInt32; srcRGB: BlendingFactor; dstRGB: BlendingFactor; srcAlpha: BlendingFactor; dstAlpha: BlendingFactor)>(z_BlendFuncSeparateiARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendFuncSeparateiARB(buf: UInt32; srcRGB: BlendingFactor; dstRGB: BlendingFactor; srcAlpha: BlendingFactor; dstAlpha: BlendingFactor);
begin
z_BlendFuncSeparateiARB_ovr_0(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
end;
end;
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);
end;
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);
end;
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);
public z_DrawArraysInstancedARB_adr := GetFuncAdr('glDrawArraysInstancedARB');
public z_DrawArraysInstancedARB_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; first: Int32; count: Int32; primcount: Int32)>(z_DrawArraysInstancedARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawArraysInstancedARB(mode: PrimitiveType; first: Int32; count: Int32; primcount: Int32);
begin
z_DrawArraysInstancedARB_ovr_0(mode, first, count, primcount);
end;
public z_DrawElementsInstancedARB_adr := GetFuncAdr('glDrawElementsInstancedARB');
public z_DrawElementsInstancedARB_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: Int32; &type: DrawElementsType; indices: IntPtr; primcount: Int32)>(z_DrawElementsInstancedARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawElementsInstancedARB(mode: PrimitiveType; count: Int32; &type: DrawElementsType; indices: IntPtr; primcount: Int32);
begin
z_DrawElementsInstancedARB_ovr_0(mode, count, &type, indices, primcount);
end;
end;
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);
public z_ProgramStringARB_adr := GetFuncAdr('glProgramStringARB');
public z_ProgramStringARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; format: ProgramFormat; len: Int32; string: IntPtr)>(z_ProgramStringARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramStringARB(target: ProgramTarget; format: ProgramFormat; len: Int32; string: IntPtr);
begin
z_ProgramStringARB_ovr_0(target, format, len, string);
end;
public z_BindProgramARB_adr := GetFuncAdr('glBindProgramARB');
public z_BindProgramARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; &program: UInt32)>(z_BindProgramARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindProgramARB(target: ProgramTarget; &program: UInt32);
begin
z_BindProgramARB_ovr_0(target, &program);
end;
public z_DeleteProgramsARB_adr := GetFuncAdr('glDeleteProgramsARB');
public z_DeleteProgramsARB_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var programs: UInt32)>(z_DeleteProgramsARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgramsARB(n: Int32; programs: array of UInt32);
begin
z_DeleteProgramsARB_ovr_0(n, programs[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgramsARB(n: Int32; var programs: UInt32);
begin
z_DeleteProgramsARB_ovr_0(n, programs);
end;
public z_DeleteProgramsARB_ovr_2 := GetFuncOrNil&<procedure(n: Int32; programs: IntPtr)>(z_DeleteProgramsARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgramsARB(n: Int32; programs: IntPtr);
begin
z_DeleteProgramsARB_ovr_2(n, programs);
end;
public z_GenProgramsARB_adr := GetFuncAdr('glGenProgramsARB');
public z_GenProgramsARB_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var programs: UInt32)>(z_GenProgramsARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenProgramsARB(n: Int32; programs: array of UInt32);
begin
z_GenProgramsARB_ovr_0(n, programs[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenProgramsARB(n: Int32; var programs: UInt32);
begin
z_GenProgramsARB_ovr_0(n, programs);
end;
public z_GenProgramsARB_ovr_2 := GetFuncOrNil&<procedure(n: Int32; programs: IntPtr)>(z_GenProgramsARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenProgramsARB(n: Int32; programs: IntPtr);
begin
z_GenProgramsARB_ovr_2(n, programs);
end;
public z_ProgramEnvParameter4dARB_adr := GetFuncAdr('glProgramEnvParameter4dARB');
public z_ProgramEnvParameter4dARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; x: real; y: real; z: real; w: real)>(z_ProgramEnvParameter4dARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4dARB(target: ProgramTarget; index: UInt32; x: real; y: real; z: real; w: real);
begin
z_ProgramEnvParameter4dARB_ovr_0(target, index, x, y, z, w);
end;
public z_ProgramEnvParameter4dvARB_adr := GetFuncAdr('glProgramEnvParameter4dvARB');
public z_ProgramEnvParameter4dvARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; var ¶ms: real)>(z_ProgramEnvParameter4dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4dvARB(target: ProgramTarget; index: UInt32; ¶ms: array of real);
begin
z_ProgramEnvParameter4dvARB_ovr_0(target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4dvARB(target: ProgramTarget; index: UInt32; var ¶ms: real);
begin
z_ProgramEnvParameter4dvARB_ovr_0(target, index, ¶ms);
end;
public z_ProgramEnvParameter4dvARB_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_ProgramEnvParameter4dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4dvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_ProgramEnvParameter4dvARB_ovr_2(target, index, ¶ms);
end;
public z_ProgramEnvParameter4fARB_adr := GetFuncAdr('glProgramEnvParameter4fARB');
public z_ProgramEnvParameter4fARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; x: single; y: single; z: single; w: single)>(z_ProgramEnvParameter4fARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4fARB(target: ProgramTarget; index: UInt32; x: single; y: single; z: single; w: single);
begin
z_ProgramEnvParameter4fARB_ovr_0(target, index, x, y, z, w);
end;
public z_ProgramEnvParameter4fvARB_adr := GetFuncAdr('glProgramEnvParameter4fvARB');
public z_ProgramEnvParameter4fvARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; var ¶ms: single)>(z_ProgramEnvParameter4fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4fvARB(target: ProgramTarget; index: UInt32; ¶ms: array of single);
begin
z_ProgramEnvParameter4fvARB_ovr_0(target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4fvARB(target: ProgramTarget; index: UInt32; var ¶ms: single);
begin
z_ProgramEnvParameter4fvARB_ovr_0(target, index, ¶ms);
end;
public z_ProgramEnvParameter4fvARB_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_ProgramEnvParameter4fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4fvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_ProgramEnvParameter4fvARB_ovr_2(target, index, ¶ms);
end;
public z_ProgramLocalParameter4dARB_adr := GetFuncAdr('glProgramLocalParameter4dARB');
public z_ProgramLocalParameter4dARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; x: real; y: real; z: real; w: real)>(z_ProgramLocalParameter4dARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4dARB(target: ProgramTarget; index: UInt32; x: real; y: real; z: real; w: real);
begin
z_ProgramLocalParameter4dARB_ovr_0(target, index, x, y, z, w);
end;
public z_ProgramLocalParameter4dvARB_adr := GetFuncAdr('glProgramLocalParameter4dvARB');
public z_ProgramLocalParameter4dvARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; var ¶ms: real)>(z_ProgramLocalParameter4dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4dvARB(target: ProgramTarget; index: UInt32; ¶ms: array of real);
begin
z_ProgramLocalParameter4dvARB_ovr_0(target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4dvARB(target: ProgramTarget; index: UInt32; var ¶ms: real);
begin
z_ProgramLocalParameter4dvARB_ovr_0(target, index, ¶ms);
end;
public z_ProgramLocalParameter4dvARB_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_ProgramLocalParameter4dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4dvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_ProgramLocalParameter4dvARB_ovr_2(target, index, ¶ms);
end;
public z_ProgramLocalParameter4fARB_adr := GetFuncAdr('glProgramLocalParameter4fARB');
public z_ProgramLocalParameter4fARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; x: single; y: single; z: single; w: single)>(z_ProgramLocalParameter4fARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4fARB(target: ProgramTarget; index: UInt32; x: single; y: single; z: single; w: single);
begin
z_ProgramLocalParameter4fARB_ovr_0(target, index, x, y, z, w);
end;
public z_ProgramLocalParameter4fvARB_adr := GetFuncAdr('glProgramLocalParameter4fvARB');
public z_ProgramLocalParameter4fvARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; var ¶ms: single)>(z_ProgramLocalParameter4fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4fvARB(target: ProgramTarget; index: UInt32; ¶ms: array of single);
begin
z_ProgramLocalParameter4fvARB_ovr_0(target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4fvARB(target: ProgramTarget; index: UInt32; var ¶ms: single);
begin
z_ProgramLocalParameter4fvARB_ovr_0(target, index, ¶ms);
end;
public z_ProgramLocalParameter4fvARB_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_ProgramLocalParameter4fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4fvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_ProgramLocalParameter4fvARB_ovr_2(target, index, ¶ms);
end;
public z_GetProgramEnvParameterdvARB_adr := GetFuncAdr('glGetProgramEnvParameterdvARB');
public z_GetProgramEnvParameterdvARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; var ¶ms: real)>(z_GetProgramEnvParameterdvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterdvARB(target: ProgramTarget; index: UInt32; ¶ms: array of real);
begin
z_GetProgramEnvParameterdvARB_ovr_0(target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterdvARB(target: ProgramTarget; index: UInt32; var ¶ms: real);
begin
z_GetProgramEnvParameterdvARB_ovr_0(target, index, ¶ms);
end;
public z_GetProgramEnvParameterdvARB_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_GetProgramEnvParameterdvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterdvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_GetProgramEnvParameterdvARB_ovr_2(target, index, ¶ms);
end;
public z_GetProgramEnvParameterfvARB_adr := GetFuncAdr('glGetProgramEnvParameterfvARB');
public z_GetProgramEnvParameterfvARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; var ¶ms: single)>(z_GetProgramEnvParameterfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterfvARB(target: ProgramTarget; index: UInt32; ¶ms: array of single);
begin
z_GetProgramEnvParameterfvARB_ovr_0(target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterfvARB(target: ProgramTarget; index: UInt32; var ¶ms: single);
begin
z_GetProgramEnvParameterfvARB_ovr_0(target, index, ¶ms);
end;
public z_GetProgramEnvParameterfvARB_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_GetProgramEnvParameterfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterfvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_GetProgramEnvParameterfvARB_ovr_2(target, index, ¶ms);
end;
public z_GetProgramLocalParameterdvARB_adr := GetFuncAdr('glGetProgramLocalParameterdvARB');
public z_GetProgramLocalParameterdvARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; var ¶ms: real)>(z_GetProgramLocalParameterdvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterdvARB(target: ProgramTarget; index: UInt32; ¶ms: array of real);
begin
z_GetProgramLocalParameterdvARB_ovr_0(target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterdvARB(target: ProgramTarget; index: UInt32; var ¶ms: real);
begin
z_GetProgramLocalParameterdvARB_ovr_0(target, index, ¶ms);
end;
public z_GetProgramLocalParameterdvARB_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_GetProgramLocalParameterdvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterdvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_GetProgramLocalParameterdvARB_ovr_2(target, index, ¶ms);
end;
public z_GetProgramLocalParameterfvARB_adr := GetFuncAdr('glGetProgramLocalParameterfvARB');
public z_GetProgramLocalParameterfvARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; var ¶ms: single)>(z_GetProgramLocalParameterfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterfvARB(target: ProgramTarget; index: UInt32; ¶ms: array of single);
begin
z_GetProgramLocalParameterfvARB_ovr_0(target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterfvARB(target: ProgramTarget; index: UInt32; var ¶ms: single);
begin
z_GetProgramLocalParameterfvARB_ovr_0(target, index, ¶ms);
end;
public z_GetProgramLocalParameterfvARB_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_GetProgramLocalParameterfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterfvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_GetProgramLocalParameterfvARB_ovr_2(target, index, ¶ms);
end;
public z_GetProgramivARB_adr := GetFuncAdr('glGetProgramivARB');
public z_GetProgramivARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; pname: ProgramPropertyARB; var ¶ms: Int32)>(z_GetProgramivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramivARB(target: ProgramTarget; pname: ProgramPropertyARB; ¶ms: array of Int32);
begin
z_GetProgramivARB_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramivARB(target: ProgramTarget; pname: ProgramPropertyARB; var ¶ms: Int32);
begin
z_GetProgramivARB_ovr_0(target, pname, ¶ms);
end;
public z_GetProgramivARB_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; pname: ProgramPropertyARB; ¶ms: IntPtr)>(z_GetProgramivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramivARB(target: ProgramTarget; pname: ProgramPropertyARB; ¶ms: IntPtr);
begin
z_GetProgramivARB_ovr_2(target, pname, ¶ms);
end;
public z_GetProgramStringARB_adr := GetFuncAdr('glGetProgramStringARB');
public z_GetProgramStringARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; pname: ProgramStringProperty; string: IntPtr)>(z_GetProgramStringARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramStringARB(target: ProgramTarget; pname: ProgramStringProperty; string: IntPtr);
begin
z_GetProgramStringARB_ovr_0(target, pname, string);
end;
public z_IsProgramARB_adr := GetFuncAdr('glIsProgramARB');
public z_IsProgramARB_ovr_0 := GetFuncOrNil&<function(&program: UInt32): boolean>(z_IsProgramARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsProgramARB(&program: UInt32): boolean;
begin
Result := z_IsProgramARB_ovr_0(&program);
end;
end;
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);
end;
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);
end;
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);
public z_ProgramParameteriARB_adr := GetFuncAdr('glProgramParameteriARB');
public z_ProgramParameteriARB_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; pname: ProgramParameterPName; value: Int32)>(z_ProgramParameteriARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameteriARB(&program: UInt32; pname: ProgramParameterPName; value: Int32);
begin
z_ProgramParameteriARB_ovr_0(&program, pname, value);
end;
public z_FramebufferTextureARB_adr := GetFuncAdr('glFramebufferTextureARB');
public z_FramebufferTextureARB_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; attachment: FramebufferAttachment; texture: UInt32; level: Int32)>(z_FramebufferTextureARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTextureARB(target: FramebufferTarget; attachment: FramebufferAttachment; texture: UInt32; level: Int32);
begin
z_FramebufferTextureARB_ovr_0(target, attachment, texture, level);
end;
public z_FramebufferTextureLayerARB_adr := GetFuncAdr('glFramebufferTextureLayerARB');
public z_FramebufferTextureLayerARB_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; attachment: FramebufferAttachment; texture: UInt32; level: Int32; layer: Int32)>(z_FramebufferTextureLayerARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTextureLayerARB(target: FramebufferTarget; attachment: FramebufferAttachment; texture: UInt32; level: Int32; layer: Int32);
begin
z_FramebufferTextureLayerARB_ovr_0(target, attachment, texture, level, layer);
end;
public z_FramebufferTextureFaceARB_adr := GetFuncAdr('glFramebufferTextureFaceARB');
public z_FramebufferTextureFaceARB_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; attachment: FramebufferAttachment; texture: UInt32; level: Int32; face: TextureTarget)>(z_FramebufferTextureFaceARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTextureFaceARB(target: FramebufferTarget; attachment: FramebufferAttachment; texture: UInt32; level: Int32; face: TextureTarget);
begin
z_FramebufferTextureFaceARB_ovr_0(target, attachment, texture, level, face);
end;
end;
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);
end;
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);
end;
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);
public z_SpecializeShaderARB_adr := GetFuncAdr('glSpecializeShaderARB');
public z_SpecializeShaderARB_ovr_0 := GetFuncOrNil&<procedure(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; var pConstantValue: UInt32)>(z_SpecializeShaderARB_adr);
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);
z_SpecializeShaderARB_ovr_0(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex[0], pConstantValue[0]);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
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);
z_SpecializeShaderARB_ovr_0(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex[0], pConstantValue);
Marshal.FreeHGlobal(par_2_str_ptr);
end;
public z_SpecializeShaderARB_ovr_2 := GetFuncOrNil&<procedure(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; pConstantValue: IntPtr)>(z_SpecializeShaderARB_adr);
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);
z_SpecializeShaderARB_ovr_2(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex[0], 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);
z_SpecializeShaderARB_ovr_0(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex, pConstantValue[0]);
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;
public z_SpecializeShaderARB_ovr_6 := GetFuncOrNil&<procedure(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; var pConstantValue: UInt32)>(z_SpecializeShaderARB_adr);
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);
z_SpecializeShaderARB_ovr_6(shader, par_2_str_ptr, numSpecializationConstants, pConstantIndex, pConstantValue[0]);
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;
public z_SpecializeShaderARB_ovr_8 := GetFuncOrNil&<procedure(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; pConstantValue: IntPtr)>(z_SpecializeShaderARB_adr);
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);
begin
z_SpecializeShaderARB_ovr_0(shader, pEntryPoint, numSpecializationConstants, pConstantIndex[0], pConstantValue[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShaderARB(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: array of UInt32; var pConstantValue: UInt32);
begin
z_SpecializeShaderARB_ovr_0(shader, pEntryPoint, numSpecializationConstants, pConstantIndex[0], pConstantValue);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShaderARB(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: array of UInt32; pConstantValue: IntPtr);
begin
z_SpecializeShaderARB_ovr_2(shader, pEntryPoint, numSpecializationConstants, pConstantIndex[0], pConstantValue);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShaderARB(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; pConstantValue: array of UInt32);
begin
z_SpecializeShaderARB_ovr_0(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShaderARB(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; var pConstantValue: UInt32);
begin
z_SpecializeShaderARB_ovr_0(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShaderARB(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; var pConstantIndex: UInt32; pConstantValue: IntPtr);
begin
z_SpecializeShaderARB_ovr_2(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShaderARB(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; pConstantValue: array of UInt32);
begin
z_SpecializeShaderARB_ovr_6(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShaderARB(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; var pConstantValue: UInt32);
begin
z_SpecializeShaderARB_ovr_6(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpecializeShaderARB(shader: UInt32; pEntryPoint: IntPtr; numSpecializationConstants: UInt32; pConstantIndex: IntPtr; pConstantValue: IntPtr);
begin
z_SpecializeShaderARB_ovr_8(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue);
end;
end;
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);
end;
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);
public z_Uniform1i64ARB_adr := GetFuncAdr('glUniform1i64ARB');
public z_Uniform1i64ARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; x: Int64)>(z_Uniform1i64ARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1i64ARB(location: Int32; x: Int64);
begin
z_Uniform1i64ARB_ovr_0(location, x);
end;
public z_Uniform2i64ARB_adr := GetFuncAdr('glUniform2i64ARB');
public z_Uniform2i64ARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; x: Int64; y: Int64)>(z_Uniform2i64ARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2i64ARB(location: Int32; x: Int64; y: Int64);
begin
z_Uniform2i64ARB_ovr_0(location, x, y);
end;
public z_Uniform3i64ARB_adr := GetFuncAdr('glUniform3i64ARB');
public z_Uniform3i64ARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; x: Int64; y: Int64; z: Int64)>(z_Uniform3i64ARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3i64ARB(location: Int32; x: Int64; y: Int64; z: Int64);
begin
z_Uniform3i64ARB_ovr_0(location, x, y, z);
end;
public z_Uniform4i64ARB_adr := GetFuncAdr('glUniform4i64ARB');
public z_Uniform4i64ARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; x: Int64; y: Int64; z: Int64; w: Int64)>(z_Uniform4i64ARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4i64ARB(location: Int32; x: Int64; y: Int64; z: Int64; w: Int64);
begin
z_Uniform4i64ARB_ovr_0(location, x, y, z, w);
end;
public z_Uniform1i64vARB_adr := GetFuncAdr('glUniform1i64vARB');
public z_Uniform1i64vARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Int64)>(z_Uniform1i64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1i64vARB(location: Int32; count: Int32; value: array of Int64);
begin
z_Uniform1i64vARB_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1i64vARB(location: Int32; count: Int32; var value: Int64);
begin
z_Uniform1i64vARB_ovr_0(location, count, value);
end;
public z_Uniform1i64vARB_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform1i64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1i64vARB(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform1i64vARB_ovr_2(location, count, value);
end;
public z_Uniform2i64vARB_adr := GetFuncAdr('glUniform2i64vARB');
public z_Uniform2i64vARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Int64)>(z_Uniform2i64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2i64vARB(location: Int32; count: Int32; value: array of Int64);
begin
z_Uniform2i64vARB_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2i64vARB(location: Int32; count: Int32; var value: Int64);
begin
z_Uniform2i64vARB_ovr_0(location, count, value);
end;
public z_Uniform2i64vARB_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform2i64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2i64vARB(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform2i64vARB_ovr_2(location, count, value);
end;
public z_Uniform3i64vARB_adr := GetFuncAdr('glUniform3i64vARB');
public z_Uniform3i64vARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Int64)>(z_Uniform3i64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3i64vARB(location: Int32; count: Int32; value: array of Int64);
begin
z_Uniform3i64vARB_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3i64vARB(location: Int32; count: Int32; var value: Int64);
begin
z_Uniform3i64vARB_ovr_0(location, count, value);
end;
public z_Uniform3i64vARB_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform3i64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3i64vARB(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform3i64vARB_ovr_2(location, count, value);
end;
public z_Uniform4i64vARB_adr := GetFuncAdr('glUniform4i64vARB');
public z_Uniform4i64vARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Int64)>(z_Uniform4i64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4i64vARB(location: Int32; count: Int32; value: array of Int64);
begin
z_Uniform4i64vARB_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4i64vARB(location: Int32; count: Int32; var value: Int64);
begin
z_Uniform4i64vARB_ovr_0(location, count, value);
end;
public z_Uniform4i64vARB_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform4i64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4i64vARB(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform4i64vARB_ovr_2(location, count, value);
end;
public z_Uniform1ui64ARB_adr := GetFuncAdr('glUniform1ui64ARB');
public z_Uniform1ui64ARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; x: UInt64)>(z_Uniform1ui64ARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ui64ARB(location: Int32; x: UInt64);
begin
z_Uniform1ui64ARB_ovr_0(location, x);
end;
public z_Uniform2ui64ARB_adr := GetFuncAdr('glUniform2ui64ARB');
public z_Uniform2ui64ARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; x: UInt64; y: UInt64)>(z_Uniform2ui64ARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2ui64ARB(location: Int32; x: UInt64; y: UInt64);
begin
z_Uniform2ui64ARB_ovr_0(location, x, y);
end;
public z_Uniform3ui64ARB_adr := GetFuncAdr('glUniform3ui64ARB');
public z_Uniform3ui64ARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; x: UInt64; y: UInt64; z: UInt64)>(z_Uniform3ui64ARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3ui64ARB(location: Int32; x: UInt64; y: UInt64; z: UInt64);
begin
z_Uniform3ui64ARB_ovr_0(location, x, y, z);
end;
public z_Uniform4ui64ARB_adr := GetFuncAdr('glUniform4ui64ARB');
public z_Uniform4ui64ARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; x: UInt64; y: UInt64; z: UInt64; w: UInt64)>(z_Uniform4ui64ARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4ui64ARB(location: Int32; x: UInt64; y: UInt64; z: UInt64; w: UInt64);
begin
z_Uniform4ui64ARB_ovr_0(location, x, y, z, w);
end;
public z_Uniform1ui64vARB_adr := GetFuncAdr('glUniform1ui64vARB');
public z_Uniform1ui64vARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: UInt64)>(z_Uniform1ui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ui64vARB(location: Int32; count: Int32; value: array of UInt64);
begin
z_Uniform1ui64vARB_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ui64vARB(location: Int32; count: Int32; var value: UInt64);
begin
z_Uniform1ui64vARB_ovr_0(location, count, value);
end;
public z_Uniform1ui64vARB_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform1ui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ui64vARB(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform1ui64vARB_ovr_2(location, count, value);
end;
public z_Uniform2ui64vARB_adr := GetFuncAdr('glUniform2ui64vARB');
public z_Uniform2ui64vARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: UInt64)>(z_Uniform2ui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2ui64vARB(location: Int32; count: Int32; value: array of UInt64);
begin
z_Uniform2ui64vARB_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2ui64vARB(location: Int32; count: Int32; var value: UInt64);
begin
z_Uniform2ui64vARB_ovr_0(location, count, value);
end;
public z_Uniform2ui64vARB_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform2ui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2ui64vARB(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform2ui64vARB_ovr_2(location, count, value);
end;
public z_Uniform3ui64vARB_adr := GetFuncAdr('glUniform3ui64vARB');
public z_Uniform3ui64vARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: UInt64)>(z_Uniform3ui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3ui64vARB(location: Int32; count: Int32; value: array of UInt64);
begin
z_Uniform3ui64vARB_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3ui64vARB(location: Int32; count: Int32; var value: UInt64);
begin
z_Uniform3ui64vARB_ovr_0(location, count, value);
end;
public z_Uniform3ui64vARB_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform3ui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3ui64vARB(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform3ui64vARB_ovr_2(location, count, value);
end;
public z_Uniform4ui64vARB_adr := GetFuncAdr('glUniform4ui64vARB');
public z_Uniform4ui64vARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: UInt64)>(z_Uniform4ui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4ui64vARB(location: Int32; count: Int32; value: array of UInt64);
begin
z_Uniform4ui64vARB_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4ui64vARB(location: Int32; count: Int32; var value: UInt64);
begin
z_Uniform4ui64vARB_ovr_0(location, count, value);
end;
public z_Uniform4ui64vARB_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform4ui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4ui64vARB(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform4ui64vARB_ovr_2(location, count, value);
end;
public z_GetUniformi64vARB_adr := GetFuncAdr('glGetUniformi64vARB');
public z_GetUniformi64vARB_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; var ¶ms: Int64)>(z_GetUniformi64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformi64vARB(&program: UInt32; location: Int32; ¶ms: array of Int64);
begin
z_GetUniformi64vARB_ovr_0(&program, location, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformi64vARB(&program: UInt32; location: Int32; var ¶ms: Int64);
begin
z_GetUniformi64vARB_ovr_0(&program, location, ¶ms);
end;
public z_GetUniformi64vARB_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; ¶ms: IntPtr)>(z_GetUniformi64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformi64vARB(&program: UInt32; location: Int32; ¶ms: IntPtr);
begin
z_GetUniformi64vARB_ovr_2(&program, location, ¶ms);
end;
public z_GetUniformui64vARB_adr := GetFuncAdr('glGetUniformui64vARB');
public z_GetUniformui64vARB_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; var ¶ms: UInt64)>(z_GetUniformui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformui64vARB(&program: UInt32; location: Int32; ¶ms: array of UInt64);
begin
z_GetUniformui64vARB_ovr_0(&program, location, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformui64vARB(&program: UInt32; location: Int32; var ¶ms: UInt64);
begin
z_GetUniformui64vARB_ovr_0(&program, location, ¶ms);
end;
public z_GetUniformui64vARB_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; ¶ms: IntPtr)>(z_GetUniformui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformui64vARB(&program: UInt32; location: Int32; ¶ms: IntPtr);
begin
z_GetUniformui64vARB_ovr_2(&program, location, ¶ms);
end;
public z_GetnUniformi64vARB_adr := GetFuncAdr('glGetnUniformi64vARB');
public z_GetnUniformi64vARB_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; bufSize: Int32; var ¶ms: Int64)>(z_GetnUniformi64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformi64vARB(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: array of Int64);
begin
z_GetnUniformi64vARB_ovr_0(&program, location, bufSize, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformi64vARB(&program: UInt32; location: Int32; bufSize: Int32; var ¶ms: Int64);
begin
z_GetnUniformi64vARB_ovr_0(&program, location, bufSize, ¶ms);
end;
public z_GetnUniformi64vARB_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr)>(z_GetnUniformi64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformi64vARB(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr);
begin
z_GetnUniformi64vARB_ovr_2(&program, location, bufSize, ¶ms);
end;
public z_GetnUniformui64vARB_adr := GetFuncAdr('glGetnUniformui64vARB');
public z_GetnUniformui64vARB_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; bufSize: Int32; var ¶ms: UInt64)>(z_GetnUniformui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformui64vARB(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: array of UInt64);
begin
z_GetnUniformui64vARB_ovr_0(&program, location, bufSize, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformui64vARB(&program: UInt32; location: Int32; bufSize: Int32; var ¶ms: UInt64);
begin
z_GetnUniformui64vARB_ovr_0(&program, location, bufSize, ¶ms);
end;
public z_GetnUniformui64vARB_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr)>(z_GetnUniformui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformui64vARB(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr);
begin
z_GetnUniformui64vARB_ovr_2(&program, location, bufSize, ¶ms);
end;
public z_ProgramUniform1i64ARB_adr := GetFuncAdr('glProgramUniform1i64ARB');
public z_ProgramUniform1i64ARB_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; x: Int64)>(z_ProgramUniform1i64ARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1i64ARB(&program: UInt32; location: Int32; x: Int64);
begin
z_ProgramUniform1i64ARB_ovr_0(&program, location, x);
end;
public z_ProgramUniform2i64ARB_adr := GetFuncAdr('glProgramUniform2i64ARB');
public z_ProgramUniform2i64ARB_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; x: Int64; y: Int64)>(z_ProgramUniform2i64ARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2i64ARB(&program: UInt32; location: Int32; x: Int64; y: Int64);
begin
z_ProgramUniform2i64ARB_ovr_0(&program, location, x, y);
end;
public z_ProgramUniform3i64ARB_adr := GetFuncAdr('glProgramUniform3i64ARB');
public z_ProgramUniform3i64ARB_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; x: Int64; y: Int64; z: Int64)>(z_ProgramUniform3i64ARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3i64ARB(&program: UInt32; location: Int32; x: Int64; y: Int64; z: Int64);
begin
z_ProgramUniform3i64ARB_ovr_0(&program, location, x, y, z);
end;
public z_ProgramUniform4i64ARB_adr := GetFuncAdr('glProgramUniform4i64ARB');
public z_ProgramUniform4i64ARB_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; x: Int64; y: Int64; z: Int64; w: Int64)>(z_ProgramUniform4i64ARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4i64ARB(&program: UInt32; location: Int32; x: Int64; y: Int64; z: Int64; w: Int64);
begin
z_ProgramUniform4i64ARB_ovr_0(&program, location, x, y, z, w);
end;
public z_ProgramUniform1i64vARB_adr := GetFuncAdr('glProgramUniform1i64vARB');
public z_ProgramUniform1i64vARB_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: Int64)>(z_ProgramUniform1i64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1i64vARB(&program: UInt32; location: Int32; count: Int32; value: array of Int64);
begin
z_ProgramUniform1i64vARB_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1i64vARB(&program: UInt32; location: Int32; count: Int32; var value: Int64);
begin
z_ProgramUniform1i64vARB_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform1i64vARB_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform1i64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1i64vARB(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform1i64vARB_ovr_2(&program, location, count, value);
end;
public z_ProgramUniform2i64vARB_adr := GetFuncAdr('glProgramUniform2i64vARB');
public z_ProgramUniform2i64vARB_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: Int64)>(z_ProgramUniform2i64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2i64vARB(&program: UInt32; location: Int32; count: Int32; value: array of Int64);
begin
z_ProgramUniform2i64vARB_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2i64vARB(&program: UInt32; location: Int32; count: Int32; var value: Int64);
begin
z_ProgramUniform2i64vARB_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform2i64vARB_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform2i64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2i64vARB(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform2i64vARB_ovr_2(&program, location, count, value);
end;
public z_ProgramUniform3i64vARB_adr := GetFuncAdr('glProgramUniform3i64vARB');
public z_ProgramUniform3i64vARB_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: Int64)>(z_ProgramUniform3i64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3i64vARB(&program: UInt32; location: Int32; count: Int32; value: array of Int64);
begin
z_ProgramUniform3i64vARB_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3i64vARB(&program: UInt32; location: Int32; count: Int32; var value: Int64);
begin
z_ProgramUniform3i64vARB_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform3i64vARB_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform3i64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3i64vARB(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform3i64vARB_ovr_2(&program, location, count, value);
end;
public z_ProgramUniform4i64vARB_adr := GetFuncAdr('glProgramUniform4i64vARB');
public z_ProgramUniform4i64vARB_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: Int64)>(z_ProgramUniform4i64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4i64vARB(&program: UInt32; location: Int32; count: Int32; value: array of Int64);
begin
z_ProgramUniform4i64vARB_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4i64vARB(&program: UInt32; location: Int32; count: Int32; var value: Int64);
begin
z_ProgramUniform4i64vARB_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform4i64vARB_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform4i64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4i64vARB(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform4i64vARB_ovr_2(&program, location, count, value);
end;
public z_ProgramUniform1ui64ARB_adr := GetFuncAdr('glProgramUniform1ui64ARB');
public z_ProgramUniform1ui64ARB_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; x: UInt64)>(z_ProgramUniform1ui64ARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ui64ARB(&program: UInt32; location: Int32; x: UInt64);
begin
z_ProgramUniform1ui64ARB_ovr_0(&program, location, x);
end;
public z_ProgramUniform2ui64ARB_adr := GetFuncAdr('glProgramUniform2ui64ARB');
public z_ProgramUniform2ui64ARB_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; x: UInt64; y: UInt64)>(z_ProgramUniform2ui64ARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ui64ARB(&program: UInt32; location: Int32; x: UInt64; y: UInt64);
begin
z_ProgramUniform2ui64ARB_ovr_0(&program, location, x, y);
end;
public z_ProgramUniform3ui64ARB_adr := GetFuncAdr('glProgramUniform3ui64ARB');
public z_ProgramUniform3ui64ARB_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; x: UInt64; y: UInt64; z: UInt64)>(z_ProgramUniform3ui64ARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ui64ARB(&program: UInt32; location: Int32; x: UInt64; y: UInt64; z: UInt64);
begin
z_ProgramUniform3ui64ARB_ovr_0(&program, location, x, y, z);
end;
public z_ProgramUniform4ui64ARB_adr := GetFuncAdr('glProgramUniform4ui64ARB');
public z_ProgramUniform4ui64ARB_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; x: UInt64; y: UInt64; z: UInt64; w: UInt64)>(z_ProgramUniform4ui64ARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ui64ARB(&program: UInt32; location: Int32; x: UInt64; y: UInt64; z: UInt64; w: UInt64);
begin
z_ProgramUniform4ui64ARB_ovr_0(&program, location, x, y, z, w);
end;
public z_ProgramUniform1ui64vARB_adr := GetFuncAdr('glProgramUniform1ui64vARB');
public z_ProgramUniform1ui64vARB_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: UInt64)>(z_ProgramUniform1ui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ui64vARB(&program: UInt32; location: Int32; count: Int32; value: array of UInt64);
begin
z_ProgramUniform1ui64vARB_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ui64vARB(&program: UInt32; location: Int32; count: Int32; var value: UInt64);
begin
z_ProgramUniform1ui64vARB_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform1ui64vARB_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform1ui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ui64vARB(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform1ui64vARB_ovr_2(&program, location, count, value);
end;
public z_ProgramUniform2ui64vARB_adr := GetFuncAdr('glProgramUniform2ui64vARB');
public z_ProgramUniform2ui64vARB_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: UInt64)>(z_ProgramUniform2ui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ui64vARB(&program: UInt32; location: Int32; count: Int32; value: array of UInt64);
begin
z_ProgramUniform2ui64vARB_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ui64vARB(&program: UInt32; location: Int32; count: Int32; var value: UInt64);
begin
z_ProgramUniform2ui64vARB_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform2ui64vARB_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform2ui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ui64vARB(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform2ui64vARB_ovr_2(&program, location, count, value);
end;
public z_ProgramUniform3ui64vARB_adr := GetFuncAdr('glProgramUniform3ui64vARB');
public z_ProgramUniform3ui64vARB_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: UInt64)>(z_ProgramUniform3ui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ui64vARB(&program: UInt32; location: Int32; count: Int32; value: array of UInt64);
begin
z_ProgramUniform3ui64vARB_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ui64vARB(&program: UInt32; location: Int32; count: Int32; var value: UInt64);
begin
z_ProgramUniform3ui64vARB_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform3ui64vARB_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform3ui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ui64vARB(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform3ui64vARB_ovr_2(&program, location, count, value);
end;
public z_ProgramUniform4ui64vARB_adr := GetFuncAdr('glProgramUniform4ui64vARB');
public z_ProgramUniform4ui64vARB_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: UInt64)>(z_ProgramUniform4ui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ui64vARB(&program: UInt32; location: Int32; count: Int32; value: array of UInt64);
begin
z_ProgramUniform4ui64vARB_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ui64vARB(&program: UInt32; location: Int32; count: Int32; var value: UInt64);
begin
z_ProgramUniform4ui64vARB_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform4ui64vARB_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform4ui64vARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ui64vARB(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform4ui64vARB_ovr_2(&program, location, count, value);
end;
end;
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);
end;
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);
public z_MultiDrawArraysIndirectCountARB_adr := GetFuncAdr('glMultiDrawArraysIndirectCountARB');
public z_MultiDrawArraysIndirectCountARB_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; indirect: IntPtr; drawcount: IntPtr; maxdrawcount: Int32; stride: Int32)>(z_MultiDrawArraysIndirectCountARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysIndirectCountARB(mode: PrimitiveType; indirect: IntPtr; drawcount: IntPtr; maxdrawcount: Int32; stride: Int32);
begin
z_MultiDrawArraysIndirectCountARB_ovr_0(mode, indirect, drawcount, maxdrawcount, stride);
end;
public z_MultiDrawElementsIndirectCountARB_adr := GetFuncAdr('glMultiDrawElementsIndirectCountARB');
public z_MultiDrawElementsIndirectCountARB_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; &type: DrawElementsType; indirect: IntPtr; drawcount: IntPtr; maxdrawcount: Int32; stride: Int32)>(z_MultiDrawElementsIndirectCountARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsIndirectCountARB(mode: PrimitiveType; &type: DrawElementsType; indirect: IntPtr; drawcount: IntPtr; maxdrawcount: Int32; stride: Int32);
begin
z_MultiDrawElementsIndirectCountARB_ovr_0(mode, &type, indirect, drawcount, maxdrawcount, stride);
end;
end;
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);
public z_VertexAttribDivisorARB_adr := GetFuncAdr('glVertexAttribDivisorARB');
public z_VertexAttribDivisorARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; divisor: UInt32)>(z_VertexAttribDivisorARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribDivisorARB(index: UInt32; divisor: UInt32);
begin
z_VertexAttribDivisorARB_ovr_0(index, divisor);
end;
end;
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);
end;
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);
end;
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);
end;
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);
end;
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);
public z_CurrentPaletteMatrixARB_adr := GetFuncAdr('glCurrentPaletteMatrixARB');
public z_CurrentPaletteMatrixARB_ovr_0 := GetFuncOrNil&<procedure(index: Int32)>(z_CurrentPaletteMatrixARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CurrentPaletteMatrixARB(index: Int32);
begin
z_CurrentPaletteMatrixARB_ovr_0(index);
end;
public z_MatrixIndexubvARB_adr := GetFuncAdr('glMatrixIndexubvARB');
public z_MatrixIndexubvARB_ovr_0 := GetFuncOrNil&<procedure(size: Int32; var indices: Byte)>(z_MatrixIndexubvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixIndexubvARB(size: Int32; indices: array of Byte);
begin
z_MatrixIndexubvARB_ovr_0(size, indices[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixIndexubvARB(size: Int32; var indices: Byte);
begin
z_MatrixIndexubvARB_ovr_0(size, indices);
end;
public z_MatrixIndexubvARB_ovr_2 := GetFuncOrNil&<procedure(size: Int32; indices: IntPtr)>(z_MatrixIndexubvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixIndexubvARB(size: Int32; indices: IntPtr);
begin
z_MatrixIndexubvARB_ovr_2(size, indices);
end;
public z_MatrixIndexusvARB_adr := GetFuncAdr('glMatrixIndexusvARB');
public z_MatrixIndexusvARB_ovr_0 := GetFuncOrNil&<procedure(size: Int32; var indices: UInt16)>(z_MatrixIndexusvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixIndexusvARB(size: Int32; indices: array of UInt16);
begin
z_MatrixIndexusvARB_ovr_0(size, indices[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixIndexusvARB(size: Int32; var indices: UInt16);
begin
z_MatrixIndexusvARB_ovr_0(size, indices);
end;
public z_MatrixIndexusvARB_ovr_2 := GetFuncOrNil&<procedure(size: Int32; indices: IntPtr)>(z_MatrixIndexusvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixIndexusvARB(size: Int32; indices: IntPtr);
begin
z_MatrixIndexusvARB_ovr_2(size, indices);
end;
public z_MatrixIndexuivARB_adr := GetFuncAdr('glMatrixIndexuivARB');
public z_MatrixIndexuivARB_ovr_0 := GetFuncOrNil&<procedure(size: Int32; var indices: UInt32)>(z_MatrixIndexuivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixIndexuivARB(size: Int32; indices: array of UInt32);
begin
z_MatrixIndexuivARB_ovr_0(size, indices[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixIndexuivARB(size: Int32; var indices: UInt32);
begin
z_MatrixIndexuivARB_ovr_0(size, indices);
end;
public z_MatrixIndexuivARB_ovr_2 := GetFuncOrNil&<procedure(size: Int32; indices: IntPtr)>(z_MatrixIndexuivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixIndexuivARB(size: Int32; indices: IntPtr);
begin
z_MatrixIndexuivARB_ovr_2(size, indices);
end;
public z_MatrixIndexPointerARB_adr := GetFuncAdr('glMatrixIndexPointerARB');
public z_MatrixIndexPointerARB_ovr_0 := GetFuncOrNil&<procedure(size: Int32; &type: MatrixIndexPointerTypeARB; stride: Int32; pointer: IntPtr)>(z_MatrixIndexPointerARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixIndexPointerARB(size: Int32; &type: MatrixIndexPointerTypeARB; stride: Int32; pointer: IntPtr);
begin
z_MatrixIndexPointerARB_ovr_0(size, &type, stride, pointer);
end;
end;
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);
end;
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);
end;
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);
public z_SampleCoverageARB_adr := GetFuncAdr('glSampleCoverageARB');
public z_SampleCoverageARB_ovr_0 := GetFuncOrNil&<procedure(value: single; invert: boolean)>(z_SampleCoverageARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SampleCoverageARB(value: single; invert: boolean);
begin
z_SampleCoverageARB_ovr_0(value, invert);
end;
end;
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);
public z_ActiveTextureARB_adr := GetFuncAdr('glActiveTextureARB');
public z_ActiveTextureARB_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit)>(z_ActiveTextureARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ActiveTextureARB(texture: TextureUnit);
begin
z_ActiveTextureARB_ovr_0(texture);
end;
public z_ClientActiveTextureARB_adr := GetFuncAdr('glClientActiveTextureARB');
public z_ClientActiveTextureARB_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit)>(z_ClientActiveTextureARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClientActiveTextureARB(texture: TextureUnit);
begin
z_ClientActiveTextureARB_ovr_0(texture);
end;
public z_MultiTexCoord1dARB_adr := GetFuncAdr('glMultiTexCoord1dARB');
public z_MultiTexCoord1dARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: real)>(z_MultiTexCoord1dARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1dARB(target: TextureUnit; s: real);
begin
z_MultiTexCoord1dARB_ovr_0(target, s);
end;
public z_MultiTexCoord1dvARB_adr := GetFuncAdr('glMultiTexCoord1dvARB');
public z_MultiTexCoord1dvARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: real)>(z_MultiTexCoord1dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1dvARB(target: TextureUnit; v: array of real);
begin
z_MultiTexCoord1dvARB_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1dvARB(target: TextureUnit; var v: real);
begin
z_MultiTexCoord1dvARB_ovr_0(target, v);
end;
public z_MultiTexCoord1dvARB_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord1dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1dvARB(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord1dvARB_ovr_2(target, v);
end;
public z_MultiTexCoord1fARB_adr := GetFuncAdr('glMultiTexCoord1fARB');
public z_MultiTexCoord1fARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: single)>(z_MultiTexCoord1fARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1fARB(target: TextureUnit; s: single);
begin
z_MultiTexCoord1fARB_ovr_0(target, s);
end;
public z_MultiTexCoord1fvARB_adr := GetFuncAdr('glMultiTexCoord1fvARB');
public z_MultiTexCoord1fvARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: single)>(z_MultiTexCoord1fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1fvARB(target: TextureUnit; v: array of single);
begin
z_MultiTexCoord1fvARB_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1fvARB(target: TextureUnit; var v: single);
begin
z_MultiTexCoord1fvARB_ovr_0(target, v);
end;
public z_MultiTexCoord1fvARB_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord1fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1fvARB(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord1fvARB_ovr_2(target, v);
end;
public z_MultiTexCoord1iARB_adr := GetFuncAdr('glMultiTexCoord1iARB');
public z_MultiTexCoord1iARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: Int32)>(z_MultiTexCoord1iARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1iARB(target: TextureUnit; s: Int32);
begin
z_MultiTexCoord1iARB_ovr_0(target, s);
end;
public z_MultiTexCoord1ivARB_adr := GetFuncAdr('glMultiTexCoord1ivARB');
public z_MultiTexCoord1ivARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Int32)>(z_MultiTexCoord1ivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1ivARB(target: TextureUnit; v: array of Int32);
begin
z_MultiTexCoord1ivARB_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1ivARB(target: TextureUnit; var v: Int32);
begin
z_MultiTexCoord1ivARB_ovr_0(target, v);
end;
public z_MultiTexCoord1ivARB_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord1ivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1ivARB(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord1ivARB_ovr_2(target, v);
end;
public z_MultiTexCoord1sARB_adr := GetFuncAdr('glMultiTexCoord1sARB');
public z_MultiTexCoord1sARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: Int16)>(z_MultiTexCoord1sARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1sARB(target: TextureUnit; s: Int16);
begin
z_MultiTexCoord1sARB_ovr_0(target, s);
end;
public z_MultiTexCoord1svARB_adr := GetFuncAdr('glMultiTexCoord1svARB');
public z_MultiTexCoord1svARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Int16)>(z_MultiTexCoord1svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1svARB(target: TextureUnit; v: array of Int16);
begin
z_MultiTexCoord1svARB_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1svARB(target: TextureUnit; var v: Int16);
begin
z_MultiTexCoord1svARB_ovr_0(target, v);
end;
public z_MultiTexCoord1svARB_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord1svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1svARB(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord1svARB_ovr_2(target, v);
end;
public z_MultiTexCoord2dARB_adr := GetFuncAdr('glMultiTexCoord2dARB');
public z_MultiTexCoord2dARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: real; t: real)>(z_MultiTexCoord2dARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2dARB(target: TextureUnit; s: real; t: real);
begin
z_MultiTexCoord2dARB_ovr_0(target, s, t);
end;
public z_MultiTexCoord2dvARB_adr := GetFuncAdr('glMultiTexCoord2dvARB');
public z_MultiTexCoord2dvARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: real)>(z_MultiTexCoord2dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2dvARB(target: TextureUnit; v: array of real);
begin
z_MultiTexCoord2dvARB_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2dvARB(target: TextureUnit; var v: real);
begin
z_MultiTexCoord2dvARB_ovr_0(target, v);
end;
public z_MultiTexCoord2dvARB_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord2dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2dvARB(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord2dvARB_ovr_2(target, v);
end;
public z_MultiTexCoord2fARB_adr := GetFuncAdr('glMultiTexCoord2fARB');
public z_MultiTexCoord2fARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: single; t: single)>(z_MultiTexCoord2fARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2fARB(target: TextureUnit; s: single; t: single);
begin
z_MultiTexCoord2fARB_ovr_0(target, s, t);
end;
public z_MultiTexCoord2fvARB_adr := GetFuncAdr('glMultiTexCoord2fvARB');
public z_MultiTexCoord2fvARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: single)>(z_MultiTexCoord2fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2fvARB(target: TextureUnit; v: array of single);
begin
z_MultiTexCoord2fvARB_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2fvARB(target: TextureUnit; var v: single);
begin
z_MultiTexCoord2fvARB_ovr_0(target, v);
end;
public z_MultiTexCoord2fvARB_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord2fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2fvARB(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord2fvARB_ovr_2(target, v);
end;
public z_MultiTexCoord2iARB_adr := GetFuncAdr('glMultiTexCoord2iARB');
public z_MultiTexCoord2iARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: Int32; t: Int32)>(z_MultiTexCoord2iARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2iARB(target: TextureUnit; s: Int32; t: Int32);
begin
z_MultiTexCoord2iARB_ovr_0(target, s, t);
end;
public z_MultiTexCoord2ivARB_adr := GetFuncAdr('glMultiTexCoord2ivARB');
public z_MultiTexCoord2ivARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Int32)>(z_MultiTexCoord2ivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2ivARB(target: TextureUnit; v: array of Int32);
begin
z_MultiTexCoord2ivARB_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2ivARB(target: TextureUnit; var v: Int32);
begin
z_MultiTexCoord2ivARB_ovr_0(target, v);
end;
public z_MultiTexCoord2ivARB_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord2ivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2ivARB(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord2ivARB_ovr_2(target, v);
end;
public z_MultiTexCoord2sARB_adr := GetFuncAdr('glMultiTexCoord2sARB');
public z_MultiTexCoord2sARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: Int16; t: Int16)>(z_MultiTexCoord2sARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2sARB(target: TextureUnit; s: Int16; t: Int16);
begin
z_MultiTexCoord2sARB_ovr_0(target, s, t);
end;
public z_MultiTexCoord2svARB_adr := GetFuncAdr('glMultiTexCoord2svARB');
public z_MultiTexCoord2svARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Int16)>(z_MultiTexCoord2svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2svARB(target: TextureUnit; v: array of Int16);
begin
z_MultiTexCoord2svARB_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2svARB(target: TextureUnit; var v: Int16);
begin
z_MultiTexCoord2svARB_ovr_0(target, v);
end;
public z_MultiTexCoord2svARB_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord2svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2svARB(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord2svARB_ovr_2(target, v);
end;
public z_MultiTexCoord3dARB_adr := GetFuncAdr('glMultiTexCoord3dARB');
public z_MultiTexCoord3dARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: real; t: real; r: real)>(z_MultiTexCoord3dARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3dARB(target: TextureUnit; s: real; t: real; r: real);
begin
z_MultiTexCoord3dARB_ovr_0(target, s, t, r);
end;
public z_MultiTexCoord3dvARB_adr := GetFuncAdr('glMultiTexCoord3dvARB');
public z_MultiTexCoord3dvARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: real)>(z_MultiTexCoord3dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3dvARB(target: TextureUnit; v: array of real);
begin
z_MultiTexCoord3dvARB_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3dvARB(target: TextureUnit; var v: real);
begin
z_MultiTexCoord3dvARB_ovr_0(target, v);
end;
public z_MultiTexCoord3dvARB_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord3dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3dvARB(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord3dvARB_ovr_2(target, v);
end;
public z_MultiTexCoord3fARB_adr := GetFuncAdr('glMultiTexCoord3fARB');
public z_MultiTexCoord3fARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: single; t: single; r: single)>(z_MultiTexCoord3fARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3fARB(target: TextureUnit; s: single; t: single; r: single);
begin
z_MultiTexCoord3fARB_ovr_0(target, s, t, r);
end;
public z_MultiTexCoord3fvARB_adr := GetFuncAdr('glMultiTexCoord3fvARB');
public z_MultiTexCoord3fvARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: single)>(z_MultiTexCoord3fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3fvARB(target: TextureUnit; v: array of single);
begin
z_MultiTexCoord3fvARB_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3fvARB(target: TextureUnit; var v: single);
begin
z_MultiTexCoord3fvARB_ovr_0(target, v);
end;
public z_MultiTexCoord3fvARB_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord3fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3fvARB(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord3fvARB_ovr_2(target, v);
end;
public z_MultiTexCoord3iARB_adr := GetFuncAdr('glMultiTexCoord3iARB');
public z_MultiTexCoord3iARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: Int32; t: Int32; r: Int32)>(z_MultiTexCoord3iARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3iARB(target: TextureUnit; s: Int32; t: Int32; r: Int32);
begin
z_MultiTexCoord3iARB_ovr_0(target, s, t, r);
end;
public z_MultiTexCoord3ivARB_adr := GetFuncAdr('glMultiTexCoord3ivARB');
public z_MultiTexCoord3ivARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Int32)>(z_MultiTexCoord3ivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3ivARB(target: TextureUnit; v: array of Int32);
begin
z_MultiTexCoord3ivARB_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3ivARB(target: TextureUnit; var v: Int32);
begin
z_MultiTexCoord3ivARB_ovr_0(target, v);
end;
public z_MultiTexCoord3ivARB_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord3ivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3ivARB(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord3ivARB_ovr_2(target, v);
end;
public z_MultiTexCoord3sARB_adr := GetFuncAdr('glMultiTexCoord3sARB');
public z_MultiTexCoord3sARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: Int16; t: Int16; r: Int16)>(z_MultiTexCoord3sARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3sARB(target: TextureUnit; s: Int16; t: Int16; r: Int16);
begin
z_MultiTexCoord3sARB_ovr_0(target, s, t, r);
end;
public z_MultiTexCoord3svARB_adr := GetFuncAdr('glMultiTexCoord3svARB');
public z_MultiTexCoord3svARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Int16)>(z_MultiTexCoord3svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3svARB(target: TextureUnit; v: array of Int16);
begin
z_MultiTexCoord3svARB_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3svARB(target: TextureUnit; var v: Int16);
begin
z_MultiTexCoord3svARB_ovr_0(target, v);
end;
public z_MultiTexCoord3svARB_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord3svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3svARB(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord3svARB_ovr_2(target, v);
end;
public z_MultiTexCoord4dARB_adr := GetFuncAdr('glMultiTexCoord4dARB');
public z_MultiTexCoord4dARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: real; t: real; r: real; q: real)>(z_MultiTexCoord4dARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4dARB(target: TextureUnit; s: real; t: real; r: real; q: real);
begin
z_MultiTexCoord4dARB_ovr_0(target, s, t, r, q);
end;
public z_MultiTexCoord4dvARB_adr := GetFuncAdr('glMultiTexCoord4dvARB');
public z_MultiTexCoord4dvARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: real)>(z_MultiTexCoord4dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4dvARB(target: TextureUnit; v: array of real);
begin
z_MultiTexCoord4dvARB_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4dvARB(target: TextureUnit; var v: real);
begin
z_MultiTexCoord4dvARB_ovr_0(target, v);
end;
public z_MultiTexCoord4dvARB_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord4dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4dvARB(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord4dvARB_ovr_2(target, v);
end;
public z_MultiTexCoord4fARB_adr := GetFuncAdr('glMultiTexCoord4fARB');
public z_MultiTexCoord4fARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: single; t: single; r: single; q: single)>(z_MultiTexCoord4fARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4fARB(target: TextureUnit; s: single; t: single; r: single; q: single);
begin
z_MultiTexCoord4fARB_ovr_0(target, s, t, r, q);
end;
public z_MultiTexCoord4fvARB_adr := GetFuncAdr('glMultiTexCoord4fvARB');
public z_MultiTexCoord4fvARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: single)>(z_MultiTexCoord4fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4fvARB(target: TextureUnit; v: array of single);
begin
z_MultiTexCoord4fvARB_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4fvARB(target: TextureUnit; var v: single);
begin
z_MultiTexCoord4fvARB_ovr_0(target, v);
end;
public z_MultiTexCoord4fvARB_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord4fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4fvARB(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord4fvARB_ovr_2(target, v);
end;
public z_MultiTexCoord4iARB_adr := GetFuncAdr('glMultiTexCoord4iARB');
public z_MultiTexCoord4iARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: Int32; t: Int32; r: Int32; q: Int32)>(z_MultiTexCoord4iARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4iARB(target: TextureUnit; s: Int32; t: Int32; r: Int32; q: Int32);
begin
z_MultiTexCoord4iARB_ovr_0(target, s, t, r, q);
end;
public z_MultiTexCoord4ivARB_adr := GetFuncAdr('glMultiTexCoord4ivARB');
public z_MultiTexCoord4ivARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Int32)>(z_MultiTexCoord4ivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4ivARB(target: TextureUnit; v: array of Int32);
begin
z_MultiTexCoord4ivARB_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4ivARB(target: TextureUnit; var v: Int32);
begin
z_MultiTexCoord4ivARB_ovr_0(target, v);
end;
public z_MultiTexCoord4ivARB_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord4ivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4ivARB(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord4ivARB_ovr_2(target, v);
end;
public z_MultiTexCoord4sARB_adr := GetFuncAdr('glMultiTexCoord4sARB');
public z_MultiTexCoord4sARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: Int16; t: Int16; r: Int16; q: Int16)>(z_MultiTexCoord4sARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4sARB(target: TextureUnit; s: Int16; t: Int16; r: Int16; q: Int16);
begin
z_MultiTexCoord4sARB_ovr_0(target, s, t, r, q);
end;
public z_MultiTexCoord4svARB_adr := GetFuncAdr('glMultiTexCoord4svARB');
public z_MultiTexCoord4svARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Int16)>(z_MultiTexCoord4svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4svARB(target: TextureUnit; v: array of Int16);
begin
z_MultiTexCoord4svARB_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4svARB(target: TextureUnit; var v: Int16);
begin
z_MultiTexCoord4svARB_ovr_0(target, v);
end;
public z_MultiTexCoord4svARB_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord4svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4svARB(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord4svARB_ovr_2(target, v);
end;
end;
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);
public z_GenQueriesARB_adr := GetFuncAdr('glGenQueriesARB');
public z_GenQueriesARB_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var ids: UInt32)>(z_GenQueriesARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenQueriesARB(n: Int32; ids: array of UInt32);
begin
z_GenQueriesARB_ovr_0(n, ids[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenQueriesARB(n: Int32; var ids: UInt32);
begin
z_GenQueriesARB_ovr_0(n, ids);
end;
public z_GenQueriesARB_ovr_2 := GetFuncOrNil&<procedure(n: Int32; ids: IntPtr)>(z_GenQueriesARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenQueriesARB(n: Int32; ids: IntPtr);
begin
z_GenQueriesARB_ovr_2(n, ids);
end;
public z_DeleteQueriesARB_adr := GetFuncAdr('glDeleteQueriesARB');
public z_DeleteQueriesARB_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var ids: UInt32)>(z_DeleteQueriesARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteQueriesARB(n: Int32; ids: array of UInt32);
begin
z_DeleteQueriesARB_ovr_0(n, ids[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteQueriesARB(n: Int32; var ids: UInt32);
begin
z_DeleteQueriesARB_ovr_0(n, ids);
end;
public z_DeleteQueriesARB_ovr_2 := GetFuncOrNil&<procedure(n: Int32; ids: IntPtr)>(z_DeleteQueriesARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteQueriesARB(n: Int32; ids: IntPtr);
begin
z_DeleteQueriesARB_ovr_2(n, ids);
end;
public z_IsQueryARB_adr := GetFuncAdr('glIsQueryARB');
public z_IsQueryARB_ovr_0 := GetFuncOrNil&<function(id: UInt32): boolean>(z_IsQueryARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsQueryARB(id: UInt32): boolean;
begin
Result := z_IsQueryARB_ovr_0(id);
end;
public z_BeginQueryARB_adr := GetFuncAdr('glBeginQueryARB');
public z_BeginQueryARB_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; id: UInt32)>(z_BeginQueryARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginQueryARB(target: DummyEnum; id: UInt32);
begin
z_BeginQueryARB_ovr_0(target, id);
end;
public z_EndQueryARB_adr := GetFuncAdr('glEndQueryARB');
public z_EndQueryARB_ovr_0 := GetFuncOrNil&<procedure(target: QueryTarget)>(z_EndQueryARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndQueryARB(target: QueryTarget);
begin
z_EndQueryARB_ovr_0(target);
end;
public z_GetQueryivARB_adr := GetFuncAdr('glGetQueryivARB');
public z_GetQueryivARB_ovr_0 := GetFuncOrNil&<procedure(target: QueryTarget; pname: QueryParameterName; var ¶ms: Int32)>(z_GetQueryivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryivARB(target: QueryTarget; pname: QueryParameterName; ¶ms: array of Int32);
begin
z_GetQueryivARB_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryivARB(target: QueryTarget; pname: QueryParameterName; var ¶ms: Int32);
begin
z_GetQueryivARB_ovr_0(target, pname, ¶ms);
end;
public z_GetQueryivARB_ovr_2 := GetFuncOrNil&<procedure(target: QueryTarget; pname: QueryParameterName; ¶ms: IntPtr)>(z_GetQueryivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryivARB(target: QueryTarget; pname: QueryParameterName; ¶ms: IntPtr);
begin
z_GetQueryivARB_ovr_2(target, pname, ¶ms);
end;
public z_GetQueryObjectivARB_adr := GetFuncAdr('glGetQueryObjectivARB');
public z_GetQueryObjectivARB_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; pname: QueryObjectParameterName; var ¶ms: Int32)>(z_GetQueryObjectivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectivARB(id: UInt32; pname: QueryObjectParameterName; ¶ms: array of Int32);
begin
z_GetQueryObjectivARB_ovr_0(id, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectivARB(id: UInt32; pname: QueryObjectParameterName; var ¶ms: Int32);
begin
z_GetQueryObjectivARB_ovr_0(id, pname, ¶ms);
end;
public z_GetQueryObjectivARB_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr)>(z_GetQueryObjectivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectivARB(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr);
begin
z_GetQueryObjectivARB_ovr_2(id, pname, ¶ms);
end;
public z_GetQueryObjectuivARB_adr := GetFuncAdr('glGetQueryObjectuivARB');
public z_GetQueryObjectuivARB_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; pname: QueryObjectParameterName; var ¶ms: UInt32)>(z_GetQueryObjectuivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectuivARB(id: UInt32; pname: QueryObjectParameterName; ¶ms: array of UInt32);
begin
z_GetQueryObjectuivARB_ovr_0(id, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectuivARB(id: UInt32; pname: QueryObjectParameterName; var ¶ms: UInt32);
begin
z_GetQueryObjectuivARB_ovr_0(id, pname, ¶ms);
end;
public z_GetQueryObjectuivARB_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr)>(z_GetQueryObjectuivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectuivARB(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr);
begin
z_GetQueryObjectuivARB_ovr_2(id, pname, ¶ms);
end;
end;
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);
public z_MaxShaderCompilerThreadsARB_adr := GetFuncAdr('glMaxShaderCompilerThreadsARB');
public z_MaxShaderCompilerThreadsARB_ovr_0 := GetFuncOrNil&<procedure(count: UInt32)>(z_MaxShaderCompilerThreadsARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MaxShaderCompilerThreadsARB(count: UInt32);
begin
z_MaxShaderCompilerThreadsARB_ovr_0(count);
end;
end;
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);
public z_PointParameterfARB_adr := GetFuncAdr('glPointParameterfARB');
public z_PointParameterfARB_ovr_0 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; param: single)>(z_PointParameterfARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfARB(pname: PointParameterNameARB; param: single);
begin
z_PointParameterfARB_ovr_0(pname, param);
end;
public z_PointParameterfvARB_adr := GetFuncAdr('glPointParameterfvARB');
public z_PointParameterfvARB_ovr_0 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; var ¶ms: single)>(z_PointParameterfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfvARB(pname: PointParameterNameARB; ¶ms: array of single);
begin
z_PointParameterfvARB_ovr_0(pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfvARB(pname: PointParameterNameARB; var ¶ms: single);
begin
z_PointParameterfvARB_ovr_0(pname, ¶ms);
end;
public z_PointParameterfvARB_ovr_2 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; ¶ms: IntPtr)>(z_PointParameterfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfvARB(pname: PointParameterNameARB; ¶ms: IntPtr);
begin
z_PointParameterfvARB_ovr_2(pname, ¶ms);
end;
end;
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);
end;
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);
end;
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);
end;
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);
public z_GetGraphicsResetStatusARB_adr := GetFuncAdr('glGetGraphicsResetStatusARB');
public z_GetGraphicsResetStatusARB_ovr_0 := GetFuncOrNil&<function: GraphicsResetStatus>(z_GetGraphicsResetStatusARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetGraphicsResetStatusARB: GraphicsResetStatus;
begin
Result := z_GetGraphicsResetStatusARB_ovr_0;
end;
public z_GetnTexImageARB_adr := GetFuncAdr('glGetnTexImageARB');
public z_GetnTexImageARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; format: PixelFormat; &type: PixelType; bufSize: Int32; img: IntPtr)>(z_GetnTexImageARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnTexImageARB(target: TextureTarget; level: Int32; format: PixelFormat; &type: PixelType; bufSize: Int32; img: IntPtr);
begin
z_GetnTexImageARB_ovr_0(target, level, format, &type, bufSize, img);
end;
public z_ReadnPixelsARB_adr := GetFuncAdr('glReadnPixelsARB');
public z_ReadnPixelsARB_ovr_0 := GetFuncOrNil&<procedure(x: Int32; y: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; bufSize: Int32; data: IntPtr)>(z_ReadnPixelsARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReadnPixelsARB(x: Int32; y: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; bufSize: Int32; data: IntPtr);
begin
z_ReadnPixelsARB_ovr_0(x, y, width, height, format, &type, bufSize, data);
end;
public z_GetnCompressedTexImageARB_adr := GetFuncAdr('glGetnCompressedTexImageARB');
public z_GetnCompressedTexImageARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; lod: Int32; bufSize: Int32; img: IntPtr)>(z_GetnCompressedTexImageARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnCompressedTexImageARB(target: TextureTarget; lod: Int32; bufSize: Int32; img: IntPtr);
begin
z_GetnCompressedTexImageARB_ovr_0(target, lod, bufSize, img);
end;
public z_GetnUniformfvARB_adr := GetFuncAdr('glGetnUniformfvARB');
public z_GetnUniformfvARB_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; bufSize: Int32; var ¶ms: single)>(z_GetnUniformfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformfvARB(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: array of single);
begin
z_GetnUniformfvARB_ovr_0(&program, location, bufSize, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformfvARB(&program: UInt32; location: Int32; bufSize: Int32; var ¶ms: single);
begin
z_GetnUniformfvARB_ovr_0(&program, location, bufSize, ¶ms);
end;
public z_GetnUniformfvARB_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr)>(z_GetnUniformfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformfvARB(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr);
begin
z_GetnUniformfvARB_ovr_2(&program, location, bufSize, ¶ms);
end;
public z_GetnUniformivARB_adr := GetFuncAdr('glGetnUniformivARB');
public z_GetnUniformivARB_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; bufSize: Int32; var ¶ms: Int32)>(z_GetnUniformivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformivARB(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: array of Int32);
begin
z_GetnUniformivARB_ovr_0(&program, location, bufSize, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformivARB(&program: UInt32; location: Int32; bufSize: Int32; var ¶ms: Int32);
begin
z_GetnUniformivARB_ovr_0(&program, location, bufSize, ¶ms);
end;
public z_GetnUniformivARB_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr)>(z_GetnUniformivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformivARB(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr);
begin
z_GetnUniformivARB_ovr_2(&program, location, bufSize, ¶ms);
end;
public z_GetnUniformuivARB_adr := GetFuncAdr('glGetnUniformuivARB');
public z_GetnUniformuivARB_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; bufSize: Int32; var ¶ms: UInt32)>(z_GetnUniformuivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformuivARB(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: array of UInt32);
begin
z_GetnUniformuivARB_ovr_0(&program, location, bufSize, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformuivARB(&program: UInt32; location: Int32; bufSize: Int32; var ¶ms: UInt32);
begin
z_GetnUniformuivARB_ovr_0(&program, location, bufSize, ¶ms);
end;
public z_GetnUniformuivARB_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr)>(z_GetnUniformuivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformuivARB(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr);
begin
z_GetnUniformuivARB_ovr_2(&program, location, bufSize, ¶ms);
end;
public z_GetnUniformdvARB_adr := GetFuncAdr('glGetnUniformdvARB');
public z_GetnUniformdvARB_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; bufSize: Int32; var ¶ms: real)>(z_GetnUniformdvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformdvARB(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: array of real);
begin
z_GetnUniformdvARB_ovr_0(&program, location, bufSize, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformdvARB(&program: UInt32; location: Int32; bufSize: Int32; var ¶ms: real);
begin
z_GetnUniformdvARB_ovr_0(&program, location, bufSize, ¶ms);
end;
public z_GetnUniformdvARB_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr)>(z_GetnUniformdvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnUniformdvARB(&program: UInt32; location: Int32; bufSize: Int32; ¶ms: IntPtr);
begin
z_GetnUniformdvARB_ovr_2(&program, location, bufSize, ¶ms);
end;
public z_GetnMapdvARB_adr := GetFuncAdr('glGetnMapdvARB');
public z_GetnMapdvARB_ovr_0 := GetFuncOrNil&<procedure(target: MapTarget; query: MapQuery; bufSize: Int32; var v: real)>(z_GetnMapdvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapdvARB(target: MapTarget; query: MapQuery; bufSize: Int32; v: array of real);
begin
z_GetnMapdvARB_ovr_0(target, query, bufSize, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapdvARB(target: MapTarget; query: MapQuery; bufSize: Int32; var v: real);
begin
z_GetnMapdvARB_ovr_0(target, query, bufSize, v);
end;
public z_GetnMapdvARB_ovr_2 := GetFuncOrNil&<procedure(target: MapTarget; query: MapQuery; bufSize: Int32; v: IntPtr)>(z_GetnMapdvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapdvARB(target: MapTarget; query: MapQuery; bufSize: Int32; v: IntPtr);
begin
z_GetnMapdvARB_ovr_2(target, query, bufSize, v);
end;
public z_GetnMapfvARB_adr := GetFuncAdr('glGetnMapfvARB');
public z_GetnMapfvARB_ovr_0 := GetFuncOrNil&<procedure(target: MapTarget; query: MapQuery; bufSize: Int32; var v: single)>(z_GetnMapfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapfvARB(target: MapTarget; query: MapQuery; bufSize: Int32; v: array of single);
begin
z_GetnMapfvARB_ovr_0(target, query, bufSize, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapfvARB(target: MapTarget; query: MapQuery; bufSize: Int32; var v: single);
begin
z_GetnMapfvARB_ovr_0(target, query, bufSize, v);
end;
public z_GetnMapfvARB_ovr_2 := GetFuncOrNil&<procedure(target: MapTarget; query: MapQuery; bufSize: Int32; v: IntPtr)>(z_GetnMapfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapfvARB(target: MapTarget; query: MapQuery; bufSize: Int32; v: IntPtr);
begin
z_GetnMapfvARB_ovr_2(target, query, bufSize, v);
end;
public z_GetnMapivARB_adr := GetFuncAdr('glGetnMapivARB');
public z_GetnMapivARB_ovr_0 := GetFuncOrNil&<procedure(target: MapTarget; query: MapQuery; bufSize: Int32; var v: Int32)>(z_GetnMapivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapivARB(target: MapTarget; query: MapQuery; bufSize: Int32; v: array of Int32);
begin
z_GetnMapivARB_ovr_0(target, query, bufSize, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapivARB(target: MapTarget; query: MapQuery; bufSize: Int32; var v: Int32);
begin
z_GetnMapivARB_ovr_0(target, query, bufSize, v);
end;
public z_GetnMapivARB_ovr_2 := GetFuncOrNil&<procedure(target: MapTarget; query: MapQuery; bufSize: Int32; v: IntPtr)>(z_GetnMapivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMapivARB(target: MapTarget; query: MapQuery; bufSize: Int32; v: IntPtr);
begin
z_GetnMapivARB_ovr_2(target, query, bufSize, v);
end;
public z_GetnPixelMapfvARB_adr := GetFuncAdr('glGetnPixelMapfvARB');
public z_GetnPixelMapfvARB_ovr_0 := GetFuncOrNil&<procedure(map: PixelMap; bufSize: Int32; var values: single)>(z_GetnPixelMapfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapfvARB(map: PixelMap; bufSize: Int32; values: array of single);
begin
z_GetnPixelMapfvARB_ovr_0(map, bufSize, values[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapfvARB(map: PixelMap; bufSize: Int32; var values: single);
begin
z_GetnPixelMapfvARB_ovr_0(map, bufSize, values);
end;
public z_GetnPixelMapfvARB_ovr_2 := GetFuncOrNil&<procedure(map: PixelMap; bufSize: Int32; values: IntPtr)>(z_GetnPixelMapfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapfvARB(map: PixelMap; bufSize: Int32; values: IntPtr);
begin
z_GetnPixelMapfvARB_ovr_2(map, bufSize, values);
end;
public z_GetnPixelMapuivARB_adr := GetFuncAdr('glGetnPixelMapuivARB');
public z_GetnPixelMapuivARB_ovr_0 := GetFuncOrNil&<procedure(map: PixelMap; bufSize: Int32; var values: UInt32)>(z_GetnPixelMapuivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapuivARB(map: PixelMap; bufSize: Int32; values: array of UInt32);
begin
z_GetnPixelMapuivARB_ovr_0(map, bufSize, values[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapuivARB(map: PixelMap; bufSize: Int32; var values: UInt32);
begin
z_GetnPixelMapuivARB_ovr_0(map, bufSize, values);
end;
public z_GetnPixelMapuivARB_ovr_2 := GetFuncOrNil&<procedure(map: PixelMap; bufSize: Int32; values: IntPtr)>(z_GetnPixelMapuivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapuivARB(map: PixelMap; bufSize: Int32; values: IntPtr);
begin
z_GetnPixelMapuivARB_ovr_2(map, bufSize, values);
end;
public z_GetnPixelMapusvARB_adr := GetFuncAdr('glGetnPixelMapusvARB');
public z_GetnPixelMapusvARB_ovr_0 := GetFuncOrNil&<procedure(map: PixelMap; bufSize: Int32; var values: UInt16)>(z_GetnPixelMapusvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapusvARB(map: PixelMap; bufSize: Int32; values: array of UInt16);
begin
z_GetnPixelMapusvARB_ovr_0(map, bufSize, values[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapusvARB(map: PixelMap; bufSize: Int32; var values: UInt16);
begin
z_GetnPixelMapusvARB_ovr_0(map, bufSize, values);
end;
public z_GetnPixelMapusvARB_ovr_2 := GetFuncOrNil&<procedure(map: PixelMap; bufSize: Int32; values: IntPtr)>(z_GetnPixelMapusvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPixelMapusvARB(map: PixelMap; bufSize: Int32; values: IntPtr);
begin
z_GetnPixelMapusvARB_ovr_2(map, bufSize, values);
end;
public z_GetnPolygonStippleARB_adr := GetFuncAdr('glGetnPolygonStippleARB');
public z_GetnPolygonStippleARB_ovr_0 := GetFuncOrNil&<procedure(bufSize: Int32; var pattern: Byte)>(z_GetnPolygonStippleARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPolygonStippleARB(bufSize: Int32; pattern: array of Byte);
begin
z_GetnPolygonStippleARB_ovr_0(bufSize, pattern[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPolygonStippleARB(bufSize: Int32; var pattern: Byte);
begin
z_GetnPolygonStippleARB_ovr_0(bufSize, pattern);
end;
public z_GetnPolygonStippleARB_ovr_2 := GetFuncOrNil&<procedure(bufSize: Int32; pattern: IntPtr)>(z_GetnPolygonStippleARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnPolygonStippleARB(bufSize: Int32; pattern: IntPtr);
begin
z_GetnPolygonStippleARB_ovr_2(bufSize, pattern);
end;
public z_GetnColorTableARB_adr := GetFuncAdr('glGetnColorTableARB');
public z_GetnColorTableARB_ovr_0 := GetFuncOrNil&<procedure(target: ColorTableTarget; format: PixelFormat; &type: PixelType; bufSize: Int32; table: IntPtr)>(z_GetnColorTableARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnColorTableARB(target: ColorTableTarget; format: PixelFormat; &type: PixelType; bufSize: Int32; table: IntPtr);
begin
z_GetnColorTableARB_ovr_0(target, format, &type, bufSize, table);
end;
public z_GetnConvolutionFilterARB_adr := GetFuncAdr('glGetnConvolutionFilterARB');
public z_GetnConvolutionFilterARB_ovr_0 := GetFuncOrNil&<procedure(target: ConvolutionTarget; format: PixelFormat; &type: PixelType; bufSize: Int32; image: IntPtr)>(z_GetnConvolutionFilterARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnConvolutionFilterARB(target: ConvolutionTarget; format: PixelFormat; &type: PixelType; bufSize: Int32; image: IntPtr);
begin
z_GetnConvolutionFilterARB_ovr_0(target, format, &type, bufSize, image);
end;
public z_GetnSeparableFilterARB_adr := GetFuncAdr('glGetnSeparableFilterARB');
public z_GetnSeparableFilterARB_ovr_0 := GetFuncOrNil&<procedure(target: SeparableTargetEXT; format: PixelFormat; &type: PixelType; rowBufSize: Int32; row: IntPtr; columnBufSize: Int32; column: IntPtr; span: IntPtr)>(z_GetnSeparableFilterARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnSeparableFilterARB(target: SeparableTargetEXT; format: PixelFormat; &type: PixelType; rowBufSize: Int32; row: IntPtr; columnBufSize: Int32; column: IntPtr; span: IntPtr);
begin
z_GetnSeparableFilterARB_ovr_0(target, format, &type, rowBufSize, row, columnBufSize, column, span);
end;
public z_GetnHistogramARB_adr := GetFuncAdr('glGetnHistogramARB');
public z_GetnHistogramARB_ovr_0 := GetFuncOrNil&<procedure(target: HistogramTargetEXT; reset: boolean; format: PixelFormat; &type: PixelType; bufSize: Int32; values: IntPtr)>(z_GetnHistogramARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnHistogramARB(target: HistogramTargetEXT; reset: boolean; format: PixelFormat; &type: PixelType; bufSize: Int32; values: IntPtr);
begin
z_GetnHistogramARB_ovr_0(target, reset, format, &type, bufSize, values);
end;
public z_GetnMinmaxARB_adr := GetFuncAdr('glGetnMinmaxARB');
public z_GetnMinmaxARB_ovr_0 := GetFuncOrNil&<procedure(target: MinmaxTargetEXT; reset: boolean; format: PixelFormat; &type: PixelType; bufSize: Int32; values: IntPtr)>(z_GetnMinmaxARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetnMinmaxARB(target: MinmaxTargetEXT; reset: boolean; format: PixelFormat; &type: PixelType; bufSize: Int32; values: IntPtr);
begin
z_GetnMinmaxARB_ovr_0(target, reset, format, &type, bufSize, values);
end;
end;
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);
public z_FramebufferSampleLocationsfvARB_adr := GetFuncAdr('glFramebufferSampleLocationsfvARB');
public z_FramebufferSampleLocationsfvARB_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; start: UInt32; count: Int32; var v: single)>(z_FramebufferSampleLocationsfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferSampleLocationsfvARB(target: FramebufferTarget; start: UInt32; count: Int32; v: array of single);
begin
z_FramebufferSampleLocationsfvARB_ovr_0(target, start, count, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferSampleLocationsfvARB(target: FramebufferTarget; start: UInt32; count: Int32; var v: single);
begin
z_FramebufferSampleLocationsfvARB_ovr_0(target, start, count, v);
end;
public z_FramebufferSampleLocationsfvARB_ovr_2 := GetFuncOrNil&<procedure(target: FramebufferTarget; start: UInt32; count: Int32; v: IntPtr)>(z_FramebufferSampleLocationsfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferSampleLocationsfvARB(target: FramebufferTarget; start: UInt32; count: Int32; v: IntPtr);
begin
z_FramebufferSampleLocationsfvARB_ovr_2(target, start, count, v);
end;
public z_NamedFramebufferSampleLocationsfvARB_adr := GetFuncAdr('glNamedFramebufferSampleLocationsfvARB');
public z_NamedFramebufferSampleLocationsfvARB_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; start: UInt32; count: Int32; var v: single)>(z_NamedFramebufferSampleLocationsfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferSampleLocationsfvARB(framebuffer: UInt32; start: UInt32; count: Int32; v: array of single);
begin
z_NamedFramebufferSampleLocationsfvARB_ovr_0(framebuffer, start, count, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferSampleLocationsfvARB(framebuffer: UInt32; start: UInt32; count: Int32; var v: single);
begin
z_NamedFramebufferSampleLocationsfvARB_ovr_0(framebuffer, start, count, v);
end;
public z_NamedFramebufferSampleLocationsfvARB_ovr_2 := GetFuncOrNil&<procedure(framebuffer: UInt32; start: UInt32; count: Int32; v: IntPtr)>(z_NamedFramebufferSampleLocationsfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferSampleLocationsfvARB(framebuffer: UInt32; start: UInt32; count: Int32; v: IntPtr);
begin
z_NamedFramebufferSampleLocationsfvARB_ovr_2(framebuffer, start, count, v);
end;
public z_EvaluateDepthValuesARB_adr := GetFuncAdr('glEvaluateDepthValuesARB');
public z_EvaluateDepthValuesARB_ovr_0 := GetFuncOrNil&<procedure>(z_EvaluateDepthValuesARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvaluateDepthValuesARB;
begin
z_EvaluateDepthValuesARB_ovr_0;
end;
end;
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);
public z_MinSampleShadingARB_adr := GetFuncAdr('glMinSampleShadingARB');
public z_MinSampleShadingARB_ovr_0 := GetFuncOrNil&<procedure(value: single)>(z_MinSampleShadingARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MinSampleShadingARB(value: single);
begin
z_MinSampleShadingARB_ovr_0(value);
end;
end;
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);
end;
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);
end;
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);
end;
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);
end;
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);
public z_DeleteObjectARB_adr := GetFuncAdr('glDeleteObjectARB');
public z_DeleteObjectARB_ovr_0 := GetFuncOrNil&<procedure(obj: GLhandleARB)>(z_DeleteObjectARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteObjectARB(obj: GLhandleARB);
begin
z_DeleteObjectARB_ovr_0(obj);
end;
public z_GetHandleARB_adr := GetFuncAdr('glGetHandleARB');
public z_GetHandleARB_ovr_0 := GetFuncOrNil&<function(pname: DummyEnum): GLhandleARB>(z_GetHandleARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetHandleARB(pname: DummyEnum): GLhandleARB;
begin
Result := z_GetHandleARB_ovr_0(pname);
end;
public z_DetachObjectARB_adr := GetFuncAdr('glDetachObjectARB');
public z_DetachObjectARB_ovr_0 := GetFuncOrNil&<procedure(containerObj: GLhandleARB; attachedObj: GLhandleARB)>(z_DetachObjectARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DetachObjectARB(containerObj: GLhandleARB; attachedObj: GLhandleARB);
begin
z_DetachObjectARB_ovr_0(containerObj, attachedObj);
end;
public z_CreateShaderObjectARB_adr := GetFuncAdr('glCreateShaderObjectARB');
public z_CreateShaderObjectARB_ovr_0 := GetFuncOrNil&<function(_shaderType: ShaderType): GLhandleARB>(z_CreateShaderObjectARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateShaderObjectARB(_shaderType: ShaderType): GLhandleARB;
begin
Result := z_CreateShaderObjectARB_ovr_0(_shaderType);
end;
public z_ShaderSourceARB_adr := GetFuncAdr('glShaderSourceARB');
public z_ShaderSourceARB_ovr_0 := GetFuncOrNil&<procedure(shaderObj: GLhandleARB; count: Int32; var _string: IntPtr; var length: Int32)>(z_ShaderSourceARB_adr);
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));
z_ShaderSourceARB_ovr_0(shaderObj, count, par_3_str_ptr[0], length[0]);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
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));
z_ShaderSourceARB_ovr_0(shaderObj, count, par_3_str_ptr[0], length);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
public z_ShaderSourceARB_ovr_2 := GetFuncOrNil&<procedure(shaderObj: GLhandleARB; count: Int32; var _string: IntPtr; length: IntPtr)>(z_ShaderSourceARB_adr);
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));
z_ShaderSourceARB_ovr_2(shaderObj, count, par_3_str_ptr[0], length);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSourceARB(shaderObj: GLhandleARB; count: Int32; _string: array of IntPtr; length: array of Int32);
begin
z_ShaderSourceARB_ovr_0(shaderObj, count, _string[0], length[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSourceARB(shaderObj: GLhandleARB; count: Int32; _string: array of IntPtr; var length: Int32);
begin
z_ShaderSourceARB_ovr_0(shaderObj, count, _string[0], length);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSourceARB(shaderObj: GLhandleARB; count: Int32; _string: array of IntPtr; length: IntPtr);
begin
z_ShaderSourceARB_ovr_2(shaderObj, count, _string[0], length);
end;
public z_ShaderSourceARB_ovr_6 := GetFuncOrNil&<procedure(shaderObj: GLhandleARB; count: Int32; _string: IntPtr; var length: Int32)>(z_ShaderSourceARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSourceARB(shaderObj: GLhandleARB; count: Int32; _string: IntPtr; length: array of Int32);
begin
z_ShaderSourceARB_ovr_6(shaderObj, count, _string, length[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSourceARB(shaderObj: GLhandleARB; count: Int32; _string: IntPtr; var length: Int32);
begin
z_ShaderSourceARB_ovr_6(shaderObj, count, _string, length);
end;
public z_ShaderSourceARB_ovr_8 := GetFuncOrNil&<procedure(shaderObj: GLhandleARB; count: Int32; _string: IntPtr; length: IntPtr)>(z_ShaderSourceARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderSourceARB(shaderObj: GLhandleARB; count: Int32; _string: IntPtr; length: IntPtr);
begin
z_ShaderSourceARB_ovr_8(shaderObj, count, _string, length);
end;
public z_CompileShaderARB_adr := GetFuncAdr('glCompileShaderARB');
public z_CompileShaderARB_ovr_0 := GetFuncOrNil&<procedure(shaderObj: GLhandleARB)>(z_CompileShaderARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompileShaderARB(shaderObj: GLhandleARB);
begin
z_CompileShaderARB_ovr_0(shaderObj);
end;
public z_CreateProgramObjectARB_adr := GetFuncAdr('glCreateProgramObjectARB');
public z_CreateProgramObjectARB_ovr_0 := GetFuncOrNil&<function: GLhandleARB>(z_CreateProgramObjectARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateProgramObjectARB: GLhandleARB;
begin
Result := z_CreateProgramObjectARB_ovr_0;
end;
public z_AttachObjectARB_adr := GetFuncAdr('glAttachObjectARB');
public z_AttachObjectARB_ovr_0 := GetFuncOrNil&<procedure(containerObj: GLhandleARB; obj: GLhandleARB)>(z_AttachObjectARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure AttachObjectARB(containerObj: GLhandleARB; obj: GLhandleARB);
begin
z_AttachObjectARB_ovr_0(containerObj, obj);
end;
public z_LinkProgramARB_adr := GetFuncAdr('glLinkProgramARB');
public z_LinkProgramARB_ovr_0 := GetFuncOrNil&<procedure(programObj: GLhandleARB)>(z_LinkProgramARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LinkProgramARB(programObj: GLhandleARB);
begin
z_LinkProgramARB_ovr_0(programObj);
end;
public z_UseProgramObjectARB_adr := GetFuncAdr('glUseProgramObjectARB');
public z_UseProgramObjectARB_ovr_0 := GetFuncOrNil&<procedure(programObj: GLhandleARB)>(z_UseProgramObjectARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UseProgramObjectARB(programObj: GLhandleARB);
begin
z_UseProgramObjectARB_ovr_0(programObj);
end;
public z_ValidateProgramARB_adr := GetFuncAdr('glValidateProgramARB');
public z_ValidateProgramARB_ovr_0 := GetFuncOrNil&<procedure(programObj: GLhandleARB)>(z_ValidateProgramARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ValidateProgramARB(programObj: GLhandleARB);
begin
z_ValidateProgramARB_ovr_0(programObj);
end;
public z_Uniform1fARB_adr := GetFuncAdr('glUniform1fARB');
public z_Uniform1fARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; v0: single)>(z_Uniform1fARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1fARB(location: Int32; v0: single);
begin
z_Uniform1fARB_ovr_0(location, v0);
end;
public z_Uniform2fARB_adr := GetFuncAdr('glUniform2fARB');
public z_Uniform2fARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; v0: single; v1: single)>(z_Uniform2fARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2fARB(location: Int32; v0: single; v1: single);
begin
z_Uniform2fARB_ovr_0(location, v0, v1);
end;
public z_Uniform3fARB_adr := GetFuncAdr('glUniform3fARB');
public z_Uniform3fARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; v0: single; v1: single; v2: single)>(z_Uniform3fARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3fARB(location: Int32; v0: single; v1: single; v2: single);
begin
z_Uniform3fARB_ovr_0(location, v0, v1, v2);
end;
public z_Uniform4fARB_adr := GetFuncAdr('glUniform4fARB');
public z_Uniform4fARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; v0: single; v1: single; v2: single; v3: single)>(z_Uniform4fARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4fARB(location: Int32; v0: single; v1: single; v2: single; v3: single);
begin
z_Uniform4fARB_ovr_0(location, v0, v1, v2, v3);
end;
public z_Uniform1iARB_adr := GetFuncAdr('glUniform1iARB');
public z_Uniform1iARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; v0: Int32)>(z_Uniform1iARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1iARB(location: Int32; v0: Int32);
begin
z_Uniform1iARB_ovr_0(location, v0);
end;
public z_Uniform2iARB_adr := GetFuncAdr('glUniform2iARB');
public z_Uniform2iARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; v0: Int32; v1: Int32)>(z_Uniform2iARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2iARB(location: Int32; v0: Int32; v1: Int32);
begin
z_Uniform2iARB_ovr_0(location, v0, v1);
end;
public z_Uniform3iARB_adr := GetFuncAdr('glUniform3iARB');
public z_Uniform3iARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; v0: Int32; v1: Int32; v2: Int32)>(z_Uniform3iARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3iARB(location: Int32; v0: Int32; v1: Int32; v2: Int32);
begin
z_Uniform3iARB_ovr_0(location, v0, v1, v2);
end;
public z_Uniform4iARB_adr := GetFuncAdr('glUniform4iARB');
public z_Uniform4iARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; v0: Int32; v1: Int32; v2: Int32; v3: Int32)>(z_Uniform4iARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4iARB(location: Int32; v0: Int32; v1: Int32; v2: Int32; v3: Int32);
begin
z_Uniform4iARB_ovr_0(location, v0, v1, v2, v3);
end;
public z_Uniform1fvARB_adr := GetFuncAdr('glUniform1fvARB');
public z_Uniform1fvARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: single)>(z_Uniform1fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1fvARB(location: Int32; count: Int32; value: array of single);
begin
z_Uniform1fvARB_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1fvARB(location: Int32; count: Int32; var value: single);
begin
z_Uniform1fvARB_ovr_0(location, count, value);
end;
public z_Uniform1fvARB_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform1fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1fvARB(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform1fvARB_ovr_2(location, count, value);
end;
public z_Uniform2fvARB_adr := GetFuncAdr('glUniform2fvARB');
public z_Uniform2fvARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: single)>(z_Uniform2fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2fvARB(location: Int32; count: Int32; value: array of single);
begin
z_Uniform2fvARB_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2fvARB(location: Int32; count: Int32; var value: single);
begin
z_Uniform2fvARB_ovr_0(location, count, value);
end;
public z_Uniform2fvARB_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform2fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2fvARB(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform2fvARB_ovr_2(location, count, value);
end;
public z_Uniform3fvARB_adr := GetFuncAdr('glUniform3fvARB');
public z_Uniform3fvARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: single)>(z_Uniform3fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3fvARB(location: Int32; count: Int32; value: array of single);
begin
z_Uniform3fvARB_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3fvARB(location: Int32; count: Int32; var value: single);
begin
z_Uniform3fvARB_ovr_0(location, count, value);
end;
public z_Uniform3fvARB_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform3fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3fvARB(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform3fvARB_ovr_2(location, count, value);
end;
public z_Uniform4fvARB_adr := GetFuncAdr('glUniform4fvARB');
public z_Uniform4fvARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: single)>(z_Uniform4fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4fvARB(location: Int32; count: Int32; value: array of single);
begin
z_Uniform4fvARB_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4fvARB(location: Int32; count: Int32; var value: single);
begin
z_Uniform4fvARB_ovr_0(location, count, value);
end;
public z_Uniform4fvARB_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform4fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4fvARB(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform4fvARB_ovr_2(location, count, value);
end;
public z_Uniform1ivARB_adr := GetFuncAdr('glUniform1ivARB');
public z_Uniform1ivARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Int32)>(z_Uniform1ivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ivARB(location: Int32; count: Int32; value: array of Int32);
begin
z_Uniform1ivARB_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ivARB(location: Int32; count: Int32; var value: Int32);
begin
z_Uniform1ivARB_ovr_0(location, count, value);
end;
public z_Uniform1ivARB_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform1ivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ivARB(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform1ivARB_ovr_2(location, count, value);
end;
public z_Uniform2ivARB_adr := GetFuncAdr('glUniform2ivARB');
public z_Uniform2ivARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Int32)>(z_Uniform2ivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2ivARB(location: Int32; count: Int32; value: array of Int32);
begin
z_Uniform2ivARB_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2ivARB(location: Int32; count: Int32; var value: Int32);
begin
z_Uniform2ivARB_ovr_0(location, count, value);
end;
public z_Uniform2ivARB_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform2ivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2ivARB(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform2ivARB_ovr_2(location, count, value);
end;
public z_Uniform3ivARB_adr := GetFuncAdr('glUniform3ivARB');
public z_Uniform3ivARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Int32)>(z_Uniform3ivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3ivARB(location: Int32; count: Int32; value: array of Int32);
begin
z_Uniform3ivARB_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3ivARB(location: Int32; count: Int32; var value: Int32);
begin
z_Uniform3ivARB_ovr_0(location, count, value);
end;
public z_Uniform3ivARB_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform3ivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3ivARB(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform3ivARB_ovr_2(location, count, value);
end;
public z_Uniform4ivARB_adr := GetFuncAdr('glUniform4ivARB');
public z_Uniform4ivARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Int32)>(z_Uniform4ivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4ivARB(location: Int32; count: Int32; value: array of Int32);
begin
z_Uniform4ivARB_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4ivARB(location: Int32; count: Int32; var value: Int32);
begin
z_Uniform4ivARB_ovr_0(location, count, value);
end;
public z_Uniform4ivARB_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform4ivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4ivARB(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform4ivARB_ovr_2(location, count, value);
end;
public z_UniformMatrix2fvARB_adr := GetFuncAdr('glUniformMatrix2fvARB');
public z_UniformMatrix2fvARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: single)>(z_UniformMatrix2fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2fvARB(location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_UniformMatrix2fvARB_ovr_0(location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2fvARB(location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_UniformMatrix2fvARB_ovr_0(location, count, transpose, value);
end;
public z_UniformMatrix2fvARB_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix2fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix2fvARB(location: Int32; count: Int32; transpose: boolean; value: IntPtr);
begin
z_UniformMatrix2fvARB_ovr_2(location, count, transpose, value);
end;
public z_UniformMatrix3fvARB_adr := GetFuncAdr('glUniformMatrix3fvARB');
public z_UniformMatrix3fvARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: single)>(z_UniformMatrix3fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3fvARB(location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_UniformMatrix3fvARB_ovr_0(location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3fvARB(location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_UniformMatrix3fvARB_ovr_0(location, count, transpose, value);
end;
public z_UniformMatrix3fvARB_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix3fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix3fvARB(location: Int32; count: Int32; transpose: boolean; value: IntPtr);
begin
z_UniformMatrix3fvARB_ovr_2(location, count, transpose, value);
end;
public z_UniformMatrix4fvARB_adr := GetFuncAdr('glUniformMatrix4fvARB');
public z_UniformMatrix4fvARB_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: single)>(z_UniformMatrix4fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4fvARB(location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_UniformMatrix4fvARB_ovr_0(location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4fvARB(location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_UniformMatrix4fvARB_ovr_0(location, count, transpose, value);
end;
public z_UniformMatrix4fvARB_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_UniformMatrix4fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformMatrix4fvARB(location: Int32; count: Int32; transpose: boolean; value: IntPtr);
begin
z_UniformMatrix4fvARB_ovr_2(location, count, transpose, value);
end;
public z_GetObjectParameterfvARB_adr := GetFuncAdr('glGetObjectParameterfvARB');
public z_GetObjectParameterfvARB_ovr_0 := GetFuncOrNil&<procedure(obj: GLhandleARB; pname: DummyEnum; var ¶ms: single)>(z_GetObjectParameterfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectParameterfvARB(obj: GLhandleARB; pname: DummyEnum; ¶ms: array of single);
begin
z_GetObjectParameterfvARB_ovr_0(obj, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectParameterfvARB(obj: GLhandleARB; pname: DummyEnum; var ¶ms: single);
begin
z_GetObjectParameterfvARB_ovr_0(obj, pname, ¶ms);
end;
public z_GetObjectParameterfvARB_ovr_2 := GetFuncOrNil&<procedure(obj: GLhandleARB; pname: DummyEnum; ¶ms: IntPtr)>(z_GetObjectParameterfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectParameterfvARB(obj: GLhandleARB; pname: DummyEnum; ¶ms: IntPtr);
begin
z_GetObjectParameterfvARB_ovr_2(obj, pname, ¶ms);
end;
public z_GetObjectParameterivARB_adr := GetFuncAdr('glGetObjectParameterivARB');
public z_GetObjectParameterivARB_ovr_0 := GetFuncOrNil&<procedure(obj: GLhandleARB; pname: DummyEnum; var ¶ms: Int32)>(z_GetObjectParameterivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectParameterivARB(obj: GLhandleARB; pname: DummyEnum; ¶ms: array of Int32);
begin
z_GetObjectParameterivARB_ovr_0(obj, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectParameterivARB(obj: GLhandleARB; pname: DummyEnum; var ¶ms: Int32);
begin
z_GetObjectParameterivARB_ovr_0(obj, pname, ¶ms);
end;
public z_GetObjectParameterivARB_ovr_2 := GetFuncOrNil&<procedure(obj: GLhandleARB; pname: DummyEnum; ¶ms: IntPtr)>(z_GetObjectParameterivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectParameterivARB(obj: GLhandleARB; pname: DummyEnum; ¶ms: IntPtr);
begin
z_GetObjectParameterivARB_ovr_2(obj, pname, ¶ms);
end;
public z_GetInfoLogARB_adr := GetFuncAdr('glGetInfoLogARB');
public z_GetInfoLogARB_ovr_0 := GetFuncOrNil&<procedure(obj: GLhandleARB; maxLength: Int32; var length: Int32; infoLog: IntPtr)>(z_GetInfoLogARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInfoLogARB(obj: GLhandleARB; maxLength: Int32; length: array of Int32; infoLog: IntPtr);
begin
z_GetInfoLogARB_ovr_0(obj, maxLength, length[0], infoLog);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInfoLogARB(obj: GLhandleARB; maxLength: Int32; var length: Int32; infoLog: IntPtr);
begin
z_GetInfoLogARB_ovr_0(obj, maxLength, length, infoLog);
end;
public z_GetInfoLogARB_ovr_2 := GetFuncOrNil&<procedure(obj: GLhandleARB; maxLength: Int32; length: IntPtr; infoLog: IntPtr)>(z_GetInfoLogARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInfoLogARB(obj: GLhandleARB; maxLength: Int32; length: IntPtr; infoLog: IntPtr);
begin
z_GetInfoLogARB_ovr_2(obj, maxLength, length, infoLog);
end;
public z_GetAttachedObjectsARB_adr := GetFuncAdr('glGetAttachedObjectsARB');
public z_GetAttachedObjectsARB_ovr_0 := GetFuncOrNil&<procedure(containerObj: GLhandleARB; maxCount: Int32; var count: Int32; var obj: GLhandleARB)>(z_GetAttachedObjectsARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedObjectsARB(containerObj: GLhandleARB; maxCount: Int32; count: array of Int32; obj: array of GLhandleARB);
begin
z_GetAttachedObjectsARB_ovr_0(containerObj, maxCount, count[0], obj[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedObjectsARB(containerObj: GLhandleARB; maxCount: Int32; count: array of Int32; var obj: GLhandleARB);
begin
z_GetAttachedObjectsARB_ovr_0(containerObj, maxCount, count[0], obj);
end;
public z_GetAttachedObjectsARB_ovr_2 := GetFuncOrNil&<procedure(containerObj: GLhandleARB; maxCount: Int32; var count: Int32; obj: IntPtr)>(z_GetAttachedObjectsARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedObjectsARB(containerObj: GLhandleARB; maxCount: Int32; count: array of Int32; obj: IntPtr);
begin
z_GetAttachedObjectsARB_ovr_2(containerObj, maxCount, count[0], obj);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedObjectsARB(containerObj: GLhandleARB; maxCount: Int32; var count: Int32; obj: array of GLhandleARB);
begin
z_GetAttachedObjectsARB_ovr_0(containerObj, maxCount, count, obj[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedObjectsARB(containerObj: GLhandleARB; maxCount: Int32; var count: Int32; var obj: GLhandleARB);
begin
z_GetAttachedObjectsARB_ovr_0(containerObj, maxCount, count, obj);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedObjectsARB(containerObj: GLhandleARB; maxCount: Int32; var count: Int32; obj: IntPtr);
begin
z_GetAttachedObjectsARB_ovr_2(containerObj, maxCount, count, obj);
end;
public z_GetAttachedObjectsARB_ovr_6 := GetFuncOrNil&<procedure(containerObj: GLhandleARB; maxCount: Int32; count: IntPtr; var obj: GLhandleARB)>(z_GetAttachedObjectsARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedObjectsARB(containerObj: GLhandleARB; maxCount: Int32; count: IntPtr; obj: array of GLhandleARB);
begin
z_GetAttachedObjectsARB_ovr_6(containerObj, maxCount, count, obj[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedObjectsARB(containerObj: GLhandleARB; maxCount: Int32; count: IntPtr; var obj: GLhandleARB);
begin
z_GetAttachedObjectsARB_ovr_6(containerObj, maxCount, count, obj);
end;
public z_GetAttachedObjectsARB_ovr_8 := GetFuncOrNil&<procedure(containerObj: GLhandleARB; maxCount: Int32; count: IntPtr; obj: IntPtr)>(z_GetAttachedObjectsARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetAttachedObjectsARB(containerObj: GLhandleARB; maxCount: Int32; count: IntPtr; obj: IntPtr);
begin
z_GetAttachedObjectsARB_ovr_8(containerObj, maxCount, count, obj);
end;
public z_GetUniformLocationARB_adr := GetFuncAdr('glGetUniformLocationARB');
public z_GetUniformLocationARB_ovr_0 := GetFuncOrNil&<function(programObj: GLhandleARB; name: IntPtr): Int32>(z_GetUniformLocationARB_adr);
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;
begin
Result := z_GetUniformLocationARB_ovr_0(programObj, name);
end;
public z_GetActiveUniformARB_adr := GetFuncAdr('glGetActiveUniformARB');
public z_GetActiveUniformARB_ovr_0 := GetFuncOrNil&<procedure(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; var size: Int32; var &type: UniformType; name: IntPtr)>(z_GetActiveUniformARB_adr);
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);
begin
z_GetActiveUniformARB_ovr_0(programObj, index, maxLength, length[0], size[0], &type[0], name);
end;
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);
begin
z_GetActiveUniformARB_ovr_0(programObj, index, maxLength, length[0], size[0], &type, name);
end;
public z_GetActiveUniformARB_ovr_2 := GetFuncOrNil&<procedure(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetActiveUniformARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; size: array of Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveUniformARB_ovr_2(programObj, index, maxLength, length[0], size[0], &type, name);
end;
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);
begin
z_GetActiveUniformARB_ovr_0(programObj, index, maxLength, length[0], size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; var size: Int32; var &type: UniformType; name: IntPtr);
begin
z_GetActiveUniformARB_ovr_0(programObj, index, maxLength, length[0], size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; var size: Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveUniformARB_ovr_2(programObj, index, maxLength, length[0], size, &type, name);
end;
public z_GetActiveUniformARB_ovr_6 := GetFuncOrNil&<procedure(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; var &type: UniformType; name: IntPtr)>(z_GetActiveUniformARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; size: IntPtr; &type: array of UniformType; name: IntPtr);
begin
z_GetActiveUniformARB_ovr_6(programObj, index, maxLength, length[0], size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; size: IntPtr; var &type: UniformType; name: IntPtr);
begin
z_GetActiveUniformARB_ovr_6(programObj, index, maxLength, length[0], size, &type, name);
end;
public z_GetActiveUniformARB_ovr_8 := GetFuncOrNil&<procedure(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveUniformARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; size: IntPtr; &type: IntPtr; name: IntPtr);
begin
z_GetActiveUniformARB_ovr_8(programObj, index, maxLength, length[0], size, &type, name);
end;
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);
begin
z_GetActiveUniformARB_ovr_0(programObj, index, maxLength, length, size[0], &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: array of Int32; var &type: UniformType; name: IntPtr);
begin
z_GetActiveUniformARB_ovr_0(programObj, index, maxLength, length, size[0], &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: array of Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveUniformARB_ovr_2(programObj, index, maxLength, length, size[0], &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; var size: Int32; &type: array of UniformType; name: IntPtr);
begin
z_GetActiveUniformARB_ovr_0(programObj, index, maxLength, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; var size: Int32; var &type: UniformType; name: IntPtr);
begin
z_GetActiveUniformARB_ovr_0(programObj, index, maxLength, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveUniformARB_ovr_2(programObj, index, maxLength, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; &type: array of UniformType; name: IntPtr);
begin
z_GetActiveUniformARB_ovr_6(programObj, index, maxLength, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; var &type: UniformType; name: IntPtr);
begin
z_GetActiveUniformARB_ovr_6(programObj, index, maxLength, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr);
begin
z_GetActiveUniformARB_ovr_8(programObj, index, maxLength, length, size, &type, name);
end;
public z_GetActiveUniformARB_ovr_18 := GetFuncOrNil&<procedure(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; var &type: UniformType; name: IntPtr)>(z_GetActiveUniformARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: array of Int32; &type: array of UniformType; name: IntPtr);
begin
z_GetActiveUniformARB_ovr_18(programObj, index, maxLength, length, size[0], &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: array of Int32; var &type: UniformType; name: IntPtr);
begin
z_GetActiveUniformARB_ovr_18(programObj, index, maxLength, length, size[0], &type, name);
end;
public z_GetActiveUniformARB_ovr_20 := GetFuncOrNil&<procedure(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetActiveUniformARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: array of Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveUniformARB_ovr_20(programObj, index, maxLength, length, size[0], &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; &type: array of UniformType; name: IntPtr);
begin
z_GetActiveUniformARB_ovr_18(programObj, index, maxLength, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; var &type: UniformType; name: IntPtr);
begin
z_GetActiveUniformARB_ovr_18(programObj, index, maxLength, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveUniformARB_ovr_20(programObj, index, maxLength, length, size, &type, name);
end;
public z_GetActiveUniformARB_ovr_24 := GetFuncOrNil&<procedure(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; var &type: UniformType; name: IntPtr)>(z_GetActiveUniformARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; &type: array of UniformType; name: IntPtr);
begin
z_GetActiveUniformARB_ovr_24(programObj, index, maxLength, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; var &type: UniformType; name: IntPtr);
begin
z_GetActiveUniformARB_ovr_24(programObj, index, maxLength, length, size, &type, name);
end;
public z_GetActiveUniformARB_ovr_26 := GetFuncOrNil&<procedure(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveUniformARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveUniformARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
begin
z_GetActiveUniformARB_ovr_26(programObj, index, maxLength, length, size, &type, name);
end;
public z_GetUniformfvARB_adr := GetFuncAdr('glGetUniformfvARB');
public z_GetUniformfvARB_ovr_0 := GetFuncOrNil&<procedure(programObj: GLhandleARB; location: Int32; var ¶ms: single)>(z_GetUniformfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformfvARB(programObj: GLhandleARB; location: Int32; ¶ms: array of single);
begin
z_GetUniformfvARB_ovr_0(programObj, location, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformfvARB(programObj: GLhandleARB; location: Int32; var ¶ms: single);
begin
z_GetUniformfvARB_ovr_0(programObj, location, ¶ms);
end;
public z_GetUniformfvARB_ovr_2 := GetFuncOrNil&<procedure(programObj: GLhandleARB; location: Int32; ¶ms: IntPtr)>(z_GetUniformfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformfvARB(programObj: GLhandleARB; location: Int32; ¶ms: IntPtr);
begin
z_GetUniformfvARB_ovr_2(programObj, location, ¶ms);
end;
public z_GetUniformivARB_adr := GetFuncAdr('glGetUniformivARB');
public z_GetUniformivARB_ovr_0 := GetFuncOrNil&<procedure(programObj: GLhandleARB; location: Int32; var ¶ms: Int32)>(z_GetUniformivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformivARB(programObj: GLhandleARB; location: Int32; ¶ms: array of Int32);
begin
z_GetUniformivARB_ovr_0(programObj, location, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformivARB(programObj: GLhandleARB; location: Int32; var ¶ms: Int32);
begin
z_GetUniformivARB_ovr_0(programObj, location, ¶ms);
end;
public z_GetUniformivARB_ovr_2 := GetFuncOrNil&<procedure(programObj: GLhandleARB; location: Int32; ¶ms: IntPtr)>(z_GetUniformivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformivARB(programObj: GLhandleARB; location: Int32; ¶ms: IntPtr);
begin
z_GetUniformivARB_ovr_2(programObj, location, ¶ms);
end;
public z_GetShaderSourceARB_adr := GetFuncAdr('glGetShaderSourceARB');
public z_GetShaderSourceARB_ovr_0 := GetFuncOrNil&<procedure(obj: GLhandleARB; maxLength: Int32; var length: Int32; source: IntPtr)>(z_GetShaderSourceARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderSourceARB(obj: GLhandleARB; maxLength: Int32; length: array of Int32; source: IntPtr);
begin
z_GetShaderSourceARB_ovr_0(obj, maxLength, length[0], source);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderSourceARB(obj: GLhandleARB; maxLength: Int32; var length: Int32; source: IntPtr);
begin
z_GetShaderSourceARB_ovr_0(obj, maxLength, length, source);
end;
public z_GetShaderSourceARB_ovr_2 := GetFuncOrNil&<procedure(obj: GLhandleARB; maxLength: Int32; length: IntPtr; source: IntPtr)>(z_GetShaderSourceARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShaderSourceARB(obj: GLhandleARB; maxLength: Int32; length: IntPtr; source: IntPtr);
begin
z_GetShaderSourceARB_ovr_2(obj, maxLength, length, source);
end;
end;
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);
end;
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);
end;
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);
public z_NamedStringARB_adr := GetFuncAdr('glNamedStringARB');
public z_NamedStringARB_ovr_0 := GetFuncOrNil&<procedure(&type: DummyEnum; namelen: Int32; name: IntPtr; stringlen: Int32; _string: IntPtr)>(z_NamedStringARB_adr);
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);
begin
z_NamedStringARB_ovr_0(&type, namelen, name, stringlen, _string);
end;
public z_DeleteNamedStringARB_adr := GetFuncAdr('glDeleteNamedStringARB');
public z_DeleteNamedStringARB_ovr_0 := GetFuncOrNil&<procedure(namelen: Int32; name: IntPtr)>(z_DeleteNamedStringARB_adr);
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);
begin
z_DeleteNamedStringARB_ovr_0(namelen, name);
end;
public z_CompileShaderIncludeARB_adr := GetFuncAdr('glCompileShaderIncludeARB');
public z_CompileShaderIncludeARB_ovr_0 := GetFuncOrNil&<procedure(shader: UInt32; count: Int32; var path: IntPtr; var length: Int32)>(z_CompileShaderIncludeARB_adr);
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));
z_CompileShaderIncludeARB_ovr_0(shader, count, par_3_str_ptr[0], length[0]);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
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));
z_CompileShaderIncludeARB_ovr_0(shader, count, par_3_str_ptr[0], length);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
public z_CompileShaderIncludeARB_ovr_2 := GetFuncOrNil&<procedure(shader: UInt32; count: Int32; var path: IntPtr; length: IntPtr)>(z_CompileShaderIncludeARB_adr);
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));
z_CompileShaderIncludeARB_ovr_2(shader, count, par_3_str_ptr[0], length);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompileShaderIncludeARB(shader: UInt32; count: Int32; path: array of IntPtr; length: array of Int32);
begin
z_CompileShaderIncludeARB_ovr_0(shader, count, path[0], length[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompileShaderIncludeARB(shader: UInt32; count: Int32; path: array of IntPtr; var length: Int32);
begin
z_CompileShaderIncludeARB_ovr_0(shader, count, path[0], length);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompileShaderIncludeARB(shader: UInt32; count: Int32; path: array of IntPtr; length: IntPtr);
begin
z_CompileShaderIncludeARB_ovr_2(shader, count, path[0], length);
end;
public z_CompileShaderIncludeARB_ovr_6 := GetFuncOrNil&<procedure(shader: UInt32; count: Int32; path: IntPtr; var length: Int32)>(z_CompileShaderIncludeARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompileShaderIncludeARB(shader: UInt32; count: Int32; path: IntPtr; length: array of Int32);
begin
z_CompileShaderIncludeARB_ovr_6(shader, count, path, length[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompileShaderIncludeARB(shader: UInt32; count: Int32; path: IntPtr; var length: Int32);
begin
z_CompileShaderIncludeARB_ovr_6(shader, count, path, length);
end;
public z_CompileShaderIncludeARB_ovr_8 := GetFuncOrNil&<procedure(shader: UInt32; count: Int32; path: IntPtr; length: IntPtr)>(z_CompileShaderIncludeARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompileShaderIncludeARB(shader: UInt32; count: Int32; path: IntPtr; length: IntPtr);
begin
z_CompileShaderIncludeARB_ovr_8(shader, count, path, length);
end;
public z_IsNamedStringARB_adr := GetFuncAdr('glIsNamedStringARB');
public z_IsNamedStringARB_ovr_0 := GetFuncOrNil&<function(namelen: Int32; name: IntPtr): boolean>(z_IsNamedStringARB_adr);
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;
begin
Result := z_IsNamedStringARB_ovr_0(namelen, name);
end;
public z_GetNamedStringARB_adr := GetFuncAdr('glGetNamedStringARB');
public z_GetNamedStringARB_ovr_0 := GetFuncOrNil&<procedure(namelen: Int32; name: IntPtr; bufSize: Int32; var stringlen: Int32; string: IntPtr)>(z_GetNamedStringARB_adr);
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);
z_GetNamedStringARB_ovr_0(namelen, par_2_str_ptr, bufSize, stringlen[0], 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;
public z_GetNamedStringARB_ovr_2 := GetFuncOrNil&<procedure(namelen: Int32; name: IntPtr; bufSize: Int32; stringlen: IntPtr; string: IntPtr)>(z_GetNamedStringARB_adr);
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);
begin
z_GetNamedStringARB_ovr_0(namelen, name, bufSize, stringlen[0], string);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedStringARB(namelen: Int32; name: IntPtr; bufSize: Int32; var stringlen: Int32; string: IntPtr);
begin
z_GetNamedStringARB_ovr_0(namelen, name, bufSize, stringlen, string);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedStringARB(namelen: Int32; name: IntPtr; bufSize: Int32; stringlen: IntPtr; string: IntPtr);
begin
z_GetNamedStringARB_ovr_2(namelen, name, bufSize, stringlen, string);
end;
public z_GetNamedStringivARB_adr := GetFuncAdr('glGetNamedStringivARB');
public z_GetNamedStringivARB_ovr_0 := GetFuncOrNil&<procedure(namelen: Int32; name: IntPtr; pname: DummyEnum; var ¶ms: Int32)>(z_GetNamedStringivARB_adr);
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);
z_GetNamedStringivARB_ovr_0(namelen, par_2_str_ptr, pname, ¶ms[0]);
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;
public z_GetNamedStringivARB_ovr_2 := GetFuncOrNil&<procedure(namelen: Int32; name: IntPtr; pname: DummyEnum; ¶ms: IntPtr)>(z_GetNamedStringivARB_adr);
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);
begin
z_GetNamedStringivARB_ovr_0(namelen, name, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedStringivARB(namelen: Int32; name: IntPtr; pname: DummyEnum; var ¶ms: Int32);
begin
z_GetNamedStringivARB_ovr_0(namelen, name, pname, ¶ms);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedStringivARB(namelen: Int32; name: IntPtr; pname: DummyEnum; ¶ms: IntPtr);
begin
z_GetNamedStringivARB_ovr_2(namelen, name, pname, ¶ms);
end;
end;
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);
public z_BufferPageCommitmentARB_adr := GetFuncAdr('glBufferPageCommitmentARB');
public z_BufferPageCommitmentARB_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; offset: IntPtr; size: IntPtr; commit: boolean)>(z_BufferPageCommitmentARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferPageCommitmentARB(target: DummyEnum; offset: IntPtr; size: IntPtr; commit: boolean);
begin
z_BufferPageCommitmentARB_ovr_0(target, offset, size, commit);
end;
public z_NamedBufferPageCommitmentARB_adr := GetFuncAdr('glNamedBufferPageCommitmentARB');
public z_NamedBufferPageCommitmentARB_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; offset: IntPtr; size: IntPtr; commit: boolean)>(z_NamedBufferPageCommitmentARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferPageCommitmentARB(buffer: UInt32; offset: IntPtr; size: IntPtr; commit: boolean);
begin
z_NamedBufferPageCommitmentARB_ovr_0(buffer, offset, size, commit);
end;
end;
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);
public z_TexPageCommitmentARB_adr := GetFuncAdr('glTexPageCommitmentARB');
public z_TexPageCommitmentARB_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; commit: boolean)>(z_TexPageCommitmentARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexPageCommitmentARB(target: DummyEnum; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; commit: boolean);
begin
z_TexPageCommitmentARB_ovr_0(target, level, xoffset, yoffset, zoffset, width, height, depth, commit);
end;
end;
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);
end;
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);
end;
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);
end;
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);
public z_TexBufferARB_adr := GetFuncAdr('glTexBufferARB');
public z_TexBufferARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; _internalformat: InternalFormat; buffer: UInt32)>(z_TexBufferARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexBufferARB(target: TextureTarget; _internalformat: InternalFormat; buffer: UInt32);
begin
z_TexBufferARB_ovr_0(target, _internalformat, buffer);
end;
end;
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);
end;
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);
public z_CompressedTexImage3DARB_adr := GetFuncAdr('glCompressedTexImage3DARB');
public z_CompressedTexImage3DARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; border: Int32; imageSize: Int32; data: IntPtr)>(z_CompressedTexImage3DARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTexImage3DARB(target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; border: Int32; imageSize: Int32; data: IntPtr);
begin
z_CompressedTexImage3DARB_ovr_0(target, level, _internalformat, width, height, depth, border, imageSize, data);
end;
public z_CompressedTexImage2DARB_adr := GetFuncAdr('glCompressedTexImage2DARB');
public z_CompressedTexImage2DARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; border: Int32; imageSize: Int32; data: IntPtr)>(z_CompressedTexImage2DARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTexImage2DARB(target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; border: Int32; imageSize: Int32; data: IntPtr);
begin
z_CompressedTexImage2DARB_ovr_0(target, level, _internalformat, width, height, border, imageSize, data);
end;
public z_CompressedTexImage1DARB_adr := GetFuncAdr('glCompressedTexImage1DARB');
public z_CompressedTexImage1DARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; border: Int32; imageSize: Int32; data: IntPtr)>(z_CompressedTexImage1DARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTexImage1DARB(target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; border: Int32; imageSize: Int32; data: IntPtr);
begin
z_CompressedTexImage1DARB_ovr_0(target, level, _internalformat, width, border, imageSize, data);
end;
public z_CompressedTexSubImage3DARB_adr := GetFuncAdr('glCompressedTexSubImage3DARB');
public z_CompressedTexSubImage3DARB_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_CompressedTexSubImage3DARB_adr);
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);
begin
z_CompressedTexSubImage3DARB_ovr_0(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
end;
public z_CompressedTexSubImage2DARB_adr := GetFuncAdr('glCompressedTexSubImage2DARB');
public z_CompressedTexSubImage2DARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr)>(z_CompressedTexSubImage2DARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTexSubImage2DARB(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr);
begin
z_CompressedTexSubImage2DARB_ovr_0(target, level, xoffset, yoffset, width, height, format, imageSize, data);
end;
public z_CompressedTexSubImage1DARB_adr := GetFuncAdr('glCompressedTexSubImage1DARB');
public z_CompressedTexSubImage1DARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr)>(z_CompressedTexSubImage1DARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTexSubImage1DARB(target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; imageSize: Int32; data: IntPtr);
begin
z_CompressedTexSubImage1DARB_ovr_0(target, level, xoffset, width, format, imageSize, data);
end;
public z_GetCompressedTexImageARB_adr := GetFuncAdr('glGetCompressedTexImageARB');
public z_GetCompressedTexImageARB_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; img: IntPtr)>(z_GetCompressedTexImageARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCompressedTexImageARB(target: TextureTarget; level: Int32; img: IntPtr);
begin
z_GetCompressedTexImageARB_ovr_0(target, level, img);
end;
end;
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);
end;
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);
end;
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);
end;
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);
end;
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);
end;
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);
end;
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);
end;
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);
end;
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);
public z_LoadTransposeMatrixfARB_adr := GetFuncAdr('glLoadTransposeMatrixfARB');
public z_LoadTransposeMatrixfARB_ovr_0 := GetFuncOrNil&<procedure(var m: single)>(z_LoadTransposeMatrixfARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixfARB(m: array of single);
begin
z_LoadTransposeMatrixfARB_ovr_0(m[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixfARB(var m: single);
begin
z_LoadTransposeMatrixfARB_ovr_0(m);
end;
public z_LoadTransposeMatrixfARB_ovr_2 := GetFuncOrNil&<procedure(m: IntPtr)>(z_LoadTransposeMatrixfARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixfARB(m: IntPtr);
begin
z_LoadTransposeMatrixfARB_ovr_2(m);
end;
public z_LoadTransposeMatrixdARB_adr := GetFuncAdr('glLoadTransposeMatrixdARB');
public z_LoadTransposeMatrixdARB_ovr_0 := GetFuncOrNil&<procedure(var m: real)>(z_LoadTransposeMatrixdARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixdARB(m: array of real);
begin
z_LoadTransposeMatrixdARB_ovr_0(m[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixdARB(var m: real);
begin
z_LoadTransposeMatrixdARB_ovr_0(m);
end;
public z_LoadTransposeMatrixdARB_ovr_2 := GetFuncOrNil&<procedure(m: IntPtr)>(z_LoadTransposeMatrixdARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixdARB(m: IntPtr);
begin
z_LoadTransposeMatrixdARB_ovr_2(m);
end;
public z_MultTransposeMatrixfARB_adr := GetFuncAdr('glMultTransposeMatrixfARB');
public z_MultTransposeMatrixfARB_ovr_0 := GetFuncOrNil&<procedure(var m: single)>(z_MultTransposeMatrixfARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixfARB(m: array of single);
begin
z_MultTransposeMatrixfARB_ovr_0(m[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixfARB(var m: single);
begin
z_MultTransposeMatrixfARB_ovr_0(m);
end;
public z_MultTransposeMatrixfARB_ovr_2 := GetFuncOrNil&<procedure(m: IntPtr)>(z_MultTransposeMatrixfARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixfARB(m: IntPtr);
begin
z_MultTransposeMatrixfARB_ovr_2(m);
end;
public z_MultTransposeMatrixdARB_adr := GetFuncAdr('glMultTransposeMatrixdARB');
public z_MultTransposeMatrixdARB_ovr_0 := GetFuncOrNil&<procedure(var m: real)>(z_MultTransposeMatrixdARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixdARB(m: array of real);
begin
z_MultTransposeMatrixdARB_ovr_0(m[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixdARB(var m: real);
begin
z_MultTransposeMatrixdARB_ovr_0(m);
end;
public z_MultTransposeMatrixdARB_ovr_2 := GetFuncOrNil&<procedure(m: IntPtr)>(z_MultTransposeMatrixdARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixdARB(m: IntPtr);
begin
z_MultTransposeMatrixdARB_ovr_2(m);
end;
end;
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);
end;
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);
end;
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);
end;
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);
end;
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);
public z_WeightbvARB_adr := GetFuncAdr('glWeightbvARB');
public z_WeightbvARB_ovr_0 := GetFuncOrNil&<procedure(size: Int32; var weights: SByte)>(z_WeightbvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightbvARB(size: Int32; weights: array of SByte);
begin
z_WeightbvARB_ovr_0(size, weights[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightbvARB(size: Int32; var weights: SByte);
begin
z_WeightbvARB_ovr_0(size, weights);
end;
public z_WeightbvARB_ovr_2 := GetFuncOrNil&<procedure(size: Int32; weights: IntPtr)>(z_WeightbvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightbvARB(size: Int32; weights: IntPtr);
begin
z_WeightbvARB_ovr_2(size, weights);
end;
public z_WeightsvARB_adr := GetFuncAdr('glWeightsvARB');
public z_WeightsvARB_ovr_0 := GetFuncOrNil&<procedure(size: Int32; var weights: Int16)>(z_WeightsvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightsvARB(size: Int32; weights: array of Int16);
begin
z_WeightsvARB_ovr_0(size, weights[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightsvARB(size: Int32; var weights: Int16);
begin
z_WeightsvARB_ovr_0(size, weights);
end;
public z_WeightsvARB_ovr_2 := GetFuncOrNil&<procedure(size: Int32; weights: IntPtr)>(z_WeightsvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightsvARB(size: Int32; weights: IntPtr);
begin
z_WeightsvARB_ovr_2(size, weights);
end;
public z_WeightivARB_adr := GetFuncAdr('glWeightivARB');
public z_WeightivARB_ovr_0 := GetFuncOrNil&<procedure(size: Int32; var weights: Int32)>(z_WeightivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightivARB(size: Int32; weights: array of Int32);
begin
z_WeightivARB_ovr_0(size, weights[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightivARB(size: Int32; var weights: Int32);
begin
z_WeightivARB_ovr_0(size, weights);
end;
public z_WeightivARB_ovr_2 := GetFuncOrNil&<procedure(size: Int32; weights: IntPtr)>(z_WeightivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightivARB(size: Int32; weights: IntPtr);
begin
z_WeightivARB_ovr_2(size, weights);
end;
public z_WeightfvARB_adr := GetFuncAdr('glWeightfvARB');
public z_WeightfvARB_ovr_0 := GetFuncOrNil&<procedure(size: Int32; var weights: single)>(z_WeightfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightfvARB(size: Int32; weights: array of single);
begin
z_WeightfvARB_ovr_0(size, weights[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightfvARB(size: Int32; var weights: single);
begin
z_WeightfvARB_ovr_0(size, weights);
end;
public z_WeightfvARB_ovr_2 := GetFuncOrNil&<procedure(size: Int32; weights: IntPtr)>(z_WeightfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightfvARB(size: Int32; weights: IntPtr);
begin
z_WeightfvARB_ovr_2(size, weights);
end;
public z_WeightdvARB_adr := GetFuncAdr('glWeightdvARB');
public z_WeightdvARB_ovr_0 := GetFuncOrNil&<procedure(size: Int32; var weights: real)>(z_WeightdvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightdvARB(size: Int32; weights: array of real);
begin
z_WeightdvARB_ovr_0(size, weights[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightdvARB(size: Int32; var weights: real);
begin
z_WeightdvARB_ovr_0(size, weights);
end;
public z_WeightdvARB_ovr_2 := GetFuncOrNil&<procedure(size: Int32; weights: IntPtr)>(z_WeightdvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightdvARB(size: Int32; weights: IntPtr);
begin
z_WeightdvARB_ovr_2(size, weights);
end;
public z_WeightubvARB_adr := GetFuncAdr('glWeightubvARB');
public z_WeightubvARB_ovr_0 := GetFuncOrNil&<procedure(size: Int32; var weights: Byte)>(z_WeightubvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightubvARB(size: Int32; weights: array of Byte);
begin
z_WeightubvARB_ovr_0(size, weights[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightubvARB(size: Int32; var weights: Byte);
begin
z_WeightubvARB_ovr_0(size, weights);
end;
public z_WeightubvARB_ovr_2 := GetFuncOrNil&<procedure(size: Int32; weights: IntPtr)>(z_WeightubvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightubvARB(size: Int32; weights: IntPtr);
begin
z_WeightubvARB_ovr_2(size, weights);
end;
public z_WeightusvARB_adr := GetFuncAdr('glWeightusvARB');
public z_WeightusvARB_ovr_0 := GetFuncOrNil&<procedure(size: Int32; var weights: UInt16)>(z_WeightusvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightusvARB(size: Int32; weights: array of UInt16);
begin
z_WeightusvARB_ovr_0(size, weights[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightusvARB(size: Int32; var weights: UInt16);
begin
z_WeightusvARB_ovr_0(size, weights);
end;
public z_WeightusvARB_ovr_2 := GetFuncOrNil&<procedure(size: Int32; weights: IntPtr)>(z_WeightusvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightusvARB(size: Int32; weights: IntPtr);
begin
z_WeightusvARB_ovr_2(size, weights);
end;
public z_WeightuivARB_adr := GetFuncAdr('glWeightuivARB');
public z_WeightuivARB_ovr_0 := GetFuncOrNil&<procedure(size: Int32; var weights: UInt32)>(z_WeightuivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightuivARB(size: Int32; weights: array of UInt32);
begin
z_WeightuivARB_ovr_0(size, weights[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightuivARB(size: Int32; var weights: UInt32);
begin
z_WeightuivARB_ovr_0(size, weights);
end;
public z_WeightuivARB_ovr_2 := GetFuncOrNil&<procedure(size: Int32; weights: IntPtr)>(z_WeightuivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightuivARB(size: Int32; weights: IntPtr);
begin
z_WeightuivARB_ovr_2(size, weights);
end;
public z_WeightPointerARB_adr := GetFuncAdr('glWeightPointerARB');
public z_WeightPointerARB_ovr_0 := GetFuncOrNil&<procedure(size: Int32; &type: WeightPointerTypeARB; stride: Int32; pointer: IntPtr)>(z_WeightPointerARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightPointerARB(size: Int32; &type: WeightPointerTypeARB; stride: Int32; pointer: IntPtr);
begin
z_WeightPointerARB_ovr_0(size, &type, stride, pointer);
end;
public z_VertexBlendARB_adr := GetFuncAdr('glVertexBlendARB');
public z_VertexBlendARB_ovr_0 := GetFuncOrNil&<procedure(count: Int32)>(z_VertexBlendARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexBlendARB(count: Int32);
begin
z_VertexBlendARB_ovr_0(count);
end;
end;
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);
public z_BindBufferARB_adr := GetFuncAdr('glBindBufferARB');
public z_BindBufferARB_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; buffer: UInt32)>(z_BindBufferARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferARB(target: BufferTargetARB; buffer: UInt32);
begin
z_BindBufferARB_ovr_0(target, buffer);
end;
public z_DeleteBuffersARB_adr := GetFuncAdr('glDeleteBuffersARB');
public z_DeleteBuffersARB_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var buffers: UInt32)>(z_DeleteBuffersARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteBuffersARB(n: Int32; buffers: array of UInt32);
begin
z_DeleteBuffersARB_ovr_0(n, buffers[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteBuffersARB(n: Int32; var buffers: UInt32);
begin
z_DeleteBuffersARB_ovr_0(n, buffers);
end;
public z_DeleteBuffersARB_ovr_2 := GetFuncOrNil&<procedure(n: Int32; buffers: IntPtr)>(z_DeleteBuffersARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteBuffersARB(n: Int32; buffers: IntPtr);
begin
z_DeleteBuffersARB_ovr_2(n, buffers);
end;
public z_GenBuffersARB_adr := GetFuncAdr('glGenBuffersARB');
public z_GenBuffersARB_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var buffers: UInt32)>(z_GenBuffersARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenBuffersARB(n: Int32; buffers: array of UInt32);
begin
z_GenBuffersARB_ovr_0(n, buffers[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenBuffersARB(n: Int32; var buffers: UInt32);
begin
z_GenBuffersARB_ovr_0(n, buffers);
end;
public z_GenBuffersARB_ovr_2 := GetFuncOrNil&<procedure(n: Int32; buffers: IntPtr)>(z_GenBuffersARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenBuffersARB(n: Int32; buffers: IntPtr);
begin
z_GenBuffersARB_ovr_2(n, buffers);
end;
public z_IsBufferARB_adr := GetFuncAdr('glIsBufferARB');
public z_IsBufferARB_ovr_0 := GetFuncOrNil&<function(buffer: UInt32): boolean>(z_IsBufferARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsBufferARB(buffer: UInt32): boolean;
begin
Result := z_IsBufferARB_ovr_0(buffer);
end;
public z_BufferDataARB_adr := GetFuncAdr('glBufferDataARB');
public z_BufferDataARB_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; size: IntPtr; data: IntPtr; usage: BufferUsageARB)>(z_BufferDataARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferDataARB(target: BufferTargetARB; size: IntPtr; data: IntPtr; usage: BufferUsageARB);
begin
z_BufferDataARB_ovr_0(target, size, data, usage);
end;
public z_BufferSubDataARB_adr := GetFuncAdr('glBufferSubDataARB');
public z_BufferSubDataARB_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; offset: IntPtr; size: IntPtr; data: IntPtr)>(z_BufferSubDataARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferSubDataARB(target: BufferTargetARB; offset: IntPtr; size: IntPtr; data: IntPtr);
begin
z_BufferSubDataARB_ovr_0(target, offset, size, data);
end;
public z_GetBufferSubDataARB_adr := GetFuncAdr('glGetBufferSubDataARB');
public z_GetBufferSubDataARB_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; offset: IntPtr; size: IntPtr; data: IntPtr)>(z_GetBufferSubDataARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferSubDataARB(target: BufferTargetARB; offset: IntPtr; size: IntPtr; data: IntPtr);
begin
z_GetBufferSubDataARB_ovr_0(target, offset, size, data);
end;
public z_MapBufferARB_adr := GetFuncAdr('glMapBufferARB');
public z_MapBufferARB_ovr_0 := GetFuncOrNil&<function(target: BufferTargetARB; access: BufferAccessARB): IntPtr>(z_MapBufferARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapBufferARB(target: BufferTargetARB; access: BufferAccessARB): IntPtr;
begin
Result := z_MapBufferARB_ovr_0(target, access);
end;
public z_UnmapBufferARB_adr := GetFuncAdr('glUnmapBufferARB');
public z_UnmapBufferARB_ovr_0 := GetFuncOrNil&<function(target: BufferTargetARB): boolean>(z_UnmapBufferARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function UnmapBufferARB(target: BufferTargetARB): boolean;
begin
Result := z_UnmapBufferARB_ovr_0(target);
end;
public z_GetBufferParameterivARB_adr := GetFuncAdr('glGetBufferParameterivARB');
public z_GetBufferParameterivARB_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPNameARB; var ¶ms: Int32)>(z_GetBufferParameterivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameterivARB(target: BufferTargetARB; pname: BufferPNameARB; ¶ms: array of Int32);
begin
z_GetBufferParameterivARB_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameterivARB(target: BufferTargetARB; pname: BufferPNameARB; var ¶ms: Int32);
begin
z_GetBufferParameterivARB_ovr_0(target, pname, ¶ms);
end;
public z_GetBufferParameterivARB_ovr_2 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPNameARB; ¶ms: IntPtr)>(z_GetBufferParameterivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameterivARB(target: BufferTargetARB; pname: BufferPNameARB; ¶ms: IntPtr);
begin
z_GetBufferParameterivARB_ovr_2(target, pname, ¶ms);
end;
public z_GetBufferPointervARB_adr := GetFuncAdr('glGetBufferPointervARB');
public z_GetBufferPointervARB_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPointerNameARB; var ¶ms: IntPtr)>(z_GetBufferPointervARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferPointervARB(target: BufferTargetARB; pname: BufferPointerNameARB; ¶ms: array of IntPtr);
begin
z_GetBufferPointervARB_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferPointervARB(target: BufferTargetARB; pname: BufferPointerNameARB; var ¶ms: IntPtr);
begin
z_GetBufferPointervARB_ovr_0(target, pname, ¶ms);
end;
public z_GetBufferPointervARB_ovr_2 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPointerNameARB; ¶ms: pointer)>(z_GetBufferPointervARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferPointervARB(target: BufferTargetARB; pname: BufferPointerNameARB; ¶ms: pointer);
begin
z_GetBufferPointervARB_ovr_2(target, pname, ¶ms);
end;
end;
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);
public z_VertexAttrib1dARB_adr := GetFuncAdr('glVertexAttrib1dARB');
public z_VertexAttrib1dARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: real)>(z_VertexAttrib1dARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dARB(index: UInt32; x: real);
begin
z_VertexAttrib1dARB_ovr_0(index, x);
end;
public z_VertexAttrib1dvARB_adr := GetFuncAdr('glVertexAttrib1dvARB');
public z_VertexAttrib1dvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttrib1dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dvARB(index: UInt32; v: array of real);
begin
z_VertexAttrib1dvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dvARB(index: UInt32; var v: real);
begin
z_VertexAttrib1dvARB_ovr_0(index, v);
end;
public z_VertexAttrib1dvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib1dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib1dvARB_ovr_2(index, v);
end;
public z_VertexAttrib1fARB_adr := GetFuncAdr('glVertexAttrib1fARB');
public z_VertexAttrib1fARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: single)>(z_VertexAttrib1fARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fARB(index: UInt32; x: single);
begin
z_VertexAttrib1fARB_ovr_0(index, x);
end;
public z_VertexAttrib1fvARB_adr := GetFuncAdr('glVertexAttrib1fvARB');
public z_VertexAttrib1fvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: single)>(z_VertexAttrib1fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fvARB(index: UInt32; v: array of single);
begin
z_VertexAttrib1fvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fvARB(index: UInt32; var v: single);
begin
z_VertexAttrib1fvARB_ovr_0(index, v);
end;
public z_VertexAttrib1fvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib1fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib1fvARB_ovr_2(index, v);
end;
public z_VertexAttrib1sARB_adr := GetFuncAdr('glVertexAttrib1sARB');
public z_VertexAttrib1sARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Int16)>(z_VertexAttrib1sARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1sARB(index: UInt32; x: Int16);
begin
z_VertexAttrib1sARB_ovr_0(index, x);
end;
public z_VertexAttrib1svARB_adr := GetFuncAdr('glVertexAttrib1svARB');
public z_VertexAttrib1svARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int16)>(z_VertexAttrib1svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1svARB(index: UInt32; v: array of Int16);
begin
z_VertexAttrib1svARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1svARB(index: UInt32; var v: Int16);
begin
z_VertexAttrib1svARB_ovr_0(index, v);
end;
public z_VertexAttrib1svARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib1svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1svARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib1svARB_ovr_2(index, v);
end;
public z_VertexAttrib2dARB_adr := GetFuncAdr('glVertexAttrib2dARB');
public z_VertexAttrib2dARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: real; y: real)>(z_VertexAttrib2dARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dARB(index: UInt32; x: real; y: real);
begin
z_VertexAttrib2dARB_ovr_0(index, x, y);
end;
public z_VertexAttrib2dvARB_adr := GetFuncAdr('glVertexAttrib2dvARB');
public z_VertexAttrib2dvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttrib2dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dvARB(index: UInt32; v: array of real);
begin
z_VertexAttrib2dvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dvARB(index: UInt32; var v: real);
begin
z_VertexAttrib2dvARB_ovr_0(index, v);
end;
public z_VertexAttrib2dvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib2dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib2dvARB_ovr_2(index, v);
end;
public z_VertexAttrib2fARB_adr := GetFuncAdr('glVertexAttrib2fARB');
public z_VertexAttrib2fARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: single; y: single)>(z_VertexAttrib2fARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fARB(index: UInt32; x: single; y: single);
begin
z_VertexAttrib2fARB_ovr_0(index, x, y);
end;
public z_VertexAttrib2fvARB_adr := GetFuncAdr('glVertexAttrib2fvARB');
public z_VertexAttrib2fvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: single)>(z_VertexAttrib2fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fvARB(index: UInt32; v: array of single);
begin
z_VertexAttrib2fvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fvARB(index: UInt32; var v: single);
begin
z_VertexAttrib2fvARB_ovr_0(index, v);
end;
public z_VertexAttrib2fvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib2fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib2fvARB_ovr_2(index, v);
end;
public z_VertexAttrib2sARB_adr := GetFuncAdr('glVertexAttrib2sARB');
public z_VertexAttrib2sARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Int16; y: Int16)>(z_VertexAttrib2sARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2sARB(index: UInt32; x: Int16; y: Int16);
begin
z_VertexAttrib2sARB_ovr_0(index, x, y);
end;
public z_VertexAttrib2svARB_adr := GetFuncAdr('glVertexAttrib2svARB');
public z_VertexAttrib2svARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int16)>(z_VertexAttrib2svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2svARB(index: UInt32; v: array of Int16);
begin
z_VertexAttrib2svARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2svARB(index: UInt32; var v: Int16);
begin
z_VertexAttrib2svARB_ovr_0(index, v);
end;
public z_VertexAttrib2svARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib2svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2svARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib2svARB_ovr_2(index, v);
end;
public z_VertexAttrib3dARB_adr := GetFuncAdr('glVertexAttrib3dARB');
public z_VertexAttrib3dARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: real; y: real; z: real)>(z_VertexAttrib3dARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dARB(index: UInt32; x: real; y: real; z: real);
begin
z_VertexAttrib3dARB_ovr_0(index, x, y, z);
end;
public z_VertexAttrib3dvARB_adr := GetFuncAdr('glVertexAttrib3dvARB');
public z_VertexAttrib3dvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttrib3dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dvARB(index: UInt32; v: array of real);
begin
z_VertexAttrib3dvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dvARB(index: UInt32; var v: real);
begin
z_VertexAttrib3dvARB_ovr_0(index, v);
end;
public z_VertexAttrib3dvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib3dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib3dvARB_ovr_2(index, v);
end;
public z_VertexAttrib3fARB_adr := GetFuncAdr('glVertexAttrib3fARB');
public z_VertexAttrib3fARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: single; y: single; z: single)>(z_VertexAttrib3fARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fARB(index: UInt32; x: single; y: single; z: single);
begin
z_VertexAttrib3fARB_ovr_0(index, x, y, z);
end;
public z_VertexAttrib3fvARB_adr := GetFuncAdr('glVertexAttrib3fvARB');
public z_VertexAttrib3fvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: single)>(z_VertexAttrib3fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fvARB(index: UInt32; v: array of single);
begin
z_VertexAttrib3fvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fvARB(index: UInt32; var v: single);
begin
z_VertexAttrib3fvARB_ovr_0(index, v);
end;
public z_VertexAttrib3fvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib3fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib3fvARB_ovr_2(index, v);
end;
public z_VertexAttrib3sARB_adr := GetFuncAdr('glVertexAttrib3sARB');
public z_VertexAttrib3sARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Int16; y: Int16; z: Int16)>(z_VertexAttrib3sARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3sARB(index: UInt32; x: Int16; y: Int16; z: Int16);
begin
z_VertexAttrib3sARB_ovr_0(index, x, y, z);
end;
public z_VertexAttrib3svARB_adr := GetFuncAdr('glVertexAttrib3svARB');
public z_VertexAttrib3svARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int16)>(z_VertexAttrib3svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3svARB(index: UInt32; v: array of Int16);
begin
z_VertexAttrib3svARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3svARB(index: UInt32; var v: Int16);
begin
z_VertexAttrib3svARB_ovr_0(index, v);
end;
public z_VertexAttrib3svARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib3svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3svARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib3svARB_ovr_2(index, v);
end;
public z_VertexAttrib4NbvARB_adr := GetFuncAdr('glVertexAttrib4NbvARB');
public z_VertexAttrib4NbvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: SByte)>(z_VertexAttrib4NbvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NbvARB(index: UInt32; v: array of SByte);
begin
z_VertexAttrib4NbvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NbvARB(index: UInt32; var v: SByte);
begin
z_VertexAttrib4NbvARB_ovr_0(index, v);
end;
public z_VertexAttrib4NbvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4NbvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NbvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4NbvARB_ovr_2(index, v);
end;
public z_VertexAttrib4NivARB_adr := GetFuncAdr('glVertexAttrib4NivARB');
public z_VertexAttrib4NivARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int32)>(z_VertexAttrib4NivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NivARB(index: UInt32; v: array of Int32);
begin
z_VertexAttrib4NivARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NivARB(index: UInt32; var v: Int32);
begin
z_VertexAttrib4NivARB_ovr_0(index, v);
end;
public z_VertexAttrib4NivARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4NivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NivARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4NivARB_ovr_2(index, v);
end;
public z_VertexAttrib4NsvARB_adr := GetFuncAdr('glVertexAttrib4NsvARB');
public z_VertexAttrib4NsvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int16)>(z_VertexAttrib4NsvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NsvARB(index: UInt32; v: array of Int16);
begin
z_VertexAttrib4NsvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NsvARB(index: UInt32; var v: Int16);
begin
z_VertexAttrib4NsvARB_ovr_0(index, v);
end;
public z_VertexAttrib4NsvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4NsvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NsvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4NsvARB_ovr_2(index, v);
end;
public z_VertexAttrib4NubARB_adr := GetFuncAdr('glVertexAttrib4NubARB');
public z_VertexAttrib4NubARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Byte; y: Byte; z: Byte; w: Byte)>(z_VertexAttrib4NubARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NubARB(index: UInt32; x: Byte; y: Byte; z: Byte; w: Byte);
begin
z_VertexAttrib4NubARB_ovr_0(index, x, y, z, w);
end;
public z_VertexAttrib4NubvARB_adr := GetFuncAdr('glVertexAttrib4NubvARB');
public z_VertexAttrib4NubvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Byte)>(z_VertexAttrib4NubvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NubvARB(index: UInt32; v: array of Byte);
begin
z_VertexAttrib4NubvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NubvARB(index: UInt32; var v: Byte);
begin
z_VertexAttrib4NubvARB_ovr_0(index, v);
end;
public z_VertexAttrib4NubvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4NubvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NubvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4NubvARB_ovr_2(index, v);
end;
public z_VertexAttrib4NuivARB_adr := GetFuncAdr('glVertexAttrib4NuivARB');
public z_VertexAttrib4NuivARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt32)>(z_VertexAttrib4NuivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NuivARB(index: UInt32; v: array of UInt32);
begin
z_VertexAttrib4NuivARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NuivARB(index: UInt32; var v: UInt32);
begin
z_VertexAttrib4NuivARB_ovr_0(index, v);
end;
public z_VertexAttrib4NuivARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4NuivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NuivARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4NuivARB_ovr_2(index, v);
end;
public z_VertexAttrib4NusvARB_adr := GetFuncAdr('glVertexAttrib4NusvARB');
public z_VertexAttrib4NusvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt16)>(z_VertexAttrib4NusvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NusvARB(index: UInt32; v: array of UInt16);
begin
z_VertexAttrib4NusvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NusvARB(index: UInt32; var v: UInt16);
begin
z_VertexAttrib4NusvARB_ovr_0(index, v);
end;
public z_VertexAttrib4NusvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4NusvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NusvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4NusvARB_ovr_2(index, v);
end;
public z_VertexAttrib4bvARB_adr := GetFuncAdr('glVertexAttrib4bvARB');
public z_VertexAttrib4bvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: SByte)>(z_VertexAttrib4bvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4bvARB(index: UInt32; v: array of SByte);
begin
z_VertexAttrib4bvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4bvARB(index: UInt32; var v: SByte);
begin
z_VertexAttrib4bvARB_ovr_0(index, v);
end;
public z_VertexAttrib4bvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4bvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4bvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4bvARB_ovr_2(index, v);
end;
public z_VertexAttrib4dARB_adr := GetFuncAdr('glVertexAttrib4dARB');
public z_VertexAttrib4dARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: real; y: real; z: real; w: real)>(z_VertexAttrib4dARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dARB(index: UInt32; x: real; y: real; z: real; w: real);
begin
z_VertexAttrib4dARB_ovr_0(index, x, y, z, w);
end;
public z_VertexAttrib4dvARB_adr := GetFuncAdr('glVertexAttrib4dvARB');
public z_VertexAttrib4dvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttrib4dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dvARB(index: UInt32; v: array of real);
begin
z_VertexAttrib4dvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dvARB(index: UInt32; var v: real);
begin
z_VertexAttrib4dvARB_ovr_0(index, v);
end;
public z_VertexAttrib4dvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4dvARB_ovr_2(index, v);
end;
public z_VertexAttrib4fARB_adr := GetFuncAdr('glVertexAttrib4fARB');
public z_VertexAttrib4fARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: single; y: single; z: single; w: single)>(z_VertexAttrib4fARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fARB(index: UInt32; x: single; y: single; z: single; w: single);
begin
z_VertexAttrib4fARB_ovr_0(index, x, y, z, w);
end;
public z_VertexAttrib4fvARB_adr := GetFuncAdr('glVertexAttrib4fvARB');
public z_VertexAttrib4fvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: single)>(z_VertexAttrib4fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fvARB(index: UInt32; v: array of single);
begin
z_VertexAttrib4fvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fvARB(index: UInt32; var v: single);
begin
z_VertexAttrib4fvARB_ovr_0(index, v);
end;
public z_VertexAttrib4fvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4fvARB_ovr_2(index, v);
end;
public z_VertexAttrib4ivARB_adr := GetFuncAdr('glVertexAttrib4ivARB');
public z_VertexAttrib4ivARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int32)>(z_VertexAttrib4ivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ivARB(index: UInt32; v: array of Int32);
begin
z_VertexAttrib4ivARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ivARB(index: UInt32; var v: Int32);
begin
z_VertexAttrib4ivARB_ovr_0(index, v);
end;
public z_VertexAttrib4ivARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4ivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ivARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4ivARB_ovr_2(index, v);
end;
public z_VertexAttrib4sARB_adr := GetFuncAdr('glVertexAttrib4sARB');
public z_VertexAttrib4sARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Int16; y: Int16; z: Int16; w: Int16)>(z_VertexAttrib4sARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4sARB(index: UInt32; x: Int16; y: Int16; z: Int16; w: Int16);
begin
z_VertexAttrib4sARB_ovr_0(index, x, y, z, w);
end;
public z_VertexAttrib4svARB_adr := GetFuncAdr('glVertexAttrib4svARB');
public z_VertexAttrib4svARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int16)>(z_VertexAttrib4svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4svARB(index: UInt32; v: array of Int16);
begin
z_VertexAttrib4svARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4svARB(index: UInt32; var v: Int16);
begin
z_VertexAttrib4svARB_ovr_0(index, v);
end;
public z_VertexAttrib4svARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4svARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4svARB_ovr_2(index, v);
end;
public z_VertexAttrib4ubvARB_adr := GetFuncAdr('glVertexAttrib4ubvARB');
public z_VertexAttrib4ubvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Byte)>(z_VertexAttrib4ubvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ubvARB(index: UInt32; v: array of Byte);
begin
z_VertexAttrib4ubvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ubvARB(index: UInt32; var v: Byte);
begin
z_VertexAttrib4ubvARB_ovr_0(index, v);
end;
public z_VertexAttrib4ubvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4ubvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ubvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4ubvARB_ovr_2(index, v);
end;
public z_VertexAttrib4uivARB_adr := GetFuncAdr('glVertexAttrib4uivARB');
public z_VertexAttrib4uivARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt32)>(z_VertexAttrib4uivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4uivARB(index: UInt32; v: array of UInt32);
begin
z_VertexAttrib4uivARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4uivARB(index: UInt32; var v: UInt32);
begin
z_VertexAttrib4uivARB_ovr_0(index, v);
end;
public z_VertexAttrib4uivARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4uivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4uivARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4uivARB_ovr_2(index, v);
end;
public z_VertexAttrib4usvARB_adr := GetFuncAdr('glVertexAttrib4usvARB');
public z_VertexAttrib4usvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt16)>(z_VertexAttrib4usvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4usvARB(index: UInt32; v: array of UInt16);
begin
z_VertexAttrib4usvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4usvARB(index: UInt32; var v: UInt16);
begin
z_VertexAttrib4usvARB_ovr_0(index, v);
end;
public z_VertexAttrib4usvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4usvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4usvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4usvARB_ovr_2(index, v);
end;
public z_VertexAttribPointerARB_adr := GetFuncAdr('glVertexAttribPointerARB');
public z_VertexAttribPointerARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; size: Int32; &type: VertexAttribPointerType; normalized: boolean; stride: Int32; pointer: IntPtr)>(z_VertexAttribPointerARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribPointerARB(index: UInt32; size: Int32; &type: VertexAttribPointerType; normalized: boolean; stride: Int32; pointer: IntPtr);
begin
z_VertexAttribPointerARB_ovr_0(index, size, &type, normalized, stride, pointer);
end;
public z_EnableVertexAttribArrayARB_adr := GetFuncAdr('glEnableVertexAttribArrayARB');
public z_EnableVertexAttribArrayARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32)>(z_EnableVertexAttribArrayARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EnableVertexAttribArrayARB(index: UInt32);
begin
z_EnableVertexAttribArrayARB_ovr_0(index);
end;
public z_DisableVertexAttribArrayARB_adr := GetFuncAdr('glDisableVertexAttribArrayARB');
public z_DisableVertexAttribArrayARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32)>(z_DisableVertexAttribArrayARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DisableVertexAttribArrayARB(index: UInt32);
begin
z_DisableVertexAttribArrayARB_ovr_0(index);
end;
public z_ProgramStringARB_adr := GetFuncAdr('glProgramStringARB');
public z_ProgramStringARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; format: ProgramFormat; len: Int32; string: IntPtr)>(z_ProgramStringARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramStringARB(target: ProgramTarget; format: ProgramFormat; len: Int32; string: IntPtr);
begin
z_ProgramStringARB_ovr_0(target, format, len, string);
end;
public z_BindProgramARB_adr := GetFuncAdr('glBindProgramARB');
public z_BindProgramARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; &program: UInt32)>(z_BindProgramARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindProgramARB(target: ProgramTarget; &program: UInt32);
begin
z_BindProgramARB_ovr_0(target, &program);
end;
public z_DeleteProgramsARB_adr := GetFuncAdr('glDeleteProgramsARB');
public z_DeleteProgramsARB_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var programs: UInt32)>(z_DeleteProgramsARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgramsARB(n: Int32; programs: array of UInt32);
begin
z_DeleteProgramsARB_ovr_0(n, programs[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgramsARB(n: Int32; var programs: UInt32);
begin
z_DeleteProgramsARB_ovr_0(n, programs);
end;
public z_DeleteProgramsARB_ovr_2 := GetFuncOrNil&<procedure(n: Int32; programs: IntPtr)>(z_DeleteProgramsARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgramsARB(n: Int32; programs: IntPtr);
begin
z_DeleteProgramsARB_ovr_2(n, programs);
end;
public z_GenProgramsARB_adr := GetFuncAdr('glGenProgramsARB');
public z_GenProgramsARB_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var programs: UInt32)>(z_GenProgramsARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenProgramsARB(n: Int32; programs: array of UInt32);
begin
z_GenProgramsARB_ovr_0(n, programs[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenProgramsARB(n: Int32; var programs: UInt32);
begin
z_GenProgramsARB_ovr_0(n, programs);
end;
public z_GenProgramsARB_ovr_2 := GetFuncOrNil&<procedure(n: Int32; programs: IntPtr)>(z_GenProgramsARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenProgramsARB(n: Int32; programs: IntPtr);
begin
z_GenProgramsARB_ovr_2(n, programs);
end;
public z_ProgramEnvParameter4dARB_adr := GetFuncAdr('glProgramEnvParameter4dARB');
public z_ProgramEnvParameter4dARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; x: real; y: real; z: real; w: real)>(z_ProgramEnvParameter4dARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4dARB(target: ProgramTarget; index: UInt32; x: real; y: real; z: real; w: real);
begin
z_ProgramEnvParameter4dARB_ovr_0(target, index, x, y, z, w);
end;
public z_ProgramEnvParameter4dvARB_adr := GetFuncAdr('glProgramEnvParameter4dvARB');
public z_ProgramEnvParameter4dvARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; var ¶ms: real)>(z_ProgramEnvParameter4dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4dvARB(target: ProgramTarget; index: UInt32; ¶ms: array of real);
begin
z_ProgramEnvParameter4dvARB_ovr_0(target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4dvARB(target: ProgramTarget; index: UInt32; var ¶ms: real);
begin
z_ProgramEnvParameter4dvARB_ovr_0(target, index, ¶ms);
end;
public z_ProgramEnvParameter4dvARB_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_ProgramEnvParameter4dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4dvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_ProgramEnvParameter4dvARB_ovr_2(target, index, ¶ms);
end;
public z_ProgramEnvParameter4fARB_adr := GetFuncAdr('glProgramEnvParameter4fARB');
public z_ProgramEnvParameter4fARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; x: single; y: single; z: single; w: single)>(z_ProgramEnvParameter4fARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4fARB(target: ProgramTarget; index: UInt32; x: single; y: single; z: single; w: single);
begin
z_ProgramEnvParameter4fARB_ovr_0(target, index, x, y, z, w);
end;
public z_ProgramEnvParameter4fvARB_adr := GetFuncAdr('glProgramEnvParameter4fvARB');
public z_ProgramEnvParameter4fvARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; var ¶ms: single)>(z_ProgramEnvParameter4fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4fvARB(target: ProgramTarget; index: UInt32; ¶ms: array of single);
begin
z_ProgramEnvParameter4fvARB_ovr_0(target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4fvARB(target: ProgramTarget; index: UInt32; var ¶ms: single);
begin
z_ProgramEnvParameter4fvARB_ovr_0(target, index, ¶ms);
end;
public z_ProgramEnvParameter4fvARB_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_ProgramEnvParameter4fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameter4fvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_ProgramEnvParameter4fvARB_ovr_2(target, index, ¶ms);
end;
public z_ProgramLocalParameter4dARB_adr := GetFuncAdr('glProgramLocalParameter4dARB');
public z_ProgramLocalParameter4dARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; x: real; y: real; z: real; w: real)>(z_ProgramLocalParameter4dARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4dARB(target: ProgramTarget; index: UInt32; x: real; y: real; z: real; w: real);
begin
z_ProgramLocalParameter4dARB_ovr_0(target, index, x, y, z, w);
end;
public z_ProgramLocalParameter4dvARB_adr := GetFuncAdr('glProgramLocalParameter4dvARB');
public z_ProgramLocalParameter4dvARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; var ¶ms: real)>(z_ProgramLocalParameter4dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4dvARB(target: ProgramTarget; index: UInt32; ¶ms: array of real);
begin
z_ProgramLocalParameter4dvARB_ovr_0(target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4dvARB(target: ProgramTarget; index: UInt32; var ¶ms: real);
begin
z_ProgramLocalParameter4dvARB_ovr_0(target, index, ¶ms);
end;
public z_ProgramLocalParameter4dvARB_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_ProgramLocalParameter4dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4dvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_ProgramLocalParameter4dvARB_ovr_2(target, index, ¶ms);
end;
public z_ProgramLocalParameter4fARB_adr := GetFuncAdr('glProgramLocalParameter4fARB');
public z_ProgramLocalParameter4fARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; x: single; y: single; z: single; w: single)>(z_ProgramLocalParameter4fARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4fARB(target: ProgramTarget; index: UInt32; x: single; y: single; z: single; w: single);
begin
z_ProgramLocalParameter4fARB_ovr_0(target, index, x, y, z, w);
end;
public z_ProgramLocalParameter4fvARB_adr := GetFuncAdr('glProgramLocalParameter4fvARB');
public z_ProgramLocalParameter4fvARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; var ¶ms: single)>(z_ProgramLocalParameter4fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4fvARB(target: ProgramTarget; index: UInt32; ¶ms: array of single);
begin
z_ProgramLocalParameter4fvARB_ovr_0(target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4fvARB(target: ProgramTarget; index: UInt32; var ¶ms: single);
begin
z_ProgramLocalParameter4fvARB_ovr_0(target, index, ¶ms);
end;
public z_ProgramLocalParameter4fvARB_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_ProgramLocalParameter4fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameter4fvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_ProgramLocalParameter4fvARB_ovr_2(target, index, ¶ms);
end;
public z_GetProgramEnvParameterdvARB_adr := GetFuncAdr('glGetProgramEnvParameterdvARB');
public z_GetProgramEnvParameterdvARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; var ¶ms: real)>(z_GetProgramEnvParameterdvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterdvARB(target: ProgramTarget; index: UInt32; ¶ms: array of real);
begin
z_GetProgramEnvParameterdvARB_ovr_0(target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterdvARB(target: ProgramTarget; index: UInt32; var ¶ms: real);
begin
z_GetProgramEnvParameterdvARB_ovr_0(target, index, ¶ms);
end;
public z_GetProgramEnvParameterdvARB_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_GetProgramEnvParameterdvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterdvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_GetProgramEnvParameterdvARB_ovr_2(target, index, ¶ms);
end;
public z_GetProgramEnvParameterfvARB_adr := GetFuncAdr('glGetProgramEnvParameterfvARB');
public z_GetProgramEnvParameterfvARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; var ¶ms: single)>(z_GetProgramEnvParameterfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterfvARB(target: ProgramTarget; index: UInt32; ¶ms: array of single);
begin
z_GetProgramEnvParameterfvARB_ovr_0(target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterfvARB(target: ProgramTarget; index: UInt32; var ¶ms: single);
begin
z_GetProgramEnvParameterfvARB_ovr_0(target, index, ¶ms);
end;
public z_GetProgramEnvParameterfvARB_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_GetProgramEnvParameterfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterfvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_GetProgramEnvParameterfvARB_ovr_2(target, index, ¶ms);
end;
public z_GetProgramLocalParameterdvARB_adr := GetFuncAdr('glGetProgramLocalParameterdvARB');
public z_GetProgramLocalParameterdvARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; var ¶ms: real)>(z_GetProgramLocalParameterdvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterdvARB(target: ProgramTarget; index: UInt32; ¶ms: array of real);
begin
z_GetProgramLocalParameterdvARB_ovr_0(target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterdvARB(target: ProgramTarget; index: UInt32; var ¶ms: real);
begin
z_GetProgramLocalParameterdvARB_ovr_0(target, index, ¶ms);
end;
public z_GetProgramLocalParameterdvARB_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_GetProgramLocalParameterdvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterdvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_GetProgramLocalParameterdvARB_ovr_2(target, index, ¶ms);
end;
public z_GetProgramLocalParameterfvARB_adr := GetFuncAdr('glGetProgramLocalParameterfvARB');
public z_GetProgramLocalParameterfvARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; var ¶ms: single)>(z_GetProgramLocalParameterfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterfvARB(target: ProgramTarget; index: UInt32; ¶ms: array of single);
begin
z_GetProgramLocalParameterfvARB_ovr_0(target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterfvARB(target: ProgramTarget; index: UInt32; var ¶ms: single);
begin
z_GetProgramLocalParameterfvARB_ovr_0(target, index, ¶ms);
end;
public z_GetProgramLocalParameterfvARB_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_GetProgramLocalParameterfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterfvARB(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_GetProgramLocalParameterfvARB_ovr_2(target, index, ¶ms);
end;
public z_GetProgramivARB_adr := GetFuncAdr('glGetProgramivARB');
public z_GetProgramivARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; pname: ProgramPropertyARB; var ¶ms: Int32)>(z_GetProgramivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramivARB(target: ProgramTarget; pname: ProgramPropertyARB; ¶ms: array of Int32);
begin
z_GetProgramivARB_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramivARB(target: ProgramTarget; pname: ProgramPropertyARB; var ¶ms: Int32);
begin
z_GetProgramivARB_ovr_0(target, pname, ¶ms);
end;
public z_GetProgramivARB_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; pname: ProgramPropertyARB; ¶ms: IntPtr)>(z_GetProgramivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramivARB(target: ProgramTarget; pname: ProgramPropertyARB; ¶ms: IntPtr);
begin
z_GetProgramivARB_ovr_2(target, pname, ¶ms);
end;
public z_GetProgramStringARB_adr := GetFuncAdr('glGetProgramStringARB');
public z_GetProgramStringARB_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; pname: ProgramStringProperty; string: IntPtr)>(z_GetProgramStringARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramStringARB(target: ProgramTarget; pname: ProgramStringProperty; string: IntPtr);
begin
z_GetProgramStringARB_ovr_0(target, pname, string);
end;
public z_GetVertexAttribdvARB_adr := GetFuncAdr('glGetVertexAttribdvARB');
public z_GetVertexAttribdvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: real)>(z_GetVertexAttribdvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribdvARB(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: array of real);
begin
z_GetVertexAttribdvARB_ovr_0(index, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribdvARB(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: real);
begin
z_GetVertexAttribdvARB_ovr_0(index, pname, ¶ms);
end;
public z_GetVertexAttribdvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr)>(z_GetVertexAttribdvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribdvARB(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr);
begin
z_GetVertexAttribdvARB_ovr_2(index, pname, ¶ms);
end;
public z_GetVertexAttribfvARB_adr := GetFuncAdr('glGetVertexAttribfvARB');
public z_GetVertexAttribfvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: single)>(z_GetVertexAttribfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribfvARB(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: array of single);
begin
z_GetVertexAttribfvARB_ovr_0(index, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribfvARB(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: single);
begin
z_GetVertexAttribfvARB_ovr_0(index, pname, ¶ms);
end;
public z_GetVertexAttribfvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr)>(z_GetVertexAttribfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribfvARB(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr);
begin
z_GetVertexAttribfvARB_ovr_2(index, pname, ¶ms);
end;
public z_GetVertexAttribivARB_adr := GetFuncAdr('glGetVertexAttribivARB');
public z_GetVertexAttribivARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: Int32)>(z_GetVertexAttribivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribivARB(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: array of Int32);
begin
z_GetVertexAttribivARB_ovr_0(index, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribivARB(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: Int32);
begin
z_GetVertexAttribivARB_ovr_0(index, pname, ¶ms);
end;
public z_GetVertexAttribivARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr)>(z_GetVertexAttribivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribivARB(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr);
begin
z_GetVertexAttribivARB_ovr_2(index, pname, ¶ms);
end;
public z_GetVertexAttribPointervARB_adr := GetFuncAdr('glGetVertexAttribPointervARB');
public z_GetVertexAttribPointervARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPointerPropertyARB; var _pointer: IntPtr)>(z_GetVertexAttribPointervARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribPointervARB(index: UInt32; pname: VertexAttribPointerPropertyARB; _pointer: array of IntPtr);
begin
z_GetVertexAttribPointervARB_ovr_0(index, pname, _pointer[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribPointervARB(index: UInt32; pname: VertexAttribPointerPropertyARB; var _pointer: IntPtr);
begin
z_GetVertexAttribPointervARB_ovr_0(index, pname, _pointer);
end;
public z_GetVertexAttribPointervARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPointerPropertyARB; _pointer: pointer)>(z_GetVertexAttribPointervARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribPointervARB(index: UInt32; pname: VertexAttribPointerPropertyARB; _pointer: pointer);
begin
z_GetVertexAttribPointervARB_ovr_2(index, pname, _pointer);
end;
public z_IsProgramARB_adr := GetFuncAdr('glIsProgramARB');
public z_IsProgramARB_ovr_0 := GetFuncOrNil&<function(&program: UInt32): boolean>(z_IsProgramARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsProgramARB(&program: UInt32): boolean;
begin
Result := z_IsProgramARB_ovr_0(&program);
end;
end;
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);
public z_VertexAttrib1fARB_adr := GetFuncAdr('glVertexAttrib1fARB');
public z_VertexAttrib1fARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: single)>(z_VertexAttrib1fARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fARB(index: UInt32; x: single);
begin
z_VertexAttrib1fARB_ovr_0(index, x);
end;
public z_VertexAttrib1sARB_adr := GetFuncAdr('glVertexAttrib1sARB');
public z_VertexAttrib1sARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Int16)>(z_VertexAttrib1sARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1sARB(index: UInt32; x: Int16);
begin
z_VertexAttrib1sARB_ovr_0(index, x);
end;
public z_VertexAttrib1dARB_adr := GetFuncAdr('glVertexAttrib1dARB');
public z_VertexAttrib1dARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: real)>(z_VertexAttrib1dARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dARB(index: UInt32; x: real);
begin
z_VertexAttrib1dARB_ovr_0(index, x);
end;
public z_VertexAttrib2fARB_adr := GetFuncAdr('glVertexAttrib2fARB');
public z_VertexAttrib2fARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: single; y: single)>(z_VertexAttrib2fARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fARB(index: UInt32; x: single; y: single);
begin
z_VertexAttrib2fARB_ovr_0(index, x, y);
end;
public z_VertexAttrib2sARB_adr := GetFuncAdr('glVertexAttrib2sARB');
public z_VertexAttrib2sARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Int16; y: Int16)>(z_VertexAttrib2sARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2sARB(index: UInt32; x: Int16; y: Int16);
begin
z_VertexAttrib2sARB_ovr_0(index, x, y);
end;
public z_VertexAttrib2dARB_adr := GetFuncAdr('glVertexAttrib2dARB');
public z_VertexAttrib2dARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: real; y: real)>(z_VertexAttrib2dARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dARB(index: UInt32; x: real; y: real);
begin
z_VertexAttrib2dARB_ovr_0(index, x, y);
end;
public z_VertexAttrib3fARB_adr := GetFuncAdr('glVertexAttrib3fARB');
public z_VertexAttrib3fARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: single; y: single; z: single)>(z_VertexAttrib3fARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fARB(index: UInt32; x: single; y: single; z: single);
begin
z_VertexAttrib3fARB_ovr_0(index, x, y, z);
end;
public z_VertexAttrib3sARB_adr := GetFuncAdr('glVertexAttrib3sARB');
public z_VertexAttrib3sARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Int16; y: Int16; z: Int16)>(z_VertexAttrib3sARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3sARB(index: UInt32; x: Int16; y: Int16; z: Int16);
begin
z_VertexAttrib3sARB_ovr_0(index, x, y, z);
end;
public z_VertexAttrib3dARB_adr := GetFuncAdr('glVertexAttrib3dARB');
public z_VertexAttrib3dARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: real; y: real; z: real)>(z_VertexAttrib3dARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dARB(index: UInt32; x: real; y: real; z: real);
begin
z_VertexAttrib3dARB_ovr_0(index, x, y, z);
end;
public z_VertexAttrib4fARB_adr := GetFuncAdr('glVertexAttrib4fARB');
public z_VertexAttrib4fARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: single; y: single; z: single; w: single)>(z_VertexAttrib4fARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fARB(index: UInt32; x: single; y: single; z: single; w: single);
begin
z_VertexAttrib4fARB_ovr_0(index, x, y, z, w);
end;
public z_VertexAttrib4sARB_adr := GetFuncAdr('glVertexAttrib4sARB');
public z_VertexAttrib4sARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Int16; y: Int16; z: Int16; w: Int16)>(z_VertexAttrib4sARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4sARB(index: UInt32; x: Int16; y: Int16; z: Int16; w: Int16);
begin
z_VertexAttrib4sARB_ovr_0(index, x, y, z, w);
end;
public z_VertexAttrib4dARB_adr := GetFuncAdr('glVertexAttrib4dARB');
public z_VertexAttrib4dARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: real; y: real; z: real; w: real)>(z_VertexAttrib4dARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dARB(index: UInt32; x: real; y: real; z: real; w: real);
begin
z_VertexAttrib4dARB_ovr_0(index, x, y, z, w);
end;
public z_VertexAttrib4NubARB_adr := GetFuncAdr('glVertexAttrib4NubARB');
public z_VertexAttrib4NubARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Byte; y: Byte; z: Byte; w: Byte)>(z_VertexAttrib4NubARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NubARB(index: UInt32; x: Byte; y: Byte; z: Byte; w: Byte);
begin
z_VertexAttrib4NubARB_ovr_0(index, x, y, z, w);
end;
public z_VertexAttrib1fvARB_adr := GetFuncAdr('glVertexAttrib1fvARB');
public z_VertexAttrib1fvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: single)>(z_VertexAttrib1fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fvARB(index: UInt32; v: array of single);
begin
z_VertexAttrib1fvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fvARB(index: UInt32; var v: single);
begin
z_VertexAttrib1fvARB_ovr_0(index, v);
end;
public z_VertexAttrib1fvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib1fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib1fvARB_ovr_2(index, v);
end;
public z_VertexAttrib1svARB_adr := GetFuncAdr('glVertexAttrib1svARB');
public z_VertexAttrib1svARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int16)>(z_VertexAttrib1svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1svARB(index: UInt32; v: array of Int16);
begin
z_VertexAttrib1svARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1svARB(index: UInt32; var v: Int16);
begin
z_VertexAttrib1svARB_ovr_0(index, v);
end;
public z_VertexAttrib1svARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib1svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1svARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib1svARB_ovr_2(index, v);
end;
public z_VertexAttrib1dvARB_adr := GetFuncAdr('glVertexAttrib1dvARB');
public z_VertexAttrib1dvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttrib1dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dvARB(index: UInt32; v: array of real);
begin
z_VertexAttrib1dvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dvARB(index: UInt32; var v: real);
begin
z_VertexAttrib1dvARB_ovr_0(index, v);
end;
public z_VertexAttrib1dvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib1dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib1dvARB_ovr_2(index, v);
end;
public z_VertexAttrib2fvARB_adr := GetFuncAdr('glVertexAttrib2fvARB');
public z_VertexAttrib2fvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: single)>(z_VertexAttrib2fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fvARB(index: UInt32; v: array of single);
begin
z_VertexAttrib2fvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fvARB(index: UInt32; var v: single);
begin
z_VertexAttrib2fvARB_ovr_0(index, v);
end;
public z_VertexAttrib2fvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib2fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib2fvARB_ovr_2(index, v);
end;
public z_VertexAttrib2svARB_adr := GetFuncAdr('glVertexAttrib2svARB');
public z_VertexAttrib2svARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int16)>(z_VertexAttrib2svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2svARB(index: UInt32; v: array of Int16);
begin
z_VertexAttrib2svARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2svARB(index: UInt32; var v: Int16);
begin
z_VertexAttrib2svARB_ovr_0(index, v);
end;
public z_VertexAttrib2svARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib2svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2svARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib2svARB_ovr_2(index, v);
end;
public z_VertexAttrib2dvARB_adr := GetFuncAdr('glVertexAttrib2dvARB');
public z_VertexAttrib2dvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttrib2dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dvARB(index: UInt32; v: array of real);
begin
z_VertexAttrib2dvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dvARB(index: UInt32; var v: real);
begin
z_VertexAttrib2dvARB_ovr_0(index, v);
end;
public z_VertexAttrib2dvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib2dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib2dvARB_ovr_2(index, v);
end;
public z_VertexAttrib3fvARB_adr := GetFuncAdr('glVertexAttrib3fvARB');
public z_VertexAttrib3fvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: single)>(z_VertexAttrib3fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fvARB(index: UInt32; v: array of single);
begin
z_VertexAttrib3fvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fvARB(index: UInt32; var v: single);
begin
z_VertexAttrib3fvARB_ovr_0(index, v);
end;
public z_VertexAttrib3fvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib3fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib3fvARB_ovr_2(index, v);
end;
public z_VertexAttrib3svARB_adr := GetFuncAdr('glVertexAttrib3svARB');
public z_VertexAttrib3svARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int16)>(z_VertexAttrib3svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3svARB(index: UInt32; v: array of Int16);
begin
z_VertexAttrib3svARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3svARB(index: UInt32; var v: Int16);
begin
z_VertexAttrib3svARB_ovr_0(index, v);
end;
public z_VertexAttrib3svARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib3svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3svARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib3svARB_ovr_2(index, v);
end;
public z_VertexAttrib3dvARB_adr := GetFuncAdr('glVertexAttrib3dvARB');
public z_VertexAttrib3dvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttrib3dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dvARB(index: UInt32; v: array of real);
begin
z_VertexAttrib3dvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dvARB(index: UInt32; var v: real);
begin
z_VertexAttrib3dvARB_ovr_0(index, v);
end;
public z_VertexAttrib3dvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib3dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib3dvARB_ovr_2(index, v);
end;
public z_VertexAttrib4fvARB_adr := GetFuncAdr('glVertexAttrib4fvARB');
public z_VertexAttrib4fvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: single)>(z_VertexAttrib4fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fvARB(index: UInt32; v: array of single);
begin
z_VertexAttrib4fvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fvARB(index: UInt32; var v: single);
begin
z_VertexAttrib4fvARB_ovr_0(index, v);
end;
public z_VertexAttrib4fvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4fvARB_ovr_2(index, v);
end;
public z_VertexAttrib4svARB_adr := GetFuncAdr('glVertexAttrib4svARB');
public z_VertexAttrib4svARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int16)>(z_VertexAttrib4svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4svARB(index: UInt32; v: array of Int16);
begin
z_VertexAttrib4svARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4svARB(index: UInt32; var v: Int16);
begin
z_VertexAttrib4svARB_ovr_0(index, v);
end;
public z_VertexAttrib4svARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4svARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4svARB_ovr_2(index, v);
end;
public z_VertexAttrib4dvARB_adr := GetFuncAdr('glVertexAttrib4dvARB');
public z_VertexAttrib4dvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttrib4dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dvARB(index: UInt32; v: array of real);
begin
z_VertexAttrib4dvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dvARB(index: UInt32; var v: real);
begin
z_VertexAttrib4dvARB_ovr_0(index, v);
end;
public z_VertexAttrib4dvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4dvARB_ovr_2(index, v);
end;
public z_VertexAttrib4ivARB_adr := GetFuncAdr('glVertexAttrib4ivARB');
public z_VertexAttrib4ivARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int32)>(z_VertexAttrib4ivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ivARB(index: UInt32; v: array of Int32);
begin
z_VertexAttrib4ivARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ivARB(index: UInt32; var v: Int32);
begin
z_VertexAttrib4ivARB_ovr_0(index, v);
end;
public z_VertexAttrib4ivARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4ivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ivARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4ivARB_ovr_2(index, v);
end;
public z_VertexAttrib4bvARB_adr := GetFuncAdr('glVertexAttrib4bvARB');
public z_VertexAttrib4bvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: SByte)>(z_VertexAttrib4bvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4bvARB(index: UInt32; v: array of SByte);
begin
z_VertexAttrib4bvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4bvARB(index: UInt32; var v: SByte);
begin
z_VertexAttrib4bvARB_ovr_0(index, v);
end;
public z_VertexAttrib4bvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4bvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4bvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4bvARB_ovr_2(index, v);
end;
public z_VertexAttrib4ubvARB_adr := GetFuncAdr('glVertexAttrib4ubvARB');
public z_VertexAttrib4ubvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Byte)>(z_VertexAttrib4ubvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ubvARB(index: UInt32; v: array of Byte);
begin
z_VertexAttrib4ubvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ubvARB(index: UInt32; var v: Byte);
begin
z_VertexAttrib4ubvARB_ovr_0(index, v);
end;
public z_VertexAttrib4ubvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4ubvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ubvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4ubvARB_ovr_2(index, v);
end;
public z_VertexAttrib4usvARB_adr := GetFuncAdr('glVertexAttrib4usvARB');
public z_VertexAttrib4usvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt16)>(z_VertexAttrib4usvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4usvARB(index: UInt32; v: array of UInt16);
begin
z_VertexAttrib4usvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4usvARB(index: UInt32; var v: UInt16);
begin
z_VertexAttrib4usvARB_ovr_0(index, v);
end;
public z_VertexAttrib4usvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4usvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4usvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4usvARB_ovr_2(index, v);
end;
public z_VertexAttrib4uivARB_adr := GetFuncAdr('glVertexAttrib4uivARB');
public z_VertexAttrib4uivARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt32)>(z_VertexAttrib4uivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4uivARB(index: UInt32; v: array of UInt32);
begin
z_VertexAttrib4uivARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4uivARB(index: UInt32; var v: UInt32);
begin
z_VertexAttrib4uivARB_ovr_0(index, v);
end;
public z_VertexAttrib4uivARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4uivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4uivARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4uivARB_ovr_2(index, v);
end;
public z_VertexAttrib4NbvARB_adr := GetFuncAdr('glVertexAttrib4NbvARB');
public z_VertexAttrib4NbvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: SByte)>(z_VertexAttrib4NbvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NbvARB(index: UInt32; v: array of SByte);
begin
z_VertexAttrib4NbvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NbvARB(index: UInt32; var v: SByte);
begin
z_VertexAttrib4NbvARB_ovr_0(index, v);
end;
public z_VertexAttrib4NbvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4NbvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NbvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4NbvARB_ovr_2(index, v);
end;
public z_VertexAttrib4NsvARB_adr := GetFuncAdr('glVertexAttrib4NsvARB');
public z_VertexAttrib4NsvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int16)>(z_VertexAttrib4NsvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NsvARB(index: UInt32; v: array of Int16);
begin
z_VertexAttrib4NsvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NsvARB(index: UInt32; var v: Int16);
begin
z_VertexAttrib4NsvARB_ovr_0(index, v);
end;
public z_VertexAttrib4NsvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4NsvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NsvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4NsvARB_ovr_2(index, v);
end;
public z_VertexAttrib4NivARB_adr := GetFuncAdr('glVertexAttrib4NivARB');
public z_VertexAttrib4NivARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int32)>(z_VertexAttrib4NivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NivARB(index: UInt32; v: array of Int32);
begin
z_VertexAttrib4NivARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NivARB(index: UInt32; var v: Int32);
begin
z_VertexAttrib4NivARB_ovr_0(index, v);
end;
public z_VertexAttrib4NivARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4NivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NivARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4NivARB_ovr_2(index, v);
end;
public z_VertexAttrib4NubvARB_adr := GetFuncAdr('glVertexAttrib4NubvARB');
public z_VertexAttrib4NubvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Byte)>(z_VertexAttrib4NubvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NubvARB(index: UInt32; v: array of Byte);
begin
z_VertexAttrib4NubvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NubvARB(index: UInt32; var v: Byte);
begin
z_VertexAttrib4NubvARB_ovr_0(index, v);
end;
public z_VertexAttrib4NubvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4NubvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NubvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4NubvARB_ovr_2(index, v);
end;
public z_VertexAttrib4NusvARB_adr := GetFuncAdr('glVertexAttrib4NusvARB');
public z_VertexAttrib4NusvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt16)>(z_VertexAttrib4NusvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NusvARB(index: UInt32; v: array of UInt16);
begin
z_VertexAttrib4NusvARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NusvARB(index: UInt32; var v: UInt16);
begin
z_VertexAttrib4NusvARB_ovr_0(index, v);
end;
public z_VertexAttrib4NusvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4NusvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NusvARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4NusvARB_ovr_2(index, v);
end;
public z_VertexAttrib4NuivARB_adr := GetFuncAdr('glVertexAttrib4NuivARB');
public z_VertexAttrib4NuivARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt32)>(z_VertexAttrib4NuivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NuivARB(index: UInt32; v: array of UInt32);
begin
z_VertexAttrib4NuivARB_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NuivARB(index: UInt32; var v: UInt32);
begin
z_VertexAttrib4NuivARB_ovr_0(index, v);
end;
public z_VertexAttrib4NuivARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4NuivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4NuivARB(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4NuivARB_ovr_2(index, v);
end;
public z_VertexAttribPointerARB_adr := GetFuncAdr('glVertexAttribPointerARB');
public z_VertexAttribPointerARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; size: Int32; &type: VertexAttribPointerType; normalized: boolean; stride: Int32; pointer: IntPtr)>(z_VertexAttribPointerARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribPointerARB(index: UInt32; size: Int32; &type: VertexAttribPointerType; normalized: boolean; stride: Int32; pointer: IntPtr);
begin
z_VertexAttribPointerARB_ovr_0(index, size, &type, normalized, stride, pointer);
end;
public z_EnableVertexAttribArrayARB_adr := GetFuncAdr('glEnableVertexAttribArrayARB');
public z_EnableVertexAttribArrayARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32)>(z_EnableVertexAttribArrayARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EnableVertexAttribArrayARB(index: UInt32);
begin
z_EnableVertexAttribArrayARB_ovr_0(index);
end;
public z_DisableVertexAttribArrayARB_adr := GetFuncAdr('glDisableVertexAttribArrayARB');
public z_DisableVertexAttribArrayARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32)>(z_DisableVertexAttribArrayARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DisableVertexAttribArrayARB(index: UInt32);
begin
z_DisableVertexAttribArrayARB_ovr_0(index);
end;
public z_BindAttribLocationARB_adr := GetFuncAdr('glBindAttribLocationARB');
public z_BindAttribLocationARB_ovr_0 := GetFuncOrNil&<procedure(programObj: GLhandleARB; index: UInt32; name: IntPtr)>(z_BindAttribLocationARB_adr);
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);
begin
z_BindAttribLocationARB_ovr_0(programObj, index, name);
end;
public z_GetActiveAttribARB_adr := GetFuncAdr('glGetActiveAttribARB');
public z_GetActiveAttribARB_ovr_0 := GetFuncOrNil&<procedure(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; var size: Int32; var &type: AttributeType; name: IntPtr)>(z_GetActiveAttribARB_adr);
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);
begin
z_GetActiveAttribARB_ovr_0(programObj, index, maxLength, length[0], size[0], &type[0], name);
end;
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);
begin
z_GetActiveAttribARB_ovr_0(programObj, index, maxLength, length[0], size[0], &type, name);
end;
public z_GetActiveAttribARB_ovr_2 := GetFuncOrNil&<procedure(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetActiveAttribARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; size: array of Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveAttribARB_ovr_2(programObj, index, maxLength, length[0], size[0], &type, name);
end;
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);
begin
z_GetActiveAttribARB_ovr_0(programObj, index, maxLength, length[0], size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; var size: Int32; var &type: AttributeType; name: IntPtr);
begin
z_GetActiveAttribARB_ovr_0(programObj, index, maxLength, length[0], size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; var size: Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveAttribARB_ovr_2(programObj, index, maxLength, length[0], size, &type, name);
end;
public z_GetActiveAttribARB_ovr_6 := GetFuncOrNil&<procedure(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; var &type: AttributeType; name: IntPtr)>(z_GetActiveAttribARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; size: IntPtr; &type: array of AttributeType; name: IntPtr);
begin
z_GetActiveAttribARB_ovr_6(programObj, index, maxLength, length[0], size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; size: IntPtr; var &type: AttributeType; name: IntPtr);
begin
z_GetActiveAttribARB_ovr_6(programObj, index, maxLength, length[0], size, &type, name);
end;
public z_GetActiveAttribARB_ovr_8 := GetFuncOrNil&<procedure(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveAttribARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: array of Int32; size: IntPtr; &type: IntPtr; name: IntPtr);
begin
z_GetActiveAttribARB_ovr_8(programObj, index, maxLength, length[0], size, &type, name);
end;
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);
begin
z_GetActiveAttribARB_ovr_0(programObj, index, maxLength, length, size[0], &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: array of Int32; var &type: AttributeType; name: IntPtr);
begin
z_GetActiveAttribARB_ovr_0(programObj, index, maxLength, length, size[0], &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: array of Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveAttribARB_ovr_2(programObj, index, maxLength, length, size[0], &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; var size: Int32; &type: array of AttributeType; name: IntPtr);
begin
z_GetActiveAttribARB_ovr_0(programObj, index, maxLength, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; var size: Int32; var &type: AttributeType; name: IntPtr);
begin
z_GetActiveAttribARB_ovr_0(programObj, index, maxLength, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveAttribARB_ovr_2(programObj, index, maxLength, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; &type: array of AttributeType; name: IntPtr);
begin
z_GetActiveAttribARB_ovr_6(programObj, index, maxLength, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; var &type: AttributeType; name: IntPtr);
begin
z_GetActiveAttribARB_ovr_6(programObj, index, maxLength, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr);
begin
z_GetActiveAttribARB_ovr_8(programObj, index, maxLength, length, size, &type, name);
end;
public z_GetActiveAttribARB_ovr_18 := GetFuncOrNil&<procedure(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; var &type: AttributeType; name: IntPtr)>(z_GetActiveAttribARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: array of Int32; &type: array of AttributeType; name: IntPtr);
begin
z_GetActiveAttribARB_ovr_18(programObj, index, maxLength, length, size[0], &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: array of Int32; var &type: AttributeType; name: IntPtr);
begin
z_GetActiveAttribARB_ovr_18(programObj, index, maxLength, length, size[0], &type, name);
end;
public z_GetActiveAttribARB_ovr_20 := GetFuncOrNil&<procedure(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetActiveAttribARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: array of Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveAttribARB_ovr_20(programObj, index, maxLength, length, size[0], &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; &type: array of AttributeType; name: IntPtr);
begin
z_GetActiveAttribARB_ovr_18(programObj, index, maxLength, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; var &type: AttributeType; name: IntPtr);
begin
z_GetActiveAttribARB_ovr_18(programObj, index, maxLength, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveAttribARB_ovr_20(programObj, index, maxLength, length, size, &type, name);
end;
public z_GetActiveAttribARB_ovr_24 := GetFuncOrNil&<procedure(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; var &type: AttributeType; name: IntPtr)>(z_GetActiveAttribARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; &type: array of AttributeType; name: IntPtr);
begin
z_GetActiveAttribARB_ovr_24(programObj, index, maxLength, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; var &type: AttributeType; name: IntPtr);
begin
z_GetActiveAttribARB_ovr_24(programObj, index, maxLength, length, size, &type, name);
end;
public z_GetActiveAttribARB_ovr_26 := GetFuncOrNil&<procedure(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveAttribARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveAttribARB(programObj: GLhandleARB; index: UInt32; maxLength: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
begin
z_GetActiveAttribARB_ovr_26(programObj, index, maxLength, length, size, &type, name);
end;
public z_GetAttribLocationARB_adr := GetFuncAdr('glGetAttribLocationARB');
public z_GetAttribLocationARB_ovr_0 := GetFuncOrNil&<function(programObj: GLhandleARB; name: IntPtr): Int32>(z_GetAttribLocationARB_adr);
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;
begin
Result := z_GetAttribLocationARB_ovr_0(programObj, name);
end;
public z_GetVertexAttribdvARB_adr := GetFuncAdr('glGetVertexAttribdvARB');
public z_GetVertexAttribdvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: real)>(z_GetVertexAttribdvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribdvARB(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: array of real);
begin
z_GetVertexAttribdvARB_ovr_0(index, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribdvARB(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: real);
begin
z_GetVertexAttribdvARB_ovr_0(index, pname, ¶ms);
end;
public z_GetVertexAttribdvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr)>(z_GetVertexAttribdvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribdvARB(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr);
begin
z_GetVertexAttribdvARB_ovr_2(index, pname, ¶ms);
end;
public z_GetVertexAttribfvARB_adr := GetFuncAdr('glGetVertexAttribfvARB');
public z_GetVertexAttribfvARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: single)>(z_GetVertexAttribfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribfvARB(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: array of single);
begin
z_GetVertexAttribfvARB_ovr_0(index, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribfvARB(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: single);
begin
z_GetVertexAttribfvARB_ovr_0(index, pname, ¶ms);
end;
public z_GetVertexAttribfvARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr)>(z_GetVertexAttribfvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribfvARB(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr);
begin
z_GetVertexAttribfvARB_ovr_2(index, pname, ¶ms);
end;
public z_GetVertexAttribivARB_adr := GetFuncAdr('glGetVertexAttribivARB');
public z_GetVertexAttribivARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: Int32)>(z_GetVertexAttribivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribivARB(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: array of Int32);
begin
z_GetVertexAttribivARB_ovr_0(index, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribivARB(index: UInt32; pname: VertexAttribPropertyARB; var ¶ms: Int32);
begin
z_GetVertexAttribivARB_ovr_0(index, pname, ¶ms);
end;
public z_GetVertexAttribivARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr)>(z_GetVertexAttribivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribivARB(index: UInt32; pname: VertexAttribPropertyARB; ¶ms: IntPtr);
begin
z_GetVertexAttribivARB_ovr_2(index, pname, ¶ms);
end;
public z_GetVertexAttribPointervARB_adr := GetFuncAdr('glGetVertexAttribPointervARB');
public z_GetVertexAttribPointervARB_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPointerPropertyARB; var _pointer: IntPtr)>(z_GetVertexAttribPointervARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribPointervARB(index: UInt32; pname: VertexAttribPointerPropertyARB; _pointer: array of IntPtr);
begin
z_GetVertexAttribPointervARB_ovr_0(index, pname, _pointer[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribPointervARB(index: UInt32; pname: VertexAttribPointerPropertyARB; var _pointer: IntPtr);
begin
z_GetVertexAttribPointervARB_ovr_0(index, pname, _pointer);
end;
public z_GetVertexAttribPointervARB_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribPointerPropertyARB; _pointer: pointer)>(z_GetVertexAttribPointervARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribPointervARB(index: UInt32; pname: VertexAttribPointerPropertyARB; _pointer: pointer);
begin
z_GetVertexAttribPointervARB_ovr_2(index, pname, _pointer);
end;
end;
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);
end;
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);
end;
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);
public z_WindowPos2dARB_adr := GetFuncAdr('glWindowPos2dARB');
public z_WindowPos2dARB_ovr_0 := GetFuncOrNil&<procedure(x: real; y: real)>(z_WindowPos2dARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2dARB(x: real; y: real);
begin
z_WindowPos2dARB_ovr_0(x, y);
end;
public z_WindowPos2dvARB_adr := GetFuncAdr('glWindowPos2dvARB');
public z_WindowPos2dvARB_ovr_0 := GetFuncOrNil&<procedure(var v: real)>(z_WindowPos2dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2dvARB(v: array of real);
begin
z_WindowPos2dvARB_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2dvARB(var v: real);
begin
z_WindowPos2dvARB_ovr_0(v);
end;
public z_WindowPos2dvARB_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos2dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2dvARB(v: IntPtr);
begin
z_WindowPos2dvARB_ovr_2(v);
end;
public z_WindowPos2fARB_adr := GetFuncAdr('glWindowPos2fARB');
public z_WindowPos2fARB_ovr_0 := GetFuncOrNil&<procedure(x: single; y: single)>(z_WindowPos2fARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2fARB(x: single; y: single);
begin
z_WindowPos2fARB_ovr_0(x, y);
end;
public z_WindowPos2fvARB_adr := GetFuncAdr('glWindowPos2fvARB');
public z_WindowPos2fvARB_ovr_0 := GetFuncOrNil&<procedure(var v: single)>(z_WindowPos2fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2fvARB(v: array of single);
begin
z_WindowPos2fvARB_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2fvARB(var v: single);
begin
z_WindowPos2fvARB_ovr_0(v);
end;
public z_WindowPos2fvARB_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos2fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2fvARB(v: IntPtr);
begin
z_WindowPos2fvARB_ovr_2(v);
end;
public z_WindowPos2iARB_adr := GetFuncAdr('glWindowPos2iARB');
public z_WindowPos2iARB_ovr_0 := GetFuncOrNil&<procedure(x: Int32; y: Int32)>(z_WindowPos2iARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2iARB(x: Int32; y: Int32);
begin
z_WindowPos2iARB_ovr_0(x, y);
end;
public z_WindowPos2ivARB_adr := GetFuncAdr('glWindowPos2ivARB');
public z_WindowPos2ivARB_ovr_0 := GetFuncOrNil&<procedure(var v: Int32)>(z_WindowPos2ivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2ivARB(v: array of Int32);
begin
z_WindowPos2ivARB_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2ivARB(var v: Int32);
begin
z_WindowPos2ivARB_ovr_0(v);
end;
public z_WindowPos2ivARB_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos2ivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2ivARB(v: IntPtr);
begin
z_WindowPos2ivARB_ovr_2(v);
end;
public z_WindowPos2sARB_adr := GetFuncAdr('glWindowPos2sARB');
public z_WindowPos2sARB_ovr_0 := GetFuncOrNil&<procedure(x: Int16; y: Int16)>(z_WindowPos2sARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2sARB(x: Int16; y: Int16);
begin
z_WindowPos2sARB_ovr_0(x, y);
end;
public z_WindowPos2svARB_adr := GetFuncAdr('glWindowPos2svARB');
public z_WindowPos2svARB_ovr_0 := GetFuncOrNil&<procedure(var v: Int16)>(z_WindowPos2svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2svARB(v: array of Int16);
begin
z_WindowPos2svARB_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2svARB(var v: Int16);
begin
z_WindowPos2svARB_ovr_0(v);
end;
public z_WindowPos2svARB_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos2svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2svARB(v: IntPtr);
begin
z_WindowPos2svARB_ovr_2(v);
end;
public z_WindowPos3dARB_adr := GetFuncAdr('glWindowPos3dARB');
public z_WindowPos3dARB_ovr_0 := GetFuncOrNil&<procedure(x: real; y: real; z: real)>(z_WindowPos3dARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3dARB(x: real; y: real; z: real);
begin
z_WindowPos3dARB_ovr_0(x, y, z);
end;
public z_WindowPos3dvARB_adr := GetFuncAdr('glWindowPos3dvARB');
public z_WindowPos3dvARB_ovr_0 := GetFuncOrNil&<procedure(var v: real)>(z_WindowPos3dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3dvARB(v: array of real);
begin
z_WindowPos3dvARB_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3dvARB(var v: real);
begin
z_WindowPos3dvARB_ovr_0(v);
end;
public z_WindowPos3dvARB_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos3dvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3dvARB(v: IntPtr);
begin
z_WindowPos3dvARB_ovr_2(v);
end;
public z_WindowPos3fARB_adr := GetFuncAdr('glWindowPos3fARB');
public z_WindowPos3fARB_ovr_0 := GetFuncOrNil&<procedure(x: single; y: single; z: single)>(z_WindowPos3fARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3fARB(x: single; y: single; z: single);
begin
z_WindowPos3fARB_ovr_0(x, y, z);
end;
public z_WindowPos3fvARB_adr := GetFuncAdr('glWindowPos3fvARB');
public z_WindowPos3fvARB_ovr_0 := GetFuncOrNil&<procedure(var v: single)>(z_WindowPos3fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3fvARB(v: array of single);
begin
z_WindowPos3fvARB_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3fvARB(var v: single);
begin
z_WindowPos3fvARB_ovr_0(v);
end;
public z_WindowPos3fvARB_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos3fvARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3fvARB(v: IntPtr);
begin
z_WindowPos3fvARB_ovr_2(v);
end;
public z_WindowPos3iARB_adr := GetFuncAdr('glWindowPos3iARB');
public z_WindowPos3iARB_ovr_0 := GetFuncOrNil&<procedure(x: Int32; y: Int32; z: Int32)>(z_WindowPos3iARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3iARB(x: Int32; y: Int32; z: Int32);
begin
z_WindowPos3iARB_ovr_0(x, y, z);
end;
public z_WindowPos3ivARB_adr := GetFuncAdr('glWindowPos3ivARB');
public z_WindowPos3ivARB_ovr_0 := GetFuncOrNil&<procedure(var v: Int32)>(z_WindowPos3ivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3ivARB(v: array of Int32);
begin
z_WindowPos3ivARB_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3ivARB(var v: Int32);
begin
z_WindowPos3ivARB_ovr_0(v);
end;
public z_WindowPos3ivARB_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos3ivARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3ivARB(v: IntPtr);
begin
z_WindowPos3ivARB_ovr_2(v);
end;
public z_WindowPos3sARB_adr := GetFuncAdr('glWindowPos3sARB');
public z_WindowPos3sARB_ovr_0 := GetFuncOrNil&<procedure(x: Int16; y: Int16; z: Int16)>(z_WindowPos3sARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3sARB(x: Int16; y: Int16; z: Int16);
begin
z_WindowPos3sARB_ovr_0(x, y, z);
end;
public z_WindowPos3svARB_adr := GetFuncAdr('glWindowPos3svARB');
public z_WindowPos3svARB_ovr_0 := GetFuncOrNil&<procedure(var v: Int16)>(z_WindowPos3svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3svARB(v: array of Int16);
begin
z_WindowPos3svARB_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3svARB(var v: Int16);
begin
z_WindowPos3svARB_ovr_0(v);
end;
public z_WindowPos3svARB_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos3svARB_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3svARB(v: IntPtr);
begin
z_WindowPos3svARB_ovr_2(v);
end;
end;
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);
public z_DrawBuffersATI_adr := GetFuncAdr('glDrawBuffersATI');
public z_DrawBuffersATI_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var bufs: DrawBufferMode)>(z_DrawBuffersATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawBuffersATI(n: Int32; bufs: array of DrawBufferMode);
begin
z_DrawBuffersATI_ovr_0(n, bufs[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawBuffersATI(n: Int32; var bufs: DrawBufferMode);
begin
z_DrawBuffersATI_ovr_0(n, bufs);
end;
public z_DrawBuffersATI_ovr_2 := GetFuncOrNil&<procedure(n: Int32; bufs: IntPtr)>(z_DrawBuffersATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawBuffersATI(n: Int32; bufs: IntPtr);
begin
z_DrawBuffersATI_ovr_2(n, bufs);
end;
end;
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);
public z_ElementPointerATI_adr := GetFuncAdr('glElementPointerATI');
public z_ElementPointerATI_ovr_0 := GetFuncOrNil&<procedure(&type: ElementPointerTypeATI; pointer: IntPtr)>(z_ElementPointerATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ElementPointerATI(&type: ElementPointerTypeATI; pointer: IntPtr);
begin
z_ElementPointerATI_ovr_0(&type, pointer);
end;
public z_DrawElementArrayATI_adr := GetFuncAdr('glDrawElementArrayATI');
public z_DrawElementArrayATI_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: Int32)>(z_DrawElementArrayATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawElementArrayATI(mode: PrimitiveType; count: Int32);
begin
z_DrawElementArrayATI_ovr_0(mode, count);
end;
public z_DrawRangeElementArrayATI_adr := GetFuncAdr('glDrawRangeElementArrayATI');
public z_DrawRangeElementArrayATI_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; start: UInt32; &end: UInt32; count: Int32)>(z_DrawRangeElementArrayATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawRangeElementArrayATI(mode: PrimitiveType; start: UInt32; &end: UInt32; count: Int32);
begin
z_DrawRangeElementArrayATI_ovr_0(mode, start, &end, count);
end;
end;
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);
public z_TexBumpParameterivATI_adr := GetFuncAdr('glTexBumpParameterivATI');
public z_TexBumpParameterivATI_ovr_0 := GetFuncOrNil&<procedure(pname: DummyEnum; var param: Int32)>(z_TexBumpParameterivATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexBumpParameterivATI(pname: DummyEnum; param: array of Int32);
begin
z_TexBumpParameterivATI_ovr_0(pname, param[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexBumpParameterivATI(pname: DummyEnum; var param: Int32);
begin
z_TexBumpParameterivATI_ovr_0(pname, param);
end;
public z_TexBumpParameterivATI_ovr_2 := GetFuncOrNil&<procedure(pname: DummyEnum; param: IntPtr)>(z_TexBumpParameterivATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexBumpParameterivATI(pname: DummyEnum; param: IntPtr);
begin
z_TexBumpParameterivATI_ovr_2(pname, param);
end;
public z_TexBumpParameterfvATI_adr := GetFuncAdr('glTexBumpParameterfvATI');
public z_TexBumpParameterfvATI_ovr_0 := GetFuncOrNil&<procedure(pname: DummyEnum; var param: single)>(z_TexBumpParameterfvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexBumpParameterfvATI(pname: DummyEnum; param: array of single);
begin
z_TexBumpParameterfvATI_ovr_0(pname, param[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexBumpParameterfvATI(pname: DummyEnum; var param: single);
begin
z_TexBumpParameterfvATI_ovr_0(pname, param);
end;
public z_TexBumpParameterfvATI_ovr_2 := GetFuncOrNil&<procedure(pname: DummyEnum; param: IntPtr)>(z_TexBumpParameterfvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexBumpParameterfvATI(pname: DummyEnum; param: IntPtr);
begin
z_TexBumpParameterfvATI_ovr_2(pname, param);
end;
public z_GetTexBumpParameterivATI_adr := GetFuncAdr('glGetTexBumpParameterivATI');
public z_GetTexBumpParameterivATI_ovr_0 := GetFuncOrNil&<procedure(pname: GetTexBumpParameterATI; var param: Int32)>(z_GetTexBumpParameterivATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexBumpParameterivATI(pname: GetTexBumpParameterATI; param: array of Int32);
begin
z_GetTexBumpParameterivATI_ovr_0(pname, param[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexBumpParameterivATI(pname: GetTexBumpParameterATI; var param: Int32);
begin
z_GetTexBumpParameterivATI_ovr_0(pname, param);
end;
public z_GetTexBumpParameterivATI_ovr_2 := GetFuncOrNil&<procedure(pname: GetTexBumpParameterATI; param: IntPtr)>(z_GetTexBumpParameterivATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexBumpParameterivATI(pname: GetTexBumpParameterATI; param: IntPtr);
begin
z_GetTexBumpParameterivATI_ovr_2(pname, param);
end;
public z_GetTexBumpParameterfvATI_adr := GetFuncAdr('glGetTexBumpParameterfvATI');
public z_GetTexBumpParameterfvATI_ovr_0 := GetFuncOrNil&<procedure(pname: GetTexBumpParameterATI; var param: single)>(z_GetTexBumpParameterfvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexBumpParameterfvATI(pname: GetTexBumpParameterATI; param: array of single);
begin
z_GetTexBumpParameterfvATI_ovr_0(pname, param[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexBumpParameterfvATI(pname: GetTexBumpParameterATI; var param: single);
begin
z_GetTexBumpParameterfvATI_ovr_0(pname, param);
end;
public z_GetTexBumpParameterfvATI_ovr_2 := GetFuncOrNil&<procedure(pname: GetTexBumpParameterATI; param: IntPtr)>(z_GetTexBumpParameterfvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexBumpParameterfvATI(pname: GetTexBumpParameterATI; param: IntPtr);
begin
z_GetTexBumpParameterfvATI_ovr_2(pname, param);
end;
end;
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);
public z_GenFragmentShadersATI_adr := GetFuncAdr('glGenFragmentShadersATI');
public z_GenFragmentShadersATI_ovr_0 := GetFuncOrNil&<function(range: UInt32): UInt32>(z_GenFragmentShadersATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GenFragmentShadersATI(range: UInt32): UInt32;
begin
Result := z_GenFragmentShadersATI_ovr_0(range);
end;
public z_BindFragmentShaderATI_adr := GetFuncAdr('glBindFragmentShaderATI');
public z_BindFragmentShaderATI_ovr_0 := GetFuncOrNil&<procedure(id: UInt32)>(z_BindFragmentShaderATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindFragmentShaderATI(id: UInt32);
begin
z_BindFragmentShaderATI_ovr_0(id);
end;
public z_DeleteFragmentShaderATI_adr := GetFuncAdr('glDeleteFragmentShaderATI');
public z_DeleteFragmentShaderATI_ovr_0 := GetFuncOrNil&<procedure(id: UInt32)>(z_DeleteFragmentShaderATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFragmentShaderATI(id: UInt32);
begin
z_DeleteFragmentShaderATI_ovr_0(id);
end;
public z_BeginFragmentShaderATI_adr := GetFuncAdr('glBeginFragmentShaderATI');
public z_BeginFragmentShaderATI_ovr_0 := GetFuncOrNil&<procedure>(z_BeginFragmentShaderATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginFragmentShaderATI;
begin
z_BeginFragmentShaderATI_ovr_0;
end;
public z_EndFragmentShaderATI_adr := GetFuncAdr('glEndFragmentShaderATI');
public z_EndFragmentShaderATI_ovr_0 := GetFuncOrNil&<procedure>(z_EndFragmentShaderATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndFragmentShaderATI;
begin
z_EndFragmentShaderATI_ovr_0;
end;
public z_PassTexCoordATI_adr := GetFuncAdr('glPassTexCoordATI');
public z_PassTexCoordATI_ovr_0 := GetFuncOrNil&<procedure(dst: UInt32; coord: UInt32; swizzle: SwizzleOpATI)>(z_PassTexCoordATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PassTexCoordATI(dst: UInt32; coord: UInt32; swizzle: SwizzleOpATI);
begin
z_PassTexCoordATI_ovr_0(dst, coord, swizzle);
end;
public z_SampleMapATI_adr := GetFuncAdr('glSampleMapATI');
public z_SampleMapATI_ovr_0 := GetFuncOrNil&<procedure(dst: UInt32; interp: UInt32; swizzle: SwizzleOpATI)>(z_SampleMapATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SampleMapATI(dst: UInt32; interp: UInt32; swizzle: SwizzleOpATI);
begin
z_SampleMapATI_ovr_0(dst, interp, swizzle);
end;
public z_ColorFragmentOp1ATI_adr := GetFuncAdr('glColorFragmentOp1ATI');
public z_ColorFragmentOp1ATI_ovr_0 := GetFuncOrNil&<procedure(op: FragmentOpATI; dst: UInt32; dstMask: UInt32; dstMod: UInt32; arg1: UInt32; arg1Rep: UInt32; arg1Mod: UInt32)>(z_ColorFragmentOp1ATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorFragmentOp1ATI(op: FragmentOpATI; dst: UInt32; dstMask: UInt32; dstMod: UInt32; arg1: UInt32; arg1Rep: UInt32; arg1Mod: UInt32);
begin
z_ColorFragmentOp1ATI_ovr_0(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod);
end;
public z_ColorFragmentOp2ATI_adr := GetFuncAdr('glColorFragmentOp2ATI');
public z_ColorFragmentOp2ATI_ovr_0 := GetFuncOrNil&<procedure(op: FragmentOpATI; dst: UInt32; dstMask: UInt32; dstMod: UInt32; arg1: UInt32; arg1Rep: UInt32; arg1Mod: UInt32; arg2: UInt32; arg2Rep: UInt32; arg2Mod: UInt32)>(z_ColorFragmentOp2ATI_adr);
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);
begin
z_ColorFragmentOp2ATI_ovr_0(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
end;
public z_ColorFragmentOp3ATI_adr := GetFuncAdr('glColorFragmentOp3ATI');
public z_ColorFragmentOp3ATI_ovr_0 := GetFuncOrNil&<procedure(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_adr);
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);
begin
z_ColorFragmentOp3ATI_ovr_0(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
end;
public z_AlphaFragmentOp1ATI_adr := GetFuncAdr('glAlphaFragmentOp1ATI');
public z_AlphaFragmentOp1ATI_ovr_0 := GetFuncOrNil&<procedure(op: FragmentOpATI; dst: UInt32; dstMod: UInt32; arg1: UInt32; arg1Rep: UInt32; arg1Mod: UInt32)>(z_AlphaFragmentOp1ATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure AlphaFragmentOp1ATI(op: FragmentOpATI; dst: UInt32; dstMod: UInt32; arg1: UInt32; arg1Rep: UInt32; arg1Mod: UInt32);
begin
z_AlphaFragmentOp1ATI_ovr_0(op, dst, dstMod, arg1, arg1Rep, arg1Mod);
end;
public z_AlphaFragmentOp2ATI_adr := GetFuncAdr('glAlphaFragmentOp2ATI');
public z_AlphaFragmentOp2ATI_ovr_0 := GetFuncOrNil&<procedure(op: FragmentOpATI; dst: UInt32; dstMod: UInt32; arg1: UInt32; arg1Rep: UInt32; arg1Mod: UInt32; arg2: UInt32; arg2Rep: UInt32; arg2Mod: UInt32)>(z_AlphaFragmentOp2ATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure AlphaFragmentOp2ATI(op: FragmentOpATI; dst: UInt32; dstMod: UInt32; arg1: UInt32; arg1Rep: UInt32; arg1Mod: UInt32; arg2: UInt32; arg2Rep: UInt32; arg2Mod: UInt32);
begin
z_AlphaFragmentOp2ATI_ovr_0(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
end;
public z_AlphaFragmentOp3ATI_adr := GetFuncAdr('glAlphaFragmentOp3ATI');
public z_AlphaFragmentOp3ATI_ovr_0 := GetFuncOrNil&<procedure(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_adr);
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);
begin
z_AlphaFragmentOp3ATI_ovr_0(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
end;
public z_SetFragmentShaderConstantATI_adr := GetFuncAdr('glSetFragmentShaderConstantATI');
public z_SetFragmentShaderConstantATI_ovr_0 := GetFuncOrNil&<procedure(dst: UInt32; var value: single)>(z_SetFragmentShaderConstantATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SetFragmentShaderConstantATI(dst: UInt32; value: array of single);
begin
z_SetFragmentShaderConstantATI_ovr_0(dst, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SetFragmentShaderConstantATI(dst: UInt32; var value: single);
begin
z_SetFragmentShaderConstantATI_ovr_0(dst, value);
end;
public z_SetFragmentShaderConstantATI_ovr_2 := GetFuncOrNil&<procedure(dst: UInt32; value: IntPtr)>(z_SetFragmentShaderConstantATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SetFragmentShaderConstantATI(dst: UInt32; value: IntPtr);
begin
z_SetFragmentShaderConstantATI_ovr_2(dst, value);
end;
end;
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);
public z_MapObjectBufferATI_adr := GetFuncAdr('glMapObjectBufferATI');
public z_MapObjectBufferATI_ovr_0 := GetFuncOrNil&<function(buffer: UInt32): IntPtr>(z_MapObjectBufferATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapObjectBufferATI(buffer: UInt32): IntPtr;
begin
Result := z_MapObjectBufferATI_ovr_0(buffer);
end;
public z_UnmapObjectBufferATI_adr := GetFuncAdr('glUnmapObjectBufferATI');
public z_UnmapObjectBufferATI_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32)>(z_UnmapObjectBufferATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UnmapObjectBufferATI(buffer: UInt32);
begin
z_UnmapObjectBufferATI_ovr_0(buffer);
end;
end;
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);
public z_PNTrianglesiATI_adr := GetFuncAdr('glPNTrianglesiATI');
public z_PNTrianglesiATI_ovr_0 := GetFuncOrNil&<procedure(pname: PNTrianglesPNameATI; param: Int32)>(z_PNTrianglesiATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PNTrianglesiATI(pname: PNTrianglesPNameATI; param: Int32);
begin
z_PNTrianglesiATI_ovr_0(pname, param);
end;
public z_PNTrianglesfATI_adr := GetFuncAdr('glPNTrianglesfATI');
public z_PNTrianglesfATI_ovr_0 := GetFuncOrNil&<procedure(pname: PNTrianglesPNameATI; param: single)>(z_PNTrianglesfATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PNTrianglesfATI(pname: PNTrianglesPNameATI; param: single);
begin
z_PNTrianglesfATI_ovr_0(pname, param);
end;
end;
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);
public z_StencilOpSeparateATI_adr := GetFuncAdr('glStencilOpSeparateATI');
public z_StencilOpSeparateATI_ovr_0 := GetFuncOrNil&<procedure(face: StencilFaceDirection; sfail: StencilOp; dpfail: StencilOp; dppass: StencilOp)>(z_StencilOpSeparateATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilOpSeparateATI(face: StencilFaceDirection; sfail: StencilOp; dpfail: StencilOp; dppass: StencilOp);
begin
z_StencilOpSeparateATI_ovr_0(face, sfail, dpfail, dppass);
end;
public z_StencilFuncSeparateATI_adr := GetFuncAdr('glStencilFuncSeparateATI');
public z_StencilFuncSeparateATI_ovr_0 := GetFuncOrNil&<procedure(frontfunc: StencilFunction; backfunc: StencilFunction; ref: Int32; mask: UInt32)>(z_StencilFuncSeparateATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilFuncSeparateATI(frontfunc: StencilFunction; backfunc: StencilFunction; ref: Int32; mask: UInt32);
begin
z_StencilFuncSeparateATI_ovr_0(frontfunc, backfunc, ref, mask);
end;
end;
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);
public z_NewObjectBufferATI_adr := GetFuncAdr('glNewObjectBufferATI');
public z_NewObjectBufferATI_ovr_0 := GetFuncOrNil&<function(size: Int32; pointer: IntPtr; usage: ArrayObjectUsageATI): UInt32>(z_NewObjectBufferATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function NewObjectBufferATI(size: Int32; pointer: IntPtr; usage: ArrayObjectUsageATI): UInt32;
begin
Result := z_NewObjectBufferATI_ovr_0(size, pointer, usage);
end;
public z_IsObjectBufferATI_adr := GetFuncAdr('glIsObjectBufferATI');
public z_IsObjectBufferATI_ovr_0 := GetFuncOrNil&<function(buffer: UInt32): boolean>(z_IsObjectBufferATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsObjectBufferATI(buffer: UInt32): boolean;
begin
Result := z_IsObjectBufferATI_ovr_0(buffer);
end;
public z_UpdateObjectBufferATI_adr := GetFuncAdr('glUpdateObjectBufferATI');
public z_UpdateObjectBufferATI_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; offset: UInt32; size: Int32; pointer: IntPtr; preserve: PreserveModeATI)>(z_UpdateObjectBufferATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UpdateObjectBufferATI(buffer: UInt32; offset: UInt32; size: Int32; pointer: IntPtr; preserve: PreserveModeATI);
begin
z_UpdateObjectBufferATI_ovr_0(buffer, offset, size, pointer, preserve);
end;
public z_GetObjectBufferfvATI_adr := GetFuncAdr('glGetObjectBufferfvATI');
public z_GetObjectBufferfvATI_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; pname: ArrayObjectPNameATI; var ¶ms: single)>(z_GetObjectBufferfvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectBufferfvATI(buffer: UInt32; pname: ArrayObjectPNameATI; ¶ms: array of single);
begin
z_GetObjectBufferfvATI_ovr_0(buffer, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectBufferfvATI(buffer: UInt32; pname: ArrayObjectPNameATI; var ¶ms: single);
begin
z_GetObjectBufferfvATI_ovr_0(buffer, pname, ¶ms);
end;
public z_GetObjectBufferfvATI_ovr_2 := GetFuncOrNil&<procedure(buffer: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr)>(z_GetObjectBufferfvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectBufferfvATI(buffer: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr);
begin
z_GetObjectBufferfvATI_ovr_2(buffer, pname, ¶ms);
end;
public z_GetObjectBufferivATI_adr := GetFuncAdr('glGetObjectBufferivATI');
public z_GetObjectBufferivATI_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; pname: ArrayObjectPNameATI; var ¶ms: Int32)>(z_GetObjectBufferivATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectBufferivATI(buffer: UInt32; pname: ArrayObjectPNameATI; ¶ms: array of Int32);
begin
z_GetObjectBufferivATI_ovr_0(buffer, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectBufferivATI(buffer: UInt32; pname: ArrayObjectPNameATI; var ¶ms: Int32);
begin
z_GetObjectBufferivATI_ovr_0(buffer, pname, ¶ms);
end;
public z_GetObjectBufferivATI_ovr_2 := GetFuncOrNil&<procedure(buffer: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr)>(z_GetObjectBufferivATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectBufferivATI(buffer: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr);
begin
z_GetObjectBufferivATI_ovr_2(buffer, pname, ¶ms);
end;
public z_FreeObjectBufferATI_adr := GetFuncAdr('glFreeObjectBufferATI');
public z_FreeObjectBufferATI_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32)>(z_FreeObjectBufferATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FreeObjectBufferATI(buffer: UInt32);
begin
z_FreeObjectBufferATI_ovr_0(buffer);
end;
public z_ArrayObjectATI_adr := GetFuncAdr('glArrayObjectATI');
public z_ArrayObjectATI_ovr_0 := GetFuncOrNil&<procedure(&array: EnableCap; size: Int32; &type: ScalarType; stride: Int32; buffer: UInt32; offset: UInt32)>(z_ArrayObjectATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ArrayObjectATI(&array: EnableCap; size: Int32; &type: ScalarType; stride: Int32; buffer: UInt32; offset: UInt32);
begin
z_ArrayObjectATI_ovr_0(&array, size, &type, stride, buffer, offset);
end;
public z_GetArrayObjectfvATI_adr := GetFuncAdr('glGetArrayObjectfvATI');
public z_GetArrayObjectfvATI_ovr_0 := GetFuncOrNil&<procedure(&array: EnableCap; pname: ArrayObjectPNameATI; var ¶ms: single)>(z_GetArrayObjectfvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetArrayObjectfvATI(&array: EnableCap; pname: ArrayObjectPNameATI; ¶ms: array of single);
begin
z_GetArrayObjectfvATI_ovr_0(&array, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetArrayObjectfvATI(&array: EnableCap; pname: ArrayObjectPNameATI; var ¶ms: single);
begin
z_GetArrayObjectfvATI_ovr_0(&array, pname, ¶ms);
end;
public z_GetArrayObjectfvATI_ovr_2 := GetFuncOrNil&<procedure(&array: EnableCap; pname: ArrayObjectPNameATI; ¶ms: IntPtr)>(z_GetArrayObjectfvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetArrayObjectfvATI(&array: EnableCap; pname: ArrayObjectPNameATI; ¶ms: IntPtr);
begin
z_GetArrayObjectfvATI_ovr_2(&array, pname, ¶ms);
end;
public z_GetArrayObjectivATI_adr := GetFuncAdr('glGetArrayObjectivATI');
public z_GetArrayObjectivATI_ovr_0 := GetFuncOrNil&<procedure(&array: EnableCap; pname: ArrayObjectPNameATI; var ¶ms: Int32)>(z_GetArrayObjectivATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetArrayObjectivATI(&array: EnableCap; pname: ArrayObjectPNameATI; ¶ms: array of Int32);
begin
z_GetArrayObjectivATI_ovr_0(&array, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetArrayObjectivATI(&array: EnableCap; pname: ArrayObjectPNameATI; var ¶ms: Int32);
begin
z_GetArrayObjectivATI_ovr_0(&array, pname, ¶ms);
end;
public z_GetArrayObjectivATI_ovr_2 := GetFuncOrNil&<procedure(&array: EnableCap; pname: ArrayObjectPNameATI; ¶ms: IntPtr)>(z_GetArrayObjectivATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetArrayObjectivATI(&array: EnableCap; pname: ArrayObjectPNameATI; ¶ms: IntPtr);
begin
z_GetArrayObjectivATI_ovr_2(&array, pname, ¶ms);
end;
public z_VariantArrayObjectATI_adr := GetFuncAdr('glVariantArrayObjectATI');
public z_VariantArrayObjectATI_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; &type: ScalarType; stride: Int32; buffer: UInt32; offset: UInt32)>(z_VariantArrayObjectATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantArrayObjectATI(id: UInt32; &type: ScalarType; stride: Int32; buffer: UInt32; offset: UInt32);
begin
z_VariantArrayObjectATI_ovr_0(id, &type, stride, buffer, offset);
end;
public z_GetVariantArrayObjectfvATI_adr := GetFuncAdr('glGetVariantArrayObjectfvATI');
public z_GetVariantArrayObjectfvATI_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; pname: ArrayObjectPNameATI; var ¶ms: single)>(z_GetVariantArrayObjectfvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantArrayObjectfvATI(id: UInt32; pname: ArrayObjectPNameATI; ¶ms: array of single);
begin
z_GetVariantArrayObjectfvATI_ovr_0(id, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantArrayObjectfvATI(id: UInt32; pname: ArrayObjectPNameATI; var ¶ms: single);
begin
z_GetVariantArrayObjectfvATI_ovr_0(id, pname, ¶ms);
end;
public z_GetVariantArrayObjectfvATI_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr)>(z_GetVariantArrayObjectfvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantArrayObjectfvATI(id: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr);
begin
z_GetVariantArrayObjectfvATI_ovr_2(id, pname, ¶ms);
end;
public z_GetVariantArrayObjectivATI_adr := GetFuncAdr('glGetVariantArrayObjectivATI');
public z_GetVariantArrayObjectivATI_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; pname: ArrayObjectPNameATI; var ¶ms: Int32)>(z_GetVariantArrayObjectivATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantArrayObjectivATI(id: UInt32; pname: ArrayObjectPNameATI; ¶ms: array of Int32);
begin
z_GetVariantArrayObjectivATI_ovr_0(id, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantArrayObjectivATI(id: UInt32; pname: ArrayObjectPNameATI; var ¶ms: Int32);
begin
z_GetVariantArrayObjectivATI_ovr_0(id, pname, ¶ms);
end;
public z_GetVariantArrayObjectivATI_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr)>(z_GetVariantArrayObjectivATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantArrayObjectivATI(id: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr);
begin
z_GetVariantArrayObjectivATI_ovr_2(id, pname, ¶ms);
end;
end;
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);
public z_VertexAttribArrayObjectATI_adr := GetFuncAdr('glVertexAttribArrayObjectATI');
public z_VertexAttribArrayObjectATI_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; size: Int32; &type: VertexAttribPointerType; normalized: boolean; stride: Int32; buffer: UInt32; offset: UInt32)>(z_VertexAttribArrayObjectATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribArrayObjectATI(index: UInt32; size: Int32; &type: VertexAttribPointerType; normalized: boolean; stride: Int32; buffer: UInt32; offset: UInt32);
begin
z_VertexAttribArrayObjectATI_ovr_0(index, size, &type, normalized, stride, buffer, offset);
end;
public z_GetVertexAttribArrayObjectfvATI_adr := GetFuncAdr('glGetVertexAttribArrayObjectfvATI');
public z_GetVertexAttribArrayObjectfvATI_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: ArrayObjectPNameATI; var ¶ms: single)>(z_GetVertexAttribArrayObjectfvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribArrayObjectfvATI(index: UInt32; pname: ArrayObjectPNameATI; ¶ms: array of single);
begin
z_GetVertexAttribArrayObjectfvATI_ovr_0(index, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribArrayObjectfvATI(index: UInt32; pname: ArrayObjectPNameATI; var ¶ms: single);
begin
z_GetVertexAttribArrayObjectfvATI_ovr_0(index, pname, ¶ms);
end;
public z_GetVertexAttribArrayObjectfvATI_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr)>(z_GetVertexAttribArrayObjectfvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribArrayObjectfvATI(index: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr);
begin
z_GetVertexAttribArrayObjectfvATI_ovr_2(index, pname, ¶ms);
end;
public z_GetVertexAttribArrayObjectivATI_adr := GetFuncAdr('glGetVertexAttribArrayObjectivATI');
public z_GetVertexAttribArrayObjectivATI_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: ArrayObjectPNameATI; var ¶ms: Int32)>(z_GetVertexAttribArrayObjectivATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribArrayObjectivATI(index: UInt32; pname: ArrayObjectPNameATI; ¶ms: array of Int32);
begin
z_GetVertexAttribArrayObjectivATI_ovr_0(index, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribArrayObjectivATI(index: UInt32; pname: ArrayObjectPNameATI; var ¶ms: Int32);
begin
z_GetVertexAttribArrayObjectivATI_ovr_0(index, pname, ¶ms);
end;
public z_GetVertexAttribArrayObjectivATI_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr)>(z_GetVertexAttribArrayObjectivATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribArrayObjectivATI(index: UInt32; pname: ArrayObjectPNameATI; ¶ms: IntPtr);
begin
z_GetVertexAttribArrayObjectivATI_ovr_2(index, pname, ¶ms);
end;
end;
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);
public z_VertexStream1sATI_adr := GetFuncAdr('glVertexStream1sATI');
public z_VertexStream1sATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; x: Int16)>(z_VertexStream1sATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1sATI(stream: VertexStreamATI; x: Int16);
begin
z_VertexStream1sATI_ovr_0(stream, x);
end;
public z_VertexStream1svATI_adr := GetFuncAdr('glVertexStream1svATI');
public z_VertexStream1svATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; var coords: Int16)>(z_VertexStream1svATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1svATI(stream: VertexStreamATI; coords: array of Int16);
begin
z_VertexStream1svATI_ovr_0(stream, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1svATI(stream: VertexStreamATI; var coords: Int16);
begin
z_VertexStream1svATI_ovr_0(stream, coords);
end;
public z_VertexStream1svATI_ovr_2 := GetFuncOrNil&<procedure(stream: VertexStreamATI; coords: IntPtr)>(z_VertexStream1svATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1svATI(stream: VertexStreamATI; coords: IntPtr);
begin
z_VertexStream1svATI_ovr_2(stream, coords);
end;
public z_VertexStream1iATI_adr := GetFuncAdr('glVertexStream1iATI');
public z_VertexStream1iATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; x: Int32)>(z_VertexStream1iATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1iATI(stream: VertexStreamATI; x: Int32);
begin
z_VertexStream1iATI_ovr_0(stream, x);
end;
public z_VertexStream1ivATI_adr := GetFuncAdr('glVertexStream1ivATI');
public z_VertexStream1ivATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; var coords: Int32)>(z_VertexStream1ivATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1ivATI(stream: VertexStreamATI; coords: array of Int32);
begin
z_VertexStream1ivATI_ovr_0(stream, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1ivATI(stream: VertexStreamATI; var coords: Int32);
begin
z_VertexStream1ivATI_ovr_0(stream, coords);
end;
public z_VertexStream1ivATI_ovr_2 := GetFuncOrNil&<procedure(stream: VertexStreamATI; coords: IntPtr)>(z_VertexStream1ivATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1ivATI(stream: VertexStreamATI; coords: IntPtr);
begin
z_VertexStream1ivATI_ovr_2(stream, coords);
end;
public z_VertexStream1fATI_adr := GetFuncAdr('glVertexStream1fATI');
public z_VertexStream1fATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; x: single)>(z_VertexStream1fATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1fATI(stream: VertexStreamATI; x: single);
begin
z_VertexStream1fATI_ovr_0(stream, x);
end;
public z_VertexStream1fvATI_adr := GetFuncAdr('glVertexStream1fvATI');
public z_VertexStream1fvATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; var coords: single)>(z_VertexStream1fvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1fvATI(stream: VertexStreamATI; coords: array of single);
begin
z_VertexStream1fvATI_ovr_0(stream, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1fvATI(stream: VertexStreamATI; var coords: single);
begin
z_VertexStream1fvATI_ovr_0(stream, coords);
end;
public z_VertexStream1fvATI_ovr_2 := GetFuncOrNil&<procedure(stream: VertexStreamATI; coords: IntPtr)>(z_VertexStream1fvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1fvATI(stream: VertexStreamATI; coords: IntPtr);
begin
z_VertexStream1fvATI_ovr_2(stream, coords);
end;
public z_VertexStream1dATI_adr := GetFuncAdr('glVertexStream1dATI');
public z_VertexStream1dATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; x: real)>(z_VertexStream1dATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1dATI(stream: VertexStreamATI; x: real);
begin
z_VertexStream1dATI_ovr_0(stream, x);
end;
public z_VertexStream1dvATI_adr := GetFuncAdr('glVertexStream1dvATI');
public z_VertexStream1dvATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; var coords: real)>(z_VertexStream1dvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1dvATI(stream: VertexStreamATI; coords: array of real);
begin
z_VertexStream1dvATI_ovr_0(stream, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1dvATI(stream: VertexStreamATI; var coords: real);
begin
z_VertexStream1dvATI_ovr_0(stream, coords);
end;
public z_VertexStream1dvATI_ovr_2 := GetFuncOrNil&<procedure(stream: VertexStreamATI; coords: IntPtr)>(z_VertexStream1dvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream1dvATI(stream: VertexStreamATI; coords: IntPtr);
begin
z_VertexStream1dvATI_ovr_2(stream, coords);
end;
public z_VertexStream2sATI_adr := GetFuncAdr('glVertexStream2sATI');
public z_VertexStream2sATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; x: Int16; y: Int16)>(z_VertexStream2sATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2sATI(stream: VertexStreamATI; x: Int16; y: Int16);
begin
z_VertexStream2sATI_ovr_0(stream, x, y);
end;
public z_VertexStream2svATI_adr := GetFuncAdr('glVertexStream2svATI');
public z_VertexStream2svATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; var coords: Int16)>(z_VertexStream2svATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2svATI(stream: VertexStreamATI; coords: array of Int16);
begin
z_VertexStream2svATI_ovr_0(stream, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2svATI(stream: VertexStreamATI; var coords: Int16);
begin
z_VertexStream2svATI_ovr_0(stream, coords);
end;
public z_VertexStream2svATI_ovr_2 := GetFuncOrNil&<procedure(stream: VertexStreamATI; coords: IntPtr)>(z_VertexStream2svATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2svATI(stream: VertexStreamATI; coords: IntPtr);
begin
z_VertexStream2svATI_ovr_2(stream, coords);
end;
public z_VertexStream2iATI_adr := GetFuncAdr('glVertexStream2iATI');
public z_VertexStream2iATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; x: Int32; y: Int32)>(z_VertexStream2iATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2iATI(stream: VertexStreamATI; x: Int32; y: Int32);
begin
z_VertexStream2iATI_ovr_0(stream, x, y);
end;
public z_VertexStream2ivATI_adr := GetFuncAdr('glVertexStream2ivATI');
public z_VertexStream2ivATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; var coords: Int32)>(z_VertexStream2ivATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2ivATI(stream: VertexStreamATI; coords: array of Int32);
begin
z_VertexStream2ivATI_ovr_0(stream, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2ivATI(stream: VertexStreamATI; var coords: Int32);
begin
z_VertexStream2ivATI_ovr_0(stream, coords);
end;
public z_VertexStream2ivATI_ovr_2 := GetFuncOrNil&<procedure(stream: VertexStreamATI; coords: IntPtr)>(z_VertexStream2ivATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2ivATI(stream: VertexStreamATI; coords: IntPtr);
begin
z_VertexStream2ivATI_ovr_2(stream, coords);
end;
public z_VertexStream2fATI_adr := GetFuncAdr('glVertexStream2fATI');
public z_VertexStream2fATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; x: single; y: single)>(z_VertexStream2fATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2fATI(stream: VertexStreamATI; x: single; y: single);
begin
z_VertexStream2fATI_ovr_0(stream, x, y);
end;
public z_VertexStream2fvATI_adr := GetFuncAdr('glVertexStream2fvATI');
public z_VertexStream2fvATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; var coords: single)>(z_VertexStream2fvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2fvATI(stream: VertexStreamATI; coords: array of single);
begin
z_VertexStream2fvATI_ovr_0(stream, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2fvATI(stream: VertexStreamATI; var coords: single);
begin
z_VertexStream2fvATI_ovr_0(stream, coords);
end;
public z_VertexStream2fvATI_ovr_2 := GetFuncOrNil&<procedure(stream: VertexStreamATI; coords: IntPtr)>(z_VertexStream2fvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2fvATI(stream: VertexStreamATI; coords: IntPtr);
begin
z_VertexStream2fvATI_ovr_2(stream, coords);
end;
public z_VertexStream2dATI_adr := GetFuncAdr('glVertexStream2dATI');
public z_VertexStream2dATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; x: real; y: real)>(z_VertexStream2dATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2dATI(stream: VertexStreamATI; x: real; y: real);
begin
z_VertexStream2dATI_ovr_0(stream, x, y);
end;
public z_VertexStream2dvATI_adr := GetFuncAdr('glVertexStream2dvATI');
public z_VertexStream2dvATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; var coords: real)>(z_VertexStream2dvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2dvATI(stream: VertexStreamATI; coords: array of real);
begin
z_VertexStream2dvATI_ovr_0(stream, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2dvATI(stream: VertexStreamATI; var coords: real);
begin
z_VertexStream2dvATI_ovr_0(stream, coords);
end;
public z_VertexStream2dvATI_ovr_2 := GetFuncOrNil&<procedure(stream: VertexStreamATI; coords: IntPtr)>(z_VertexStream2dvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream2dvATI(stream: VertexStreamATI; coords: IntPtr);
begin
z_VertexStream2dvATI_ovr_2(stream, coords);
end;
public z_VertexStream3sATI_adr := GetFuncAdr('glVertexStream3sATI');
public z_VertexStream3sATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; x: Int16; y: Int16; z: Int16)>(z_VertexStream3sATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3sATI(stream: VertexStreamATI; x: Int16; y: Int16; z: Int16);
begin
z_VertexStream3sATI_ovr_0(stream, x, y, z);
end;
public z_VertexStream3svATI_adr := GetFuncAdr('glVertexStream3svATI');
public z_VertexStream3svATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; var coords: Int16)>(z_VertexStream3svATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3svATI(stream: VertexStreamATI; coords: array of Int16);
begin
z_VertexStream3svATI_ovr_0(stream, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3svATI(stream: VertexStreamATI; var coords: Int16);
begin
z_VertexStream3svATI_ovr_0(stream, coords);
end;
public z_VertexStream3svATI_ovr_2 := GetFuncOrNil&<procedure(stream: VertexStreamATI; coords: IntPtr)>(z_VertexStream3svATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3svATI(stream: VertexStreamATI; coords: IntPtr);
begin
z_VertexStream3svATI_ovr_2(stream, coords);
end;
public z_VertexStream3iATI_adr := GetFuncAdr('glVertexStream3iATI');
public z_VertexStream3iATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; x: Int32; y: Int32; z: Int32)>(z_VertexStream3iATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3iATI(stream: VertexStreamATI; x: Int32; y: Int32; z: Int32);
begin
z_VertexStream3iATI_ovr_0(stream, x, y, z);
end;
public z_VertexStream3ivATI_adr := GetFuncAdr('glVertexStream3ivATI');
public z_VertexStream3ivATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; var coords: Int32)>(z_VertexStream3ivATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3ivATI(stream: VertexStreamATI; coords: array of Int32);
begin
z_VertexStream3ivATI_ovr_0(stream, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3ivATI(stream: VertexStreamATI; var coords: Int32);
begin
z_VertexStream3ivATI_ovr_0(stream, coords);
end;
public z_VertexStream3ivATI_ovr_2 := GetFuncOrNil&<procedure(stream: VertexStreamATI; coords: IntPtr)>(z_VertexStream3ivATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3ivATI(stream: VertexStreamATI; coords: IntPtr);
begin
z_VertexStream3ivATI_ovr_2(stream, coords);
end;
public z_VertexStream3fATI_adr := GetFuncAdr('glVertexStream3fATI');
public z_VertexStream3fATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; x: single; y: single; z: single)>(z_VertexStream3fATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3fATI(stream: VertexStreamATI; x: single; y: single; z: single);
begin
z_VertexStream3fATI_ovr_0(stream, x, y, z);
end;
public z_VertexStream3fvATI_adr := GetFuncAdr('glVertexStream3fvATI');
public z_VertexStream3fvATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; var coords: single)>(z_VertexStream3fvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3fvATI(stream: VertexStreamATI; coords: array of single);
begin
z_VertexStream3fvATI_ovr_0(stream, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3fvATI(stream: VertexStreamATI; var coords: single);
begin
z_VertexStream3fvATI_ovr_0(stream, coords);
end;
public z_VertexStream3fvATI_ovr_2 := GetFuncOrNil&<procedure(stream: VertexStreamATI; coords: IntPtr)>(z_VertexStream3fvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3fvATI(stream: VertexStreamATI; coords: IntPtr);
begin
z_VertexStream3fvATI_ovr_2(stream, coords);
end;
public z_VertexStream3dATI_adr := GetFuncAdr('glVertexStream3dATI');
public z_VertexStream3dATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; x: real; y: real; z: real)>(z_VertexStream3dATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3dATI(stream: VertexStreamATI; x: real; y: real; z: real);
begin
z_VertexStream3dATI_ovr_0(stream, x, y, z);
end;
public z_VertexStream3dvATI_adr := GetFuncAdr('glVertexStream3dvATI');
public z_VertexStream3dvATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; var coords: real)>(z_VertexStream3dvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3dvATI(stream: VertexStreamATI; coords: array of real);
begin
z_VertexStream3dvATI_ovr_0(stream, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3dvATI(stream: VertexStreamATI; var coords: real);
begin
z_VertexStream3dvATI_ovr_0(stream, coords);
end;
public z_VertexStream3dvATI_ovr_2 := GetFuncOrNil&<procedure(stream: VertexStreamATI; coords: IntPtr)>(z_VertexStream3dvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream3dvATI(stream: VertexStreamATI; coords: IntPtr);
begin
z_VertexStream3dvATI_ovr_2(stream, coords);
end;
public z_VertexStream4sATI_adr := GetFuncAdr('glVertexStream4sATI');
public z_VertexStream4sATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; x: Int16; y: Int16; z: Int16; w: Int16)>(z_VertexStream4sATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4sATI(stream: VertexStreamATI; x: Int16; y: Int16; z: Int16; w: Int16);
begin
z_VertexStream4sATI_ovr_0(stream, x, y, z, w);
end;
public z_VertexStream4svATI_adr := GetFuncAdr('glVertexStream4svATI');
public z_VertexStream4svATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; var coords: Int16)>(z_VertexStream4svATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4svATI(stream: VertexStreamATI; coords: array of Int16);
begin
z_VertexStream4svATI_ovr_0(stream, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4svATI(stream: VertexStreamATI; var coords: Int16);
begin
z_VertexStream4svATI_ovr_0(stream, coords);
end;
public z_VertexStream4svATI_ovr_2 := GetFuncOrNil&<procedure(stream: VertexStreamATI; coords: IntPtr)>(z_VertexStream4svATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4svATI(stream: VertexStreamATI; coords: IntPtr);
begin
z_VertexStream4svATI_ovr_2(stream, coords);
end;
public z_VertexStream4iATI_adr := GetFuncAdr('glVertexStream4iATI');
public z_VertexStream4iATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; x: Int32; y: Int32; z: Int32; w: Int32)>(z_VertexStream4iATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4iATI(stream: VertexStreamATI; x: Int32; y: Int32; z: Int32; w: Int32);
begin
z_VertexStream4iATI_ovr_0(stream, x, y, z, w);
end;
public z_VertexStream4ivATI_adr := GetFuncAdr('glVertexStream4ivATI');
public z_VertexStream4ivATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; var coords: Int32)>(z_VertexStream4ivATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4ivATI(stream: VertexStreamATI; coords: array of Int32);
begin
z_VertexStream4ivATI_ovr_0(stream, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4ivATI(stream: VertexStreamATI; var coords: Int32);
begin
z_VertexStream4ivATI_ovr_0(stream, coords);
end;
public z_VertexStream4ivATI_ovr_2 := GetFuncOrNil&<procedure(stream: VertexStreamATI; coords: IntPtr)>(z_VertexStream4ivATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4ivATI(stream: VertexStreamATI; coords: IntPtr);
begin
z_VertexStream4ivATI_ovr_2(stream, coords);
end;
public z_VertexStream4fATI_adr := GetFuncAdr('glVertexStream4fATI');
public z_VertexStream4fATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; x: single; y: single; z: single; w: single)>(z_VertexStream4fATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4fATI(stream: VertexStreamATI; x: single; y: single; z: single; w: single);
begin
z_VertexStream4fATI_ovr_0(stream, x, y, z, w);
end;
public z_VertexStream4fvATI_adr := GetFuncAdr('glVertexStream4fvATI');
public z_VertexStream4fvATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; var coords: single)>(z_VertexStream4fvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4fvATI(stream: VertexStreamATI; coords: array of single);
begin
z_VertexStream4fvATI_ovr_0(stream, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4fvATI(stream: VertexStreamATI; var coords: single);
begin
z_VertexStream4fvATI_ovr_0(stream, coords);
end;
public z_VertexStream4fvATI_ovr_2 := GetFuncOrNil&<procedure(stream: VertexStreamATI; coords: IntPtr)>(z_VertexStream4fvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4fvATI(stream: VertexStreamATI; coords: IntPtr);
begin
z_VertexStream4fvATI_ovr_2(stream, coords);
end;
public z_VertexStream4dATI_adr := GetFuncAdr('glVertexStream4dATI');
public z_VertexStream4dATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; x: real; y: real; z: real; w: real)>(z_VertexStream4dATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4dATI(stream: VertexStreamATI; x: real; y: real; z: real; w: real);
begin
z_VertexStream4dATI_ovr_0(stream, x, y, z, w);
end;
public z_VertexStream4dvATI_adr := GetFuncAdr('glVertexStream4dvATI');
public z_VertexStream4dvATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; var coords: real)>(z_VertexStream4dvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4dvATI(stream: VertexStreamATI; coords: array of real);
begin
z_VertexStream4dvATI_ovr_0(stream, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4dvATI(stream: VertexStreamATI; var coords: real);
begin
z_VertexStream4dvATI_ovr_0(stream, coords);
end;
public z_VertexStream4dvATI_ovr_2 := GetFuncOrNil&<procedure(stream: VertexStreamATI; coords: IntPtr)>(z_VertexStream4dvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexStream4dvATI(stream: VertexStreamATI; coords: IntPtr);
begin
z_VertexStream4dvATI_ovr_2(stream, coords);
end;
public z_NormalStream3bATI_adr := GetFuncAdr('glNormalStream3bATI');
public z_NormalStream3bATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; nx: SByte; ny: SByte; nz: SByte)>(z_NormalStream3bATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3bATI(stream: VertexStreamATI; nx: SByte; ny: SByte; nz: SByte);
begin
z_NormalStream3bATI_ovr_0(stream, nx, ny, nz);
end;
public z_NormalStream3bvATI_adr := GetFuncAdr('glNormalStream3bvATI');
public z_NormalStream3bvATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; var coords: SByte)>(z_NormalStream3bvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3bvATI(stream: VertexStreamATI; coords: array of SByte);
begin
z_NormalStream3bvATI_ovr_0(stream, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3bvATI(stream: VertexStreamATI; var coords: SByte);
begin
z_NormalStream3bvATI_ovr_0(stream, coords);
end;
public z_NormalStream3bvATI_ovr_2 := GetFuncOrNil&<procedure(stream: VertexStreamATI; coords: IntPtr)>(z_NormalStream3bvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3bvATI(stream: VertexStreamATI; coords: IntPtr);
begin
z_NormalStream3bvATI_ovr_2(stream, coords);
end;
public z_NormalStream3sATI_adr := GetFuncAdr('glNormalStream3sATI');
public z_NormalStream3sATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; nx: Int16; ny: Int16; nz: Int16)>(z_NormalStream3sATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3sATI(stream: VertexStreamATI; nx: Int16; ny: Int16; nz: Int16);
begin
z_NormalStream3sATI_ovr_0(stream, nx, ny, nz);
end;
public z_NormalStream3svATI_adr := GetFuncAdr('glNormalStream3svATI');
public z_NormalStream3svATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; var coords: Int16)>(z_NormalStream3svATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3svATI(stream: VertexStreamATI; coords: array of Int16);
begin
z_NormalStream3svATI_ovr_0(stream, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3svATI(stream: VertexStreamATI; var coords: Int16);
begin
z_NormalStream3svATI_ovr_0(stream, coords);
end;
public z_NormalStream3svATI_ovr_2 := GetFuncOrNil&<procedure(stream: VertexStreamATI; coords: IntPtr)>(z_NormalStream3svATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3svATI(stream: VertexStreamATI; coords: IntPtr);
begin
z_NormalStream3svATI_ovr_2(stream, coords);
end;
public z_NormalStream3iATI_adr := GetFuncAdr('glNormalStream3iATI');
public z_NormalStream3iATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; nx: Int32; ny: Int32; nz: Int32)>(z_NormalStream3iATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3iATI(stream: VertexStreamATI; nx: Int32; ny: Int32; nz: Int32);
begin
z_NormalStream3iATI_ovr_0(stream, nx, ny, nz);
end;
public z_NormalStream3ivATI_adr := GetFuncAdr('glNormalStream3ivATI');
public z_NormalStream3ivATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; var coords: Int32)>(z_NormalStream3ivATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3ivATI(stream: VertexStreamATI; coords: array of Int32);
begin
z_NormalStream3ivATI_ovr_0(stream, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3ivATI(stream: VertexStreamATI; var coords: Int32);
begin
z_NormalStream3ivATI_ovr_0(stream, coords);
end;
public z_NormalStream3ivATI_ovr_2 := GetFuncOrNil&<procedure(stream: VertexStreamATI; coords: IntPtr)>(z_NormalStream3ivATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3ivATI(stream: VertexStreamATI; coords: IntPtr);
begin
z_NormalStream3ivATI_ovr_2(stream, coords);
end;
public z_NormalStream3fATI_adr := GetFuncAdr('glNormalStream3fATI');
public z_NormalStream3fATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; nx: single; ny: single; nz: single)>(z_NormalStream3fATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3fATI(stream: VertexStreamATI; nx: single; ny: single; nz: single);
begin
z_NormalStream3fATI_ovr_0(stream, nx, ny, nz);
end;
public z_NormalStream3fvATI_adr := GetFuncAdr('glNormalStream3fvATI');
public z_NormalStream3fvATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; var coords: single)>(z_NormalStream3fvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3fvATI(stream: VertexStreamATI; coords: array of single);
begin
z_NormalStream3fvATI_ovr_0(stream, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3fvATI(stream: VertexStreamATI; var coords: single);
begin
z_NormalStream3fvATI_ovr_0(stream, coords);
end;
public z_NormalStream3fvATI_ovr_2 := GetFuncOrNil&<procedure(stream: VertexStreamATI; coords: IntPtr)>(z_NormalStream3fvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3fvATI(stream: VertexStreamATI; coords: IntPtr);
begin
z_NormalStream3fvATI_ovr_2(stream, coords);
end;
public z_NormalStream3dATI_adr := GetFuncAdr('glNormalStream3dATI');
public z_NormalStream3dATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; nx: real; ny: real; nz: real)>(z_NormalStream3dATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3dATI(stream: VertexStreamATI; nx: real; ny: real; nz: real);
begin
z_NormalStream3dATI_ovr_0(stream, nx, ny, nz);
end;
public z_NormalStream3dvATI_adr := GetFuncAdr('glNormalStream3dvATI');
public z_NormalStream3dvATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI; var coords: real)>(z_NormalStream3dvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3dvATI(stream: VertexStreamATI; coords: array of real);
begin
z_NormalStream3dvATI_ovr_0(stream, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3dvATI(stream: VertexStreamATI; var coords: real);
begin
z_NormalStream3dvATI_ovr_0(stream, coords);
end;
public z_NormalStream3dvATI_ovr_2 := GetFuncOrNil&<procedure(stream: VertexStreamATI; coords: IntPtr)>(z_NormalStream3dvATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalStream3dvATI(stream: VertexStreamATI; coords: IntPtr);
begin
z_NormalStream3dvATI_ovr_2(stream, coords);
end;
public z_ClientActiveVertexStreamATI_adr := GetFuncAdr('glClientActiveVertexStreamATI');
public z_ClientActiveVertexStreamATI_ovr_0 := GetFuncOrNil&<procedure(stream: VertexStreamATI)>(z_ClientActiveVertexStreamATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClientActiveVertexStreamATI(stream: VertexStreamATI);
begin
z_ClientActiveVertexStreamATI_ovr_0(stream);
end;
public z_VertexBlendEnviATI_adr := GetFuncAdr('glVertexBlendEnviATI');
public z_VertexBlendEnviATI_ovr_0 := GetFuncOrNil&<procedure(pname: VertexStreamATI; param: Int32)>(z_VertexBlendEnviATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexBlendEnviATI(pname: VertexStreamATI; param: Int32);
begin
z_VertexBlendEnviATI_ovr_0(pname, param);
end;
public z_VertexBlendEnvfATI_adr := GetFuncAdr('glVertexBlendEnvfATI');
public z_VertexBlendEnvfATI_ovr_0 := GetFuncOrNil&<procedure(pname: VertexStreamATI; param: single)>(z_VertexBlendEnvfATI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexBlendEnvfATI(pname: VertexStreamATI; param: single);
begin
z_VertexBlendEnvfATI_ovr_0(pname, param);
end;
end;
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);
public z_EGLImageTargetTexStorageEXT_adr := GetFuncAdr('glEGLImageTargetTexStorageEXT');
public z_EGLImageTargetTexStorageEXT_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; image: GLeglImageOES; var attrib_list: Int32)>(z_EGLImageTargetTexStorageEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EGLImageTargetTexStorageEXT(target: DummyEnum; image: GLeglImageOES; attrib_list: array of Int32);
begin
z_EGLImageTargetTexStorageEXT_ovr_0(target, image, attrib_list[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EGLImageTargetTexStorageEXT(target: DummyEnum; image: GLeglImageOES; var attrib_list: Int32);
begin
z_EGLImageTargetTexStorageEXT_ovr_0(target, image, attrib_list);
end;
public z_EGLImageTargetTexStorageEXT_ovr_2 := GetFuncOrNil&<procedure(target: DummyEnum; image: GLeglImageOES; attrib_list: IntPtr)>(z_EGLImageTargetTexStorageEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EGLImageTargetTexStorageEXT(target: DummyEnum; image: GLeglImageOES; attrib_list: IntPtr);
begin
z_EGLImageTargetTexStorageEXT_ovr_2(target, image, attrib_list);
end;
public z_EGLImageTargetTextureStorageEXT_adr := GetFuncAdr('glEGLImageTargetTextureStorageEXT');
public z_EGLImageTargetTextureStorageEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; image: GLeglImageOES; var attrib_list: Int32)>(z_EGLImageTargetTextureStorageEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EGLImageTargetTextureStorageEXT(texture: UInt32; image: GLeglImageOES; attrib_list: array of Int32);
begin
z_EGLImageTargetTextureStorageEXT_ovr_0(texture, image, attrib_list[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EGLImageTargetTextureStorageEXT(texture: UInt32; image: GLeglImageOES; var attrib_list: Int32);
begin
z_EGLImageTargetTextureStorageEXT_ovr_0(texture, image, attrib_list);
end;
public z_EGLImageTargetTextureStorageEXT_ovr_2 := GetFuncOrNil&<procedure(texture: UInt32; image: GLeglImageOES; attrib_list: IntPtr)>(z_EGLImageTargetTextureStorageEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EGLImageTargetTextureStorageEXT(texture: UInt32; image: GLeglImageOES; attrib_list: IntPtr);
begin
z_EGLImageTargetTextureStorageEXT_ovr_2(texture, image, attrib_list);
end;
end;
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);
public z_UniformBufferEXT_adr := GetFuncAdr('glUniformBufferEXT');
public z_UniformBufferEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; buffer: UInt32)>(z_UniformBufferEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformBufferEXT(&program: UInt32; location: Int32; buffer: UInt32);
begin
z_UniformBufferEXT_ovr_0(&program, location, buffer);
end;
public z_GetUniformBufferSizeEXT_adr := GetFuncAdr('glGetUniformBufferSizeEXT');
public z_GetUniformBufferSizeEXT_ovr_0 := GetFuncOrNil&<function(&program: UInt32; location: Int32): Int32>(z_GetUniformBufferSizeEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetUniformBufferSizeEXT(&program: UInt32; location: Int32): Int32;
begin
Result := z_GetUniformBufferSizeEXT_ovr_0(&program, location);
end;
public z_GetUniformOffsetEXT_adr := GetFuncAdr('glGetUniformOffsetEXT');
public z_GetUniformOffsetEXT_ovr_0 := GetFuncOrNil&<function(&program: UInt32; location: Int32): IntPtr>(z_GetUniformOffsetEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetUniformOffsetEXT(&program: UInt32; location: Int32): IntPtr;
begin
Result := z_GetUniformOffsetEXT_ovr_0(&program, location);
end;
end;
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);
public z_BlendColorEXT_adr := GetFuncAdr('glBlendColorEXT');
public z_BlendColorEXT_ovr_0 := GetFuncOrNil&<procedure(red: single; green: single; blue: single; alpha: single)>(z_BlendColorEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendColorEXT(red: single; green: single; blue: single; alpha: single);
begin
z_BlendColorEXT_ovr_0(red, green, blue, alpha);
end;
end;
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);
public z_BlendEquationSeparateEXT_adr := GetFuncAdr('glBlendEquationSeparateEXT');
public z_BlendEquationSeparateEXT_ovr_0 := GetFuncOrNil&<procedure(modeRGB: BlendEquationModeEXT; modeAlpha: BlendEquationModeEXT)>(z_BlendEquationSeparateEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendEquationSeparateEXT(modeRGB: BlendEquationModeEXT; modeAlpha: BlendEquationModeEXT);
begin
z_BlendEquationSeparateEXT_ovr_0(modeRGB, modeAlpha);
end;
end;
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);
public z_BlendFuncSeparateEXT_adr := GetFuncAdr('glBlendFuncSeparateEXT');
public z_BlendFuncSeparateEXT_ovr_0 := GetFuncOrNil&<procedure(sfactorRGB: BlendingFactor; dfactorRGB: BlendingFactor; sfactorAlpha: BlendingFactor; dfactorAlpha: BlendingFactor)>(z_BlendFuncSeparateEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendFuncSeparateEXT(sfactorRGB: BlendingFactor; dfactorRGB: BlendingFactor; sfactorAlpha: BlendingFactor; dfactorAlpha: BlendingFactor);
begin
z_BlendFuncSeparateEXT_ovr_0(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
end;
end;
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);
public z_BlendEquationEXT_adr := GetFuncAdr('glBlendEquationEXT');
public z_BlendEquationEXT_ovr_0 := GetFuncOrNil&<procedure(mode: BlendEquationModeEXT)>(z_BlendEquationEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendEquationEXT(mode: BlendEquationModeEXT);
begin
z_BlendEquationEXT_ovr_0(mode);
end;
end;
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);
public z_ColorSubTableEXT_adr := GetFuncAdr('glColorSubTableEXT');
public z_ColorSubTableEXT_ovr_0 := GetFuncOrNil&<procedure(target: ColorTableTarget; start: Int32; count: Int32; format: PixelFormat; &type: PixelType; data: IntPtr)>(z_ColorSubTableEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorSubTableEXT(target: ColorTableTarget; start: Int32; count: Int32; format: PixelFormat; &type: PixelType; data: IntPtr);
begin
z_ColorSubTableEXT_ovr_0(target, start, count, format, &type, data);
end;
public z_CopyColorSubTableEXT_adr := GetFuncAdr('glCopyColorSubTableEXT');
public z_CopyColorSubTableEXT_ovr_0 := GetFuncOrNil&<procedure(target: ColorTableTarget; start: Int32; x: Int32; y: Int32; width: Int32)>(z_CopyColorSubTableEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyColorSubTableEXT(target: ColorTableTarget; start: Int32; x: Int32; y: Int32; width: Int32);
begin
z_CopyColorSubTableEXT_ovr_0(target, start, x, y, width);
end;
end;
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);
public z_LockArraysEXT_adr := GetFuncAdr('glLockArraysEXT');
public z_LockArraysEXT_ovr_0 := GetFuncOrNil&<procedure(first: Int32; count: Int32)>(z_LockArraysEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LockArraysEXT(first: Int32; count: Int32);
begin
z_LockArraysEXT_ovr_0(first, count);
end;
public z_UnlockArraysEXT_adr := GetFuncAdr('glUnlockArraysEXT');
public z_UnlockArraysEXT_ovr_0 := GetFuncOrNil&<procedure>(z_UnlockArraysEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UnlockArraysEXT;
begin
z_UnlockArraysEXT_ovr_0;
end;
end;
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);
public z_ConvolutionFilter1DEXT_adr := GetFuncAdr('glConvolutionFilter1DEXT');
public z_ConvolutionFilter1DEXT_ovr_0 := GetFuncOrNil&<procedure(target: ConvolutionTargetEXT; _internalformat: InternalFormat; width: Int32; format: PixelFormat; &type: PixelType; image: IntPtr)>(z_ConvolutionFilter1DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionFilter1DEXT(target: ConvolutionTargetEXT; _internalformat: InternalFormat; width: Int32; format: PixelFormat; &type: PixelType; image: IntPtr);
begin
z_ConvolutionFilter1DEXT_ovr_0(target, _internalformat, width, format, &type, image);
end;
public z_ConvolutionFilter2DEXT_adr := GetFuncAdr('glConvolutionFilter2DEXT');
public z_ConvolutionFilter2DEXT_ovr_0 := GetFuncOrNil&<procedure(target: ConvolutionTargetEXT; _internalformat: InternalFormat; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; image: IntPtr)>(z_ConvolutionFilter2DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionFilter2DEXT(target: ConvolutionTargetEXT; _internalformat: InternalFormat; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; image: IntPtr);
begin
z_ConvolutionFilter2DEXT_ovr_0(target, _internalformat, width, height, format, &type, image);
end;
public z_ConvolutionParameterfEXT_adr := GetFuncAdr('glConvolutionParameterfEXT');
public z_ConvolutionParameterfEXT_ovr_0 := GetFuncOrNil&<procedure(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: single)>(z_ConvolutionParameterfEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameterfEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: single);
begin
z_ConvolutionParameterfEXT_ovr_0(target, pname, ¶ms);
end;
public z_ConvolutionParameterfvEXT_adr := GetFuncAdr('glConvolutionParameterfvEXT');
public z_ConvolutionParameterfvEXT_ovr_0 := GetFuncOrNil&<procedure(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; var ¶ms: single)>(z_ConvolutionParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameterfvEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: array of single);
begin
z_ConvolutionParameterfvEXT_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameterfvEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; var ¶ms: single);
begin
z_ConvolutionParameterfvEXT_ovr_0(target, pname, ¶ms);
end;
public z_ConvolutionParameterfvEXT_ovr_2 := GetFuncOrNil&<procedure(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: IntPtr)>(z_ConvolutionParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameterfvEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: IntPtr);
begin
z_ConvolutionParameterfvEXT_ovr_2(target, pname, ¶ms);
end;
public z_ConvolutionParameteriEXT_adr := GetFuncAdr('glConvolutionParameteriEXT');
public z_ConvolutionParameteriEXT_ovr_0 := GetFuncOrNil&<procedure(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: Int32)>(z_ConvolutionParameteriEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameteriEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: Int32);
begin
z_ConvolutionParameteriEXT_ovr_0(target, pname, ¶ms);
end;
public z_ConvolutionParameterivEXT_adr := GetFuncAdr('glConvolutionParameterivEXT');
public z_ConvolutionParameterivEXT_ovr_0 := GetFuncOrNil&<procedure(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; var ¶ms: Int32)>(z_ConvolutionParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameterivEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: array of Int32);
begin
z_ConvolutionParameterivEXT_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameterivEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; var ¶ms: Int32);
begin
z_ConvolutionParameterivEXT_ovr_0(target, pname, ¶ms);
end;
public z_ConvolutionParameterivEXT_ovr_2 := GetFuncOrNil&<procedure(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: IntPtr)>(z_ConvolutionParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameterivEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: IntPtr);
begin
z_ConvolutionParameterivEXT_ovr_2(target, pname, ¶ms);
end;
public z_CopyConvolutionFilter1DEXT_adr := GetFuncAdr('glCopyConvolutionFilter1DEXT');
public z_CopyConvolutionFilter1DEXT_ovr_0 := GetFuncOrNil&<procedure(target: ConvolutionTargetEXT; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32)>(z_CopyConvolutionFilter1DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyConvolutionFilter1DEXT(target: ConvolutionTargetEXT; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32);
begin
z_CopyConvolutionFilter1DEXT_ovr_0(target, _internalformat, x, y, width);
end;
public z_CopyConvolutionFilter2DEXT_adr := GetFuncAdr('glCopyConvolutionFilter2DEXT');
public z_CopyConvolutionFilter2DEXT_ovr_0 := GetFuncOrNil&<procedure(target: ConvolutionTargetEXT; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; height: Int32)>(z_CopyConvolutionFilter2DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyConvolutionFilter2DEXT(target: ConvolutionTargetEXT; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; height: Int32);
begin
z_CopyConvolutionFilter2DEXT_ovr_0(target, _internalformat, x, y, width, height);
end;
public z_GetConvolutionFilterEXT_adr := GetFuncAdr('glGetConvolutionFilterEXT');
public z_GetConvolutionFilterEXT_ovr_0 := GetFuncOrNil&<procedure(target: ConvolutionTargetEXT; format: PixelFormat; &type: PixelType; image: IntPtr)>(z_GetConvolutionFilterEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetConvolutionFilterEXT(target: ConvolutionTargetEXT; format: PixelFormat; &type: PixelType; image: IntPtr);
begin
z_GetConvolutionFilterEXT_ovr_0(target, format, &type, image);
end;
public z_GetConvolutionParameterfvEXT_adr := GetFuncAdr('glGetConvolutionParameterfvEXT');
public z_GetConvolutionParameterfvEXT_ovr_0 := GetFuncOrNil&<procedure(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; var ¶ms: single)>(z_GetConvolutionParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetConvolutionParameterfvEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: array of single);
begin
z_GetConvolutionParameterfvEXT_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetConvolutionParameterfvEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; var ¶ms: single);
begin
z_GetConvolutionParameterfvEXT_ovr_0(target, pname, ¶ms);
end;
public z_GetConvolutionParameterfvEXT_ovr_2 := GetFuncOrNil&<procedure(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: IntPtr)>(z_GetConvolutionParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetConvolutionParameterfvEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: IntPtr);
begin
z_GetConvolutionParameterfvEXT_ovr_2(target, pname, ¶ms);
end;
public z_GetConvolutionParameterivEXT_adr := GetFuncAdr('glGetConvolutionParameterivEXT');
public z_GetConvolutionParameterivEXT_ovr_0 := GetFuncOrNil&<procedure(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; var ¶ms: Int32)>(z_GetConvolutionParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetConvolutionParameterivEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: array of Int32);
begin
z_GetConvolutionParameterivEXT_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetConvolutionParameterivEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; var ¶ms: Int32);
begin
z_GetConvolutionParameterivEXT_ovr_0(target, pname, ¶ms);
end;
public z_GetConvolutionParameterivEXT_ovr_2 := GetFuncOrNil&<procedure(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: IntPtr)>(z_GetConvolutionParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetConvolutionParameterivEXT(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: IntPtr);
begin
z_GetConvolutionParameterivEXT_ovr_2(target, pname, ¶ms);
end;
public z_GetSeparableFilterEXT_adr := GetFuncAdr('glGetSeparableFilterEXT');
public z_GetSeparableFilterEXT_ovr_0 := GetFuncOrNil&<procedure(target: SeparableTargetEXT; format: PixelFormat; &type: PixelType; row: IntPtr; column: IntPtr; span: IntPtr)>(z_GetSeparableFilterEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSeparableFilterEXT(target: SeparableTargetEXT; format: PixelFormat; &type: PixelType; row: IntPtr; column: IntPtr; span: IntPtr);
begin
z_GetSeparableFilterEXT_ovr_0(target, format, &type, row, column, span);
end;
public z_SeparableFilter2DEXT_adr := GetFuncAdr('glSeparableFilter2DEXT');
public z_SeparableFilter2DEXT_ovr_0 := GetFuncOrNil&<procedure(target: SeparableTargetEXT; _internalformat: InternalFormat; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; row: IntPtr; column: IntPtr)>(z_SeparableFilter2DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SeparableFilter2DEXT(target: SeparableTargetEXT; _internalformat: InternalFormat; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; row: IntPtr; column: IntPtr);
begin
z_SeparableFilter2DEXT_ovr_0(target, _internalformat, width, height, format, &type, row, column);
end;
end;
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);
public z_Tangent3bEXT_adr := GetFuncAdr('glTangent3bEXT');
public z_Tangent3bEXT_ovr_0 := GetFuncOrNil&<procedure(tx: SByte; ty: SByte; tz: SByte)>(z_Tangent3bEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3bEXT(tx: SByte; ty: SByte; tz: SByte);
begin
z_Tangent3bEXT_ovr_0(tx, ty, tz);
end;
public z_Tangent3bvEXT_adr := GetFuncAdr('glTangent3bvEXT');
public z_Tangent3bvEXT_ovr_0 := GetFuncOrNil&<procedure(var v: SByte)>(z_Tangent3bvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3bvEXT(v: array of SByte);
begin
z_Tangent3bvEXT_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3bvEXT(var v: SByte);
begin
z_Tangent3bvEXT_ovr_0(v);
end;
public z_Tangent3bvEXT_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_Tangent3bvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3bvEXT(v: IntPtr);
begin
z_Tangent3bvEXT_ovr_2(v);
end;
public z_Tangent3dEXT_adr := GetFuncAdr('glTangent3dEXT');
public z_Tangent3dEXT_ovr_0 := GetFuncOrNil&<procedure(tx: real; ty: real; tz: real)>(z_Tangent3dEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3dEXT(tx: real; ty: real; tz: real);
begin
z_Tangent3dEXT_ovr_0(tx, ty, tz);
end;
public z_Tangent3dvEXT_adr := GetFuncAdr('glTangent3dvEXT');
public z_Tangent3dvEXT_ovr_0 := GetFuncOrNil&<procedure(var v: real)>(z_Tangent3dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3dvEXT(v: array of real);
begin
z_Tangent3dvEXT_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3dvEXT(var v: real);
begin
z_Tangent3dvEXT_ovr_0(v);
end;
public z_Tangent3dvEXT_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_Tangent3dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3dvEXT(v: IntPtr);
begin
z_Tangent3dvEXT_ovr_2(v);
end;
public z_Tangent3fEXT_adr := GetFuncAdr('glTangent3fEXT');
public z_Tangent3fEXT_ovr_0 := GetFuncOrNil&<procedure(tx: single; ty: single; tz: single)>(z_Tangent3fEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3fEXT(tx: single; ty: single; tz: single);
begin
z_Tangent3fEXT_ovr_0(tx, ty, tz);
end;
public z_Tangent3fvEXT_adr := GetFuncAdr('glTangent3fvEXT');
public z_Tangent3fvEXT_ovr_0 := GetFuncOrNil&<procedure(var v: single)>(z_Tangent3fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3fvEXT(v: array of single);
begin
z_Tangent3fvEXT_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3fvEXT(var v: single);
begin
z_Tangent3fvEXT_ovr_0(v);
end;
public z_Tangent3fvEXT_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_Tangent3fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3fvEXT(v: IntPtr);
begin
z_Tangent3fvEXT_ovr_2(v);
end;
public z_Tangent3iEXT_adr := GetFuncAdr('glTangent3iEXT');
public z_Tangent3iEXT_ovr_0 := GetFuncOrNil&<procedure(tx: Int32; ty: Int32; tz: Int32)>(z_Tangent3iEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3iEXT(tx: Int32; ty: Int32; tz: Int32);
begin
z_Tangent3iEXT_ovr_0(tx, ty, tz);
end;
public z_Tangent3ivEXT_adr := GetFuncAdr('glTangent3ivEXT');
public z_Tangent3ivEXT_ovr_0 := GetFuncOrNil&<procedure(var v: Int32)>(z_Tangent3ivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3ivEXT(v: array of Int32);
begin
z_Tangent3ivEXT_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3ivEXT(var v: Int32);
begin
z_Tangent3ivEXT_ovr_0(v);
end;
public z_Tangent3ivEXT_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_Tangent3ivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3ivEXT(v: IntPtr);
begin
z_Tangent3ivEXT_ovr_2(v);
end;
public z_Tangent3sEXT_adr := GetFuncAdr('glTangent3sEXT');
public z_Tangent3sEXT_ovr_0 := GetFuncOrNil&<procedure(tx: Int16; ty: Int16; tz: Int16)>(z_Tangent3sEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3sEXT(tx: Int16; ty: Int16; tz: Int16);
begin
z_Tangent3sEXT_ovr_0(tx, ty, tz);
end;
public z_Tangent3svEXT_adr := GetFuncAdr('glTangent3svEXT');
public z_Tangent3svEXT_ovr_0 := GetFuncOrNil&<procedure(var v: Int16)>(z_Tangent3svEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3svEXT(v: array of Int16);
begin
z_Tangent3svEXT_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3svEXT(var v: Int16);
begin
z_Tangent3svEXT_ovr_0(v);
end;
public z_Tangent3svEXT_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_Tangent3svEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Tangent3svEXT(v: IntPtr);
begin
z_Tangent3svEXT_ovr_2(v);
end;
public z_Binormal3bEXT_adr := GetFuncAdr('glBinormal3bEXT');
public z_Binormal3bEXT_ovr_0 := GetFuncOrNil&<procedure(bx: SByte; by: SByte; bz: SByte)>(z_Binormal3bEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3bEXT(bx: SByte; by: SByte; bz: SByte);
begin
z_Binormal3bEXT_ovr_0(bx, by, bz);
end;
public z_Binormal3bvEXT_adr := GetFuncAdr('glBinormal3bvEXT');
public z_Binormal3bvEXT_ovr_0 := GetFuncOrNil&<procedure(var v: SByte)>(z_Binormal3bvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3bvEXT(v: array of SByte);
begin
z_Binormal3bvEXT_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3bvEXT(var v: SByte);
begin
z_Binormal3bvEXT_ovr_0(v);
end;
public z_Binormal3bvEXT_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_Binormal3bvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3bvEXT(v: IntPtr);
begin
z_Binormal3bvEXT_ovr_2(v);
end;
public z_Binormal3dEXT_adr := GetFuncAdr('glBinormal3dEXT');
public z_Binormal3dEXT_ovr_0 := GetFuncOrNil&<procedure(bx: real; by: real; bz: real)>(z_Binormal3dEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3dEXT(bx: real; by: real; bz: real);
begin
z_Binormal3dEXT_ovr_0(bx, by, bz);
end;
public z_Binormal3dvEXT_adr := GetFuncAdr('glBinormal3dvEXT');
public z_Binormal3dvEXT_ovr_0 := GetFuncOrNil&<procedure(var v: real)>(z_Binormal3dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3dvEXT(v: array of real);
begin
z_Binormal3dvEXT_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3dvEXT(var v: real);
begin
z_Binormal3dvEXT_ovr_0(v);
end;
public z_Binormal3dvEXT_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_Binormal3dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3dvEXT(v: IntPtr);
begin
z_Binormal3dvEXT_ovr_2(v);
end;
public z_Binormal3fEXT_adr := GetFuncAdr('glBinormal3fEXT');
public z_Binormal3fEXT_ovr_0 := GetFuncOrNil&<procedure(bx: single; by: single; bz: single)>(z_Binormal3fEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3fEXT(bx: single; by: single; bz: single);
begin
z_Binormal3fEXT_ovr_0(bx, by, bz);
end;
public z_Binormal3fvEXT_adr := GetFuncAdr('glBinormal3fvEXT');
public z_Binormal3fvEXT_ovr_0 := GetFuncOrNil&<procedure(var v: single)>(z_Binormal3fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3fvEXT(v: array of single);
begin
z_Binormal3fvEXT_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3fvEXT(var v: single);
begin
z_Binormal3fvEXT_ovr_0(v);
end;
public z_Binormal3fvEXT_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_Binormal3fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3fvEXT(v: IntPtr);
begin
z_Binormal3fvEXT_ovr_2(v);
end;
public z_Binormal3iEXT_adr := GetFuncAdr('glBinormal3iEXT');
public z_Binormal3iEXT_ovr_0 := GetFuncOrNil&<procedure(bx: Int32; by: Int32; bz: Int32)>(z_Binormal3iEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3iEXT(bx: Int32; by: Int32; bz: Int32);
begin
z_Binormal3iEXT_ovr_0(bx, by, bz);
end;
public z_Binormal3ivEXT_adr := GetFuncAdr('glBinormal3ivEXT');
public z_Binormal3ivEXT_ovr_0 := GetFuncOrNil&<procedure(var v: Int32)>(z_Binormal3ivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3ivEXT(v: array of Int32);
begin
z_Binormal3ivEXT_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3ivEXT(var v: Int32);
begin
z_Binormal3ivEXT_ovr_0(v);
end;
public z_Binormal3ivEXT_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_Binormal3ivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3ivEXT(v: IntPtr);
begin
z_Binormal3ivEXT_ovr_2(v);
end;
public z_Binormal3sEXT_adr := GetFuncAdr('glBinormal3sEXT');
public z_Binormal3sEXT_ovr_0 := GetFuncOrNil&<procedure(bx: Int16; by: Int16; bz: Int16)>(z_Binormal3sEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3sEXT(bx: Int16; by: Int16; bz: Int16);
begin
z_Binormal3sEXT_ovr_0(bx, by, bz);
end;
public z_Binormal3svEXT_adr := GetFuncAdr('glBinormal3svEXT');
public z_Binormal3svEXT_ovr_0 := GetFuncOrNil&<procedure(var v: Int16)>(z_Binormal3svEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3svEXT(v: array of Int16);
begin
z_Binormal3svEXT_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3svEXT(var v: Int16);
begin
z_Binormal3svEXT_ovr_0(v);
end;
public z_Binormal3svEXT_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_Binormal3svEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Binormal3svEXT(v: IntPtr);
begin
z_Binormal3svEXT_ovr_2(v);
end;
public z_TangentPointerEXT_adr := GetFuncAdr('glTangentPointerEXT');
public z_TangentPointerEXT_ovr_0 := GetFuncOrNil&<procedure(&type: TangentPointerTypeEXT; stride: Int32; pointer: IntPtr)>(z_TangentPointerEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TangentPointerEXT(&type: TangentPointerTypeEXT; stride: Int32; pointer: IntPtr);
begin
z_TangentPointerEXT_ovr_0(&type, stride, pointer);
end;
public z_BinormalPointerEXT_adr := GetFuncAdr('glBinormalPointerEXT');
public z_BinormalPointerEXT_ovr_0 := GetFuncOrNil&<procedure(&type: BinormalPointerTypeEXT; stride: Int32; pointer: IntPtr)>(z_BinormalPointerEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BinormalPointerEXT(&type: BinormalPointerTypeEXT; stride: Int32; pointer: IntPtr);
begin
z_BinormalPointerEXT_ovr_0(&type, stride, pointer);
end;
end;
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);
public z_CopyTexImage1DEXT_adr := GetFuncAdr('glCopyTexImage1DEXT');
public z_CopyTexImage1DEXT_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; border: Int32)>(z_CopyTexImage1DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTexImage1DEXT(target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; border: Int32);
begin
z_CopyTexImage1DEXT_ovr_0(target, level, _internalformat, x, y, width, border);
end;
public z_CopyTexImage2DEXT_adr := GetFuncAdr('glCopyTexImage2DEXT');
public z_CopyTexImage2DEXT_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; height: Int32; border: Int32)>(z_CopyTexImage2DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTexImage2DEXT(target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; height: Int32; border: Int32);
begin
z_CopyTexImage2DEXT_ovr_0(target, level, _internalformat, x, y, width, height, border);
end;
public z_CopyTexSubImage1DEXT_adr := GetFuncAdr('glCopyTexSubImage1DEXT');
public z_CopyTexSubImage1DEXT_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; xoffset: Int32; x: Int32; y: Int32; width: Int32)>(z_CopyTexSubImage1DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTexSubImage1DEXT(target: TextureTarget; level: Int32; xoffset: Int32; x: Int32; y: Int32; width: Int32);
begin
z_CopyTexSubImage1DEXT_ovr_0(target, level, xoffset, x, y, width);
end;
public z_CopyTexSubImage2DEXT_adr := GetFuncAdr('glCopyTexSubImage2DEXT');
public z_CopyTexSubImage2DEXT_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32)>(z_CopyTexSubImage2DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTexSubImage2DEXT(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32);
begin
z_CopyTexSubImage2DEXT_ovr_0(target, level, xoffset, yoffset, x, y, width, height);
end;
public z_CopyTexSubImage3DEXT_adr := GetFuncAdr('glCopyTexSubImage3DEXT');
public z_CopyTexSubImage3DEXT_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32)>(z_CopyTexSubImage3DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTexSubImage3DEXT(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32);
begin
z_CopyTexSubImage3DEXT_ovr_0(target, level, xoffset, yoffset, zoffset, x, y, width, height);
end;
end;
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);
public z_CullParameterdvEXT_adr := GetFuncAdr('glCullParameterdvEXT');
public z_CullParameterdvEXT_ovr_0 := GetFuncOrNil&<procedure(pname: CullParameterEXT; var ¶ms: real)>(z_CullParameterdvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CullParameterdvEXT(pname: CullParameterEXT; ¶ms: array of real);
begin
z_CullParameterdvEXT_ovr_0(pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CullParameterdvEXT(pname: CullParameterEXT; var ¶ms: real);
begin
z_CullParameterdvEXT_ovr_0(pname, ¶ms);
end;
public z_CullParameterdvEXT_ovr_2 := GetFuncOrNil&<procedure(pname: CullParameterEXT; ¶ms: IntPtr)>(z_CullParameterdvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CullParameterdvEXT(pname: CullParameterEXT; ¶ms: IntPtr);
begin
z_CullParameterdvEXT_ovr_2(pname, ¶ms);
end;
public z_CullParameterfvEXT_adr := GetFuncAdr('glCullParameterfvEXT');
public z_CullParameterfvEXT_ovr_0 := GetFuncOrNil&<procedure(pname: CullParameterEXT; var ¶ms: single)>(z_CullParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CullParameterfvEXT(pname: CullParameterEXT; ¶ms: array of single);
begin
z_CullParameterfvEXT_ovr_0(pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CullParameterfvEXT(pname: CullParameterEXT; var ¶ms: single);
begin
z_CullParameterfvEXT_ovr_0(pname, ¶ms);
end;
public z_CullParameterfvEXT_ovr_2 := GetFuncOrNil&<procedure(pname: CullParameterEXT; ¶ms: IntPtr)>(z_CullParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CullParameterfvEXT(pname: CullParameterEXT; ¶ms: IntPtr);
begin
z_CullParameterfvEXT_ovr_2(pname, ¶ms);
end;
end;
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);
public z_LabelObjectEXT_adr := GetFuncAdr('glLabelObjectEXT');
public z_LabelObjectEXT_ovr_0 := GetFuncOrNil&<procedure(&type: DummyEnum; object: UInt32; length: Int32; &label: IntPtr)>(z_LabelObjectEXT_adr);
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);
begin
z_LabelObjectEXT_ovr_0(&type, object, length, &label);
end;
public z_GetObjectLabelEXT_adr := GetFuncAdr('glGetObjectLabelEXT');
public z_GetObjectLabelEXT_ovr_0 := GetFuncOrNil&<procedure(&type: DummyEnum; object: UInt32; bufSize: Int32; var length: Int32; &label: IntPtr)>(z_GetObjectLabelEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectLabelEXT(&type: DummyEnum; object: UInt32; bufSize: Int32; length: array of Int32; &label: IntPtr);
begin
z_GetObjectLabelEXT_ovr_0(&type, object, bufSize, length[0], &label);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectLabelEXT(&type: DummyEnum; object: UInt32; bufSize: Int32; var length: Int32; &label: IntPtr);
begin
z_GetObjectLabelEXT_ovr_0(&type, object, bufSize, length, &label);
end;
public z_GetObjectLabelEXT_ovr_2 := GetFuncOrNil&<procedure(&type: DummyEnum; object: UInt32; bufSize: Int32; length: IntPtr; &label: IntPtr)>(z_GetObjectLabelEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetObjectLabelEXT(&type: DummyEnum; object: UInt32; bufSize: Int32; length: IntPtr; &label: IntPtr);
begin
z_GetObjectLabelEXT_ovr_2(&type, object, bufSize, length, &label);
end;
end;
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);
public z_InsertEventMarkerEXT_adr := GetFuncAdr('glInsertEventMarkerEXT');
public z_InsertEventMarkerEXT_ovr_0 := GetFuncOrNil&<procedure(length: Int32; marker: IntPtr)>(z_InsertEventMarkerEXT_adr);
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);
begin
z_InsertEventMarkerEXT_ovr_0(length, marker);
end;
public z_PushGroupMarkerEXT_adr := GetFuncAdr('glPushGroupMarkerEXT');
public z_PushGroupMarkerEXT_ovr_0 := GetFuncOrNil&<procedure(length: Int32; marker: IntPtr)>(z_PushGroupMarkerEXT_adr);
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);
begin
z_PushGroupMarkerEXT_ovr_0(length, marker);
end;
public z_PopGroupMarkerEXT_adr := GetFuncAdr('glPopGroupMarkerEXT');
public z_PopGroupMarkerEXT_ovr_0 := GetFuncOrNil&<procedure>(z_PopGroupMarkerEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PopGroupMarkerEXT;
begin
z_PopGroupMarkerEXT_ovr_0;
end;
end;
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);
public z_DepthBoundsEXT_adr := GetFuncAdr('glDepthBoundsEXT');
public z_DepthBoundsEXT_ovr_0 := GetFuncOrNil&<procedure(zmin: real; zmax: real)>(z_DepthBoundsEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthBoundsEXT(zmin: real; zmax: real);
begin
z_DepthBoundsEXT_ovr_0(zmin, zmax);
end;
end;
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);
public z_MatrixLoadfEXT_adr := GetFuncAdr('glMatrixLoadfEXT');
public z_MatrixLoadfEXT_ovr_0 := GetFuncOrNil&<procedure(mode: MatrixMode; var m: single)>(z_MatrixLoadfEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadfEXT(mode: MatrixMode; m: array of single);
begin
z_MatrixLoadfEXT_ovr_0(mode, m[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadfEXT(mode: MatrixMode; var m: single);
begin
z_MatrixLoadfEXT_ovr_0(mode, m);
end;
public z_MatrixLoadfEXT_ovr_2 := GetFuncOrNil&<procedure(mode: MatrixMode; m: IntPtr)>(z_MatrixLoadfEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadfEXT(mode: MatrixMode; m: IntPtr);
begin
z_MatrixLoadfEXT_ovr_2(mode, m);
end;
public z_MatrixLoaddEXT_adr := GetFuncAdr('glMatrixLoaddEXT');
public z_MatrixLoaddEXT_ovr_0 := GetFuncOrNil&<procedure(mode: MatrixMode; var m: real)>(z_MatrixLoaddEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoaddEXT(mode: MatrixMode; m: array of real);
begin
z_MatrixLoaddEXT_ovr_0(mode, m[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoaddEXT(mode: MatrixMode; var m: real);
begin
z_MatrixLoaddEXT_ovr_0(mode, m);
end;
public z_MatrixLoaddEXT_ovr_2 := GetFuncOrNil&<procedure(mode: MatrixMode; m: IntPtr)>(z_MatrixLoaddEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoaddEXT(mode: MatrixMode; m: IntPtr);
begin
z_MatrixLoaddEXT_ovr_2(mode, m);
end;
public z_MatrixMultfEXT_adr := GetFuncAdr('glMatrixMultfEXT');
public z_MatrixMultfEXT_ovr_0 := GetFuncOrNil&<procedure(mode: MatrixMode; var m: single)>(z_MatrixMultfEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultfEXT(mode: MatrixMode; m: array of single);
begin
z_MatrixMultfEXT_ovr_0(mode, m[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultfEXT(mode: MatrixMode; var m: single);
begin
z_MatrixMultfEXT_ovr_0(mode, m);
end;
public z_MatrixMultfEXT_ovr_2 := GetFuncOrNil&<procedure(mode: MatrixMode; m: IntPtr)>(z_MatrixMultfEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultfEXT(mode: MatrixMode; m: IntPtr);
begin
z_MatrixMultfEXT_ovr_2(mode, m);
end;
public z_MatrixMultdEXT_adr := GetFuncAdr('glMatrixMultdEXT');
public z_MatrixMultdEXT_ovr_0 := GetFuncOrNil&<procedure(mode: MatrixMode; var m: real)>(z_MatrixMultdEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultdEXT(mode: MatrixMode; m: array of real);
begin
z_MatrixMultdEXT_ovr_0(mode, m[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultdEXT(mode: MatrixMode; var m: real);
begin
z_MatrixMultdEXT_ovr_0(mode, m);
end;
public z_MatrixMultdEXT_ovr_2 := GetFuncOrNil&<procedure(mode: MatrixMode; m: IntPtr)>(z_MatrixMultdEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultdEXT(mode: MatrixMode; m: IntPtr);
begin
z_MatrixMultdEXT_ovr_2(mode, m);
end;
public z_MatrixLoadIdentityEXT_adr := GetFuncAdr('glMatrixLoadIdentityEXT');
public z_MatrixLoadIdentityEXT_ovr_0 := GetFuncOrNil&<procedure(mode: MatrixMode)>(z_MatrixLoadIdentityEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadIdentityEXT(mode: MatrixMode);
begin
z_MatrixLoadIdentityEXT_ovr_0(mode);
end;
public z_MatrixRotatefEXT_adr := GetFuncAdr('glMatrixRotatefEXT');
public z_MatrixRotatefEXT_ovr_0 := GetFuncOrNil&<procedure(mode: MatrixMode; angle: single; x: single; y: single; z: single)>(z_MatrixRotatefEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixRotatefEXT(mode: MatrixMode; angle: single; x: single; y: single; z: single);
begin
z_MatrixRotatefEXT_ovr_0(mode, angle, x, y, z);
end;
public z_MatrixRotatedEXT_adr := GetFuncAdr('glMatrixRotatedEXT');
public z_MatrixRotatedEXT_ovr_0 := GetFuncOrNil&<procedure(mode: MatrixMode; angle: real; x: real; y: real; z: real)>(z_MatrixRotatedEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixRotatedEXT(mode: MatrixMode; angle: real; x: real; y: real; z: real);
begin
z_MatrixRotatedEXT_ovr_0(mode, angle, x, y, z);
end;
public z_MatrixScalefEXT_adr := GetFuncAdr('glMatrixScalefEXT');
public z_MatrixScalefEXT_ovr_0 := GetFuncOrNil&<procedure(mode: MatrixMode; x: single; y: single; z: single)>(z_MatrixScalefEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixScalefEXT(mode: MatrixMode; x: single; y: single; z: single);
begin
z_MatrixScalefEXT_ovr_0(mode, x, y, z);
end;
public z_MatrixScaledEXT_adr := GetFuncAdr('glMatrixScaledEXT');
public z_MatrixScaledEXT_ovr_0 := GetFuncOrNil&<procedure(mode: MatrixMode; x: real; y: real; z: real)>(z_MatrixScaledEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixScaledEXT(mode: MatrixMode; x: real; y: real; z: real);
begin
z_MatrixScaledEXT_ovr_0(mode, x, y, z);
end;
public z_MatrixTranslatefEXT_adr := GetFuncAdr('glMatrixTranslatefEXT');
public z_MatrixTranslatefEXT_ovr_0 := GetFuncOrNil&<procedure(mode: MatrixMode; x: single; y: single; z: single)>(z_MatrixTranslatefEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixTranslatefEXT(mode: MatrixMode; x: single; y: single; z: single);
begin
z_MatrixTranslatefEXT_ovr_0(mode, x, y, z);
end;
public z_MatrixTranslatedEXT_adr := GetFuncAdr('glMatrixTranslatedEXT');
public z_MatrixTranslatedEXT_ovr_0 := GetFuncOrNil&<procedure(mode: MatrixMode; x: real; y: real; z: real)>(z_MatrixTranslatedEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixTranslatedEXT(mode: MatrixMode; x: real; y: real; z: real);
begin
z_MatrixTranslatedEXT_ovr_0(mode, x, y, z);
end;
public z_MatrixFrustumEXT_adr := GetFuncAdr('glMatrixFrustumEXT');
public z_MatrixFrustumEXT_ovr_0 := GetFuncOrNil&<procedure(mode: MatrixMode; left: real; right: real; bottom: real; top: real; zNear: real; zFar: real)>(z_MatrixFrustumEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixFrustumEXT(mode: MatrixMode; left: real; right: real; bottom: real; top: real; zNear: real; zFar: real);
begin
z_MatrixFrustumEXT_ovr_0(mode, left, right, bottom, top, zNear, zFar);
end;
public z_MatrixOrthoEXT_adr := GetFuncAdr('glMatrixOrthoEXT');
public z_MatrixOrthoEXT_ovr_0 := GetFuncOrNil&<procedure(mode: MatrixMode; left: real; right: real; bottom: real; top: real; zNear: real; zFar: real)>(z_MatrixOrthoEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixOrthoEXT(mode: MatrixMode; left: real; right: real; bottom: real; top: real; zNear: real; zFar: real);
begin
z_MatrixOrthoEXT_ovr_0(mode, left, right, bottom, top, zNear, zFar);
end;
public z_MatrixPopEXT_adr := GetFuncAdr('glMatrixPopEXT');
public z_MatrixPopEXT_ovr_0 := GetFuncOrNil&<procedure(mode: MatrixMode)>(z_MatrixPopEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixPopEXT(mode: MatrixMode);
begin
z_MatrixPopEXT_ovr_0(mode);
end;
public z_MatrixPushEXT_adr := GetFuncAdr('glMatrixPushEXT');
public z_MatrixPushEXT_ovr_0 := GetFuncOrNil&<procedure(mode: MatrixMode)>(z_MatrixPushEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixPushEXT(mode: MatrixMode);
begin
z_MatrixPushEXT_ovr_0(mode);
end;
public z_ClientAttribDefaultEXT_adr := GetFuncAdr('glClientAttribDefaultEXT');
public z_ClientAttribDefaultEXT_ovr_0 := GetFuncOrNil&<procedure(mask: ClientAttribMask)>(z_ClientAttribDefaultEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClientAttribDefaultEXT(mask: ClientAttribMask);
begin
z_ClientAttribDefaultEXT_ovr_0(mask);
end;
public z_PushClientAttribDefaultEXT_adr := GetFuncAdr('glPushClientAttribDefaultEXT');
public z_PushClientAttribDefaultEXT_ovr_0 := GetFuncOrNil&<procedure(mask: ClientAttribMask)>(z_PushClientAttribDefaultEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PushClientAttribDefaultEXT(mask: ClientAttribMask);
begin
z_PushClientAttribDefaultEXT_ovr_0(mask);
end;
public z_TextureParameterfEXT_adr := GetFuncAdr('glTextureParameterfEXT');
public z_TextureParameterfEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; pname: TextureParameterName; param: single)>(z_TextureParameterfEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterfEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; param: single);
begin
z_TextureParameterfEXT_ovr_0(texture, target, pname, param);
end;
public z_TextureParameterfvEXT_adr := GetFuncAdr('glTextureParameterfvEXT');
public z_TextureParameterfvEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; pname: TextureParameterName; var ¶ms: single)>(z_TextureParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterfvEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: array of single);
begin
z_TextureParameterfvEXT_ovr_0(texture, target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterfvEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; var ¶ms: single);
begin
z_TextureParameterfvEXT_ovr_0(texture, target, pname, ¶ms);
end;
public z_TextureParameterfvEXT_ovr_2 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr)>(z_TextureParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterfvEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
begin
z_TextureParameterfvEXT_ovr_2(texture, target, pname, ¶ms);
end;
public z_TextureParameteriEXT_adr := GetFuncAdr('glTextureParameteriEXT');
public z_TextureParameteriEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; pname: TextureParameterName; param: Int32)>(z_TextureParameteriEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameteriEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; param: Int32);
begin
z_TextureParameteriEXT_ovr_0(texture, target, pname, param);
end;
public z_TextureParameterivEXT_adr := GetFuncAdr('glTextureParameterivEXT');
public z_TextureParameterivEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32)>(z_TextureParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterivEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: array of Int32);
begin
z_TextureParameterivEXT_ovr_0(texture, target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterivEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32);
begin
z_TextureParameterivEXT_ovr_0(texture, target, pname, ¶ms);
end;
public z_TextureParameterivEXT_ovr_2 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr)>(z_TextureParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterivEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
begin
z_TextureParameterivEXT_ovr_2(texture, target, pname, ¶ms);
end;
public z_TextureImage1DEXT_adr := GetFuncAdr('glTextureImage1DEXT');
public z_TextureImage1DEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr)>(z_TextureImage1DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureImage1DEXT(texture: UInt32; target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
begin
z_TextureImage1DEXT_ovr_0(texture, target, level, internalformat, width, border, format, &type, pixels);
end;
public z_TextureImage2DEXT_adr := GetFuncAdr('glTextureImage2DEXT');
public z_TextureImage2DEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; height: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr)>(z_TextureImage2DEXT_adr);
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);
begin
z_TextureImage2DEXT_ovr_0(texture, target, level, internalformat, width, height, border, format, &type, pixels);
end;
public z_TextureSubImage1DEXT_adr := GetFuncAdr('glTextureSubImage1DEXT');
public z_TextureSubImage1DEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr)>(z_TextureSubImage1DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureSubImage1DEXT(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
begin
z_TextureSubImage1DEXT_ovr_0(texture, target, level, xoffset, width, format, &type, pixels);
end;
public z_TextureSubImage2DEXT_adr := GetFuncAdr('glTextureSubImage2DEXT');
public z_TextureSubImage2DEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr)>(z_TextureSubImage2DEXT_adr);
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);
begin
z_TextureSubImage2DEXT_ovr_0(texture, target, level, xoffset, yoffset, width, height, format, &type, pixels);
end;
public z_CopyTextureImage1DEXT_adr := GetFuncAdr('glCopyTextureImage1DEXT');
public z_CopyTextureImage1DEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; border: Int32)>(z_CopyTextureImage1DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTextureImage1DEXT(texture: UInt32; target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; border: Int32);
begin
z_CopyTextureImage1DEXT_ovr_0(texture, target, level, _internalformat, x, y, width, border);
end;
public z_CopyTextureImage2DEXT_adr := GetFuncAdr('glCopyTextureImage2DEXT');
public z_CopyTextureImage2DEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; height: Int32; border: Int32)>(z_CopyTextureImage2DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTextureImage2DEXT(texture: UInt32; target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; height: Int32; border: Int32);
begin
z_CopyTextureImage2DEXT_ovr_0(texture, target, level, _internalformat, x, y, width, height, border);
end;
public z_CopyTextureSubImage1DEXT_adr := GetFuncAdr('glCopyTextureSubImage1DEXT');
public z_CopyTextureSubImage1DEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; x: Int32; y: Int32; width: Int32)>(z_CopyTextureSubImage1DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTextureSubImage1DEXT(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; x: Int32; y: Int32; width: Int32);
begin
z_CopyTextureSubImage1DEXT_ovr_0(texture, target, level, xoffset, x, y, width);
end;
public z_CopyTextureSubImage2DEXT_adr := GetFuncAdr('glCopyTextureSubImage2DEXT');
public z_CopyTextureSubImage2DEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32)>(z_CopyTextureSubImage2DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyTextureSubImage2DEXT(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32);
begin
z_CopyTextureSubImage2DEXT_ovr_0(texture, target, level, xoffset, yoffset, x, y, width, height);
end;
public z_GetTextureImageEXT_adr := GetFuncAdr('glGetTextureImageEXT');
public z_GetTextureImageEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; level: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr)>(z_GetTextureImageEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureImageEXT(texture: UInt32; target: TextureTarget; level: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
begin
z_GetTextureImageEXT_ovr_0(texture, target, level, format, &type, pixels);
end;
public z_GetTextureParameterfvEXT_adr := GetFuncAdr('glGetTextureParameterfvEXT');
public z_GetTextureParameterfvEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; var ¶ms: single)>(z_GetTextureParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterfvEXT(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: array of single);
begin
z_GetTextureParameterfvEXT_ovr_0(texture, target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterfvEXT(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; var ¶ms: single);
begin
z_GetTextureParameterfvEXT_ovr_0(texture, target, pname, ¶ms);
end;
public z_GetTextureParameterfvEXT_ovr_2 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetTextureParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterfvEXT(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
begin
z_GetTextureParameterfvEXT_ovr_2(texture, target, pname, ¶ms);
end;
public z_GetTextureParameterivEXT_adr := GetFuncAdr('glGetTextureParameterivEXT');
public z_GetTextureParameterivEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32)>(z_GetTextureParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterivEXT(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: array of Int32);
begin
z_GetTextureParameterivEXT_ovr_0(texture, target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterivEXT(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32);
begin
z_GetTextureParameterivEXT_ovr_0(texture, target, pname, ¶ms);
end;
public z_GetTextureParameterivEXT_ovr_2 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetTextureParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterivEXT(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
begin
z_GetTextureParameterivEXT_ovr_2(texture, target, pname, ¶ms);
end;
public z_GetTextureLevelParameterfvEXT_adr := GetFuncAdr('glGetTextureLevelParameterfvEXT');
public z_GetTextureLevelParameterfvEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: single)>(z_GetTextureLevelParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameterfvEXT(texture: UInt32; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: array of single);
begin
z_GetTextureLevelParameterfvEXT_ovr_0(texture, target, level, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameterfvEXT(texture: UInt32; target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: single);
begin
z_GetTextureLevelParameterfvEXT_ovr_0(texture, target, level, pname, ¶ms);
end;
public z_GetTextureLevelParameterfvEXT_ovr_2 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetTextureLevelParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameterfvEXT(texture: UInt32; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr);
begin
z_GetTextureLevelParameterfvEXT_ovr_2(texture, target, level, pname, ¶ms);
end;
public z_GetTextureLevelParameterivEXT_adr := GetFuncAdr('glGetTextureLevelParameterivEXT');
public z_GetTextureLevelParameterivEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: Int32)>(z_GetTextureLevelParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameterivEXT(texture: UInt32; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: array of Int32);
begin
z_GetTextureLevelParameterivEXT_ovr_0(texture, target, level, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameterivEXT(texture: UInt32; target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: Int32);
begin
z_GetTextureLevelParameterivEXT_ovr_0(texture, target, level, pname, ¶ms);
end;
public z_GetTextureLevelParameterivEXT_ovr_2 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetTextureLevelParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureLevelParameterivEXT(texture: UInt32; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr);
begin
z_GetTextureLevelParameterivEXT_ovr_2(texture, target, level, pname, ¶ms);
end;
public z_TextureImage3DEXT_adr := GetFuncAdr('glTextureImage3DEXT');
public z_TextureImage3DEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; height: Int32; depth: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr)>(z_TextureImage3DEXT_adr);
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);
begin
z_TextureImage3DEXT_ovr_0(texture, target, level, internalformat, width, height, depth, border, format, &type, pixels);
end;
public z_TextureSubImage3DEXT_adr := GetFuncAdr('glTextureSubImage3DEXT');
public z_TextureSubImage3DEXT_ovr_0 := GetFuncOrNil&<procedure(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_adr);
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);
begin
z_TextureSubImage3DEXT_ovr_0(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, &type, pixels);
end;
public z_CopyTextureSubImage3DEXT_adr := GetFuncAdr('glCopyTextureSubImage3DEXT');
public z_CopyTextureSubImage3DEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32)>(z_CopyTextureSubImage3DEXT_adr);
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);
begin
z_CopyTextureSubImage3DEXT_ovr_0(texture, target, level, xoffset, yoffset, zoffset, x, y, width, height);
end;
public z_BindMultiTextureEXT_adr := GetFuncAdr('glBindMultiTextureEXT');
public z_BindMultiTextureEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; texture: UInt32)>(z_BindMultiTextureEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindMultiTextureEXT(texunit: TextureUnit; target: TextureTarget; texture: UInt32);
begin
z_BindMultiTextureEXT_ovr_0(texunit, target, texture);
end;
public z_MultiTexCoordPointerEXT_adr := GetFuncAdr('glMultiTexCoordPointerEXT');
public z_MultiTexCoordPointerEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; size: Int32; &type: TexCoordPointerType; stride: Int32; pointer: IntPtr)>(z_MultiTexCoordPointerEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoordPointerEXT(texunit: TextureUnit; size: Int32; &type: TexCoordPointerType; stride: Int32; pointer: IntPtr);
begin
z_MultiTexCoordPointerEXT_ovr_0(texunit, size, &type, stride, pointer);
end;
public z_MultiTexEnvfEXT_adr := GetFuncAdr('glMultiTexEnvfEXT');
public z_MultiTexEnvfEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; param: single)>(z_MultiTexEnvfEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexEnvfEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; param: single);
begin
z_MultiTexEnvfEXT_ovr_0(texunit, target, pname, param);
end;
public z_MultiTexEnvfvEXT_adr := GetFuncAdr('glMultiTexEnvfvEXT');
public z_MultiTexEnvfvEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: single)>(z_MultiTexEnvfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexEnvfvEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: array of single);
begin
z_MultiTexEnvfvEXT_ovr_0(texunit, target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexEnvfvEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: single);
begin
z_MultiTexEnvfvEXT_ovr_0(texunit, target, pname, ¶ms);
end;
public z_MultiTexEnvfvEXT_ovr_2 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr)>(z_MultiTexEnvfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexEnvfvEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
begin
z_MultiTexEnvfvEXT_ovr_2(texunit, target, pname, ¶ms);
end;
public z_MultiTexEnviEXT_adr := GetFuncAdr('glMultiTexEnviEXT');
public z_MultiTexEnviEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; param: Int32)>(z_MultiTexEnviEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexEnviEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; param: Int32);
begin
z_MultiTexEnviEXT_ovr_0(texunit, target, pname, param);
end;
public z_MultiTexEnvivEXT_adr := GetFuncAdr('glMultiTexEnvivEXT');
public z_MultiTexEnvivEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: Int32)>(z_MultiTexEnvivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexEnvivEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: array of Int32);
begin
z_MultiTexEnvivEXT_ovr_0(texunit, target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexEnvivEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: Int32);
begin
z_MultiTexEnvivEXT_ovr_0(texunit, target, pname, ¶ms);
end;
public z_MultiTexEnvivEXT_ovr_2 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr)>(z_MultiTexEnvivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexEnvivEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
begin
z_MultiTexEnvivEXT_ovr_2(texunit, target, pname, ¶ms);
end;
public z_MultiTexGendEXT_adr := GetFuncAdr('glMultiTexGendEXT');
public z_MultiTexGendEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; param: real)>(z_MultiTexGendEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexGendEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; param: real);
begin
z_MultiTexGendEXT_ovr_0(texunit, coord, pname, param);
end;
public z_MultiTexGendvEXT_adr := GetFuncAdr('glMultiTexGendvEXT');
public z_MultiTexGendvEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: real)>(z_MultiTexGendvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexGendvEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of real);
begin
z_MultiTexGendvEXT_ovr_0(texunit, coord, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexGendvEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: real);
begin
z_MultiTexGendvEXT_ovr_0(texunit, coord, pname, ¶ms);
end;
public z_MultiTexGendvEXT_ovr_2 := GetFuncOrNil&<procedure(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr)>(z_MultiTexGendvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexGendvEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
begin
z_MultiTexGendvEXT_ovr_2(texunit, coord, pname, ¶ms);
end;
public z_MultiTexGenfEXT_adr := GetFuncAdr('glMultiTexGenfEXT');
public z_MultiTexGenfEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; param: single)>(z_MultiTexGenfEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexGenfEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; param: single);
begin
z_MultiTexGenfEXT_ovr_0(texunit, coord, pname, param);
end;
public z_MultiTexGenfvEXT_adr := GetFuncAdr('glMultiTexGenfvEXT');
public z_MultiTexGenfvEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: single)>(z_MultiTexGenfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexGenfvEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of single);
begin
z_MultiTexGenfvEXT_ovr_0(texunit, coord, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexGenfvEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: single);
begin
z_MultiTexGenfvEXT_ovr_0(texunit, coord, pname, ¶ms);
end;
public z_MultiTexGenfvEXT_ovr_2 := GetFuncOrNil&<procedure(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr)>(z_MultiTexGenfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexGenfvEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
begin
z_MultiTexGenfvEXT_ovr_2(texunit, coord, pname, ¶ms);
end;
public z_MultiTexGeniEXT_adr := GetFuncAdr('glMultiTexGeniEXT');
public z_MultiTexGeniEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; param: Int32)>(z_MultiTexGeniEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexGeniEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; param: Int32);
begin
z_MultiTexGeniEXT_ovr_0(texunit, coord, pname, param);
end;
public z_MultiTexGenivEXT_adr := GetFuncAdr('glMultiTexGenivEXT');
public z_MultiTexGenivEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: Int32)>(z_MultiTexGenivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexGenivEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of Int32);
begin
z_MultiTexGenivEXT_ovr_0(texunit, coord, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexGenivEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: Int32);
begin
z_MultiTexGenivEXT_ovr_0(texunit, coord, pname, ¶ms);
end;
public z_MultiTexGenivEXT_ovr_2 := GetFuncOrNil&<procedure(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr)>(z_MultiTexGenivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexGenivEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
begin
z_MultiTexGenivEXT_ovr_2(texunit, coord, pname, ¶ms);
end;
public z_GetMultiTexEnvfvEXT_adr := GetFuncAdr('glGetMultiTexEnvfvEXT');
public z_GetMultiTexEnvfvEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: single)>(z_GetMultiTexEnvfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexEnvfvEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: array of single);
begin
z_GetMultiTexEnvfvEXT_ovr_0(texunit, target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexEnvfvEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: single);
begin
z_GetMultiTexEnvfvEXT_ovr_0(texunit, target, pname, ¶ms);
end;
public z_GetMultiTexEnvfvEXT_ovr_2 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr)>(z_GetMultiTexEnvfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexEnvfvEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
begin
z_GetMultiTexEnvfvEXT_ovr_2(texunit, target, pname, ¶ms);
end;
public z_GetMultiTexEnvivEXT_adr := GetFuncAdr('glGetMultiTexEnvivEXT');
public z_GetMultiTexEnvivEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: Int32)>(z_GetMultiTexEnvivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexEnvivEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: array of Int32);
begin
z_GetMultiTexEnvivEXT_ovr_0(texunit, target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexEnvivEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: Int32);
begin
z_GetMultiTexEnvivEXT_ovr_0(texunit, target, pname, ¶ms);
end;
public z_GetMultiTexEnvivEXT_ovr_2 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr)>(z_GetMultiTexEnvivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexEnvivEXT(texunit: TextureUnit; target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
begin
z_GetMultiTexEnvivEXT_ovr_2(texunit, target, pname, ¶ms);
end;
public z_GetMultiTexGendvEXT_adr := GetFuncAdr('glGetMultiTexGendvEXT');
public z_GetMultiTexGendvEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: real)>(z_GetMultiTexGendvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexGendvEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of real);
begin
z_GetMultiTexGendvEXT_ovr_0(texunit, coord, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexGendvEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: real);
begin
z_GetMultiTexGendvEXT_ovr_0(texunit, coord, pname, ¶ms);
end;
public z_GetMultiTexGendvEXT_ovr_2 := GetFuncOrNil&<procedure(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr)>(z_GetMultiTexGendvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexGendvEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
begin
z_GetMultiTexGendvEXT_ovr_2(texunit, coord, pname, ¶ms);
end;
public z_GetMultiTexGenfvEXT_adr := GetFuncAdr('glGetMultiTexGenfvEXT');
public z_GetMultiTexGenfvEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: single)>(z_GetMultiTexGenfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexGenfvEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of single);
begin
z_GetMultiTexGenfvEXT_ovr_0(texunit, coord, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexGenfvEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: single);
begin
z_GetMultiTexGenfvEXT_ovr_0(texunit, coord, pname, ¶ms);
end;
public z_GetMultiTexGenfvEXT_ovr_2 := GetFuncOrNil&<procedure(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr)>(z_GetMultiTexGenfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexGenfvEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
begin
z_GetMultiTexGenfvEXT_ovr_2(texunit, coord, pname, ¶ms);
end;
public z_GetMultiTexGenivEXT_adr := GetFuncAdr('glGetMultiTexGenivEXT');
public z_GetMultiTexGenivEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: Int32)>(z_GetMultiTexGenivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexGenivEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of Int32);
begin
z_GetMultiTexGenivEXT_ovr_0(texunit, coord, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexGenivEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: Int32);
begin
z_GetMultiTexGenivEXT_ovr_0(texunit, coord, pname, ¶ms);
end;
public z_GetMultiTexGenivEXT_ovr_2 := GetFuncOrNil&<procedure(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr)>(z_GetMultiTexGenivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexGenivEXT(texunit: TextureUnit; coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
begin
z_GetMultiTexGenivEXT_ovr_2(texunit, coord, pname, ¶ms);
end;
public z_MultiTexParameteriEXT_adr := GetFuncAdr('glMultiTexParameteriEXT');
public z_MultiTexParameteriEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; param: Int32)>(z_MultiTexParameteriEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameteriEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; param: Int32);
begin
z_MultiTexParameteriEXT_ovr_0(texunit, target, pname, param);
end;
public z_MultiTexParameterivEXT_adr := GetFuncAdr('glMultiTexParameterivEXT');
public z_MultiTexParameterivEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32)>(z_MultiTexParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameterivEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: array of Int32);
begin
z_MultiTexParameterivEXT_ovr_0(texunit, target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameterivEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32);
begin
z_MultiTexParameterivEXT_ovr_0(texunit, target, pname, ¶ms);
end;
public z_MultiTexParameterivEXT_ovr_2 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr)>(z_MultiTexParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameterivEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
begin
z_MultiTexParameterivEXT_ovr_2(texunit, target, pname, ¶ms);
end;
public z_MultiTexParameterfEXT_adr := GetFuncAdr('glMultiTexParameterfEXT');
public z_MultiTexParameterfEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; param: single)>(z_MultiTexParameterfEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameterfEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; param: single);
begin
z_MultiTexParameterfEXT_ovr_0(texunit, target, pname, param);
end;
public z_MultiTexParameterfvEXT_adr := GetFuncAdr('glMultiTexParameterfvEXT');
public z_MultiTexParameterfvEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; var ¶ms: single)>(z_MultiTexParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameterfvEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: array of single);
begin
z_MultiTexParameterfvEXT_ovr_0(texunit, target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameterfvEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; var ¶ms: single);
begin
z_MultiTexParameterfvEXT_ovr_0(texunit, target, pname, ¶ms);
end;
public z_MultiTexParameterfvEXT_ovr_2 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr)>(z_MultiTexParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameterfvEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
begin
z_MultiTexParameterfvEXT_ovr_2(texunit, target, pname, ¶ms);
end;
public z_MultiTexImage1DEXT_adr := GetFuncAdr('glMultiTexImage1DEXT');
public z_MultiTexImage1DEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr)>(z_MultiTexImage1DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexImage1DEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
begin
z_MultiTexImage1DEXT_ovr_0(texunit, target, level, internalformat, width, border, format, &type, pixels);
end;
public z_MultiTexImage2DEXT_adr := GetFuncAdr('glMultiTexImage2DEXT');
public z_MultiTexImage2DEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; height: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr)>(z_MultiTexImage2DEXT_adr);
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);
begin
z_MultiTexImage2DEXT_ovr_0(texunit, target, level, internalformat, width, height, border, format, &type, pixels);
end;
public z_MultiTexSubImage1DEXT_adr := GetFuncAdr('glMultiTexSubImage1DEXT');
public z_MultiTexSubImage1DEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr)>(z_MultiTexSubImage1DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexSubImage1DEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
begin
z_MultiTexSubImage1DEXT_ovr_0(texunit, target, level, xoffset, width, format, &type, pixels);
end;
public z_MultiTexSubImage2DEXT_adr := GetFuncAdr('glMultiTexSubImage2DEXT');
public z_MultiTexSubImage2DEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr)>(z_MultiTexSubImage2DEXT_adr);
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);
begin
z_MultiTexSubImage2DEXT_ovr_0(texunit, target, level, xoffset, yoffset, width, height, format, &type, pixels);
end;
public z_CopyMultiTexImage1DEXT_adr := GetFuncAdr('glCopyMultiTexImage1DEXT');
public z_CopyMultiTexImage1DEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; border: Int32)>(z_CopyMultiTexImage1DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyMultiTexImage1DEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; border: Int32);
begin
z_CopyMultiTexImage1DEXT_ovr_0(texunit, target, level, _internalformat, x, y, width, border);
end;
public z_CopyMultiTexImage2DEXT_adr := GetFuncAdr('glCopyMultiTexImage2DEXT');
public z_CopyMultiTexImage2DEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; height: Int32; border: Int32)>(z_CopyMultiTexImage2DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyMultiTexImage2DEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32; height: Int32; border: Int32);
begin
z_CopyMultiTexImage2DEXT_ovr_0(texunit, target, level, _internalformat, x, y, width, height, border);
end;
public z_CopyMultiTexSubImage1DEXT_adr := GetFuncAdr('glCopyMultiTexSubImage1DEXT');
public z_CopyMultiTexSubImage1DEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; x: Int32; y: Int32; width: Int32)>(z_CopyMultiTexSubImage1DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyMultiTexSubImage1DEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; x: Int32; y: Int32; width: Int32);
begin
z_CopyMultiTexSubImage1DEXT_ovr_0(texunit, target, level, xoffset, x, y, width);
end;
public z_CopyMultiTexSubImage2DEXT_adr := GetFuncAdr('glCopyMultiTexSubImage2DEXT');
public z_CopyMultiTexSubImage2DEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32)>(z_CopyMultiTexSubImage2DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyMultiTexSubImage2DEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32);
begin
z_CopyMultiTexSubImage2DEXT_ovr_0(texunit, target, level, xoffset, yoffset, x, y, width, height);
end;
public z_GetMultiTexImageEXT_adr := GetFuncAdr('glGetMultiTexImageEXT');
public z_GetMultiTexImageEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; level: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr)>(z_GetMultiTexImageEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexImageEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
begin
z_GetMultiTexImageEXT_ovr_0(texunit, target, level, format, &type, pixels);
end;
public z_GetMultiTexParameterfvEXT_adr := GetFuncAdr('glGetMultiTexParameterfvEXT');
public z_GetMultiTexParameterfvEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; var ¶ms: single)>(z_GetMultiTexParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexParameterfvEXT(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: array of single);
begin
z_GetMultiTexParameterfvEXT_ovr_0(texunit, target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexParameterfvEXT(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; var ¶ms: single);
begin
z_GetMultiTexParameterfvEXT_ovr_0(texunit, target, pname, ¶ms);
end;
public z_GetMultiTexParameterfvEXT_ovr_2 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetMultiTexParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexParameterfvEXT(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
begin
z_GetMultiTexParameterfvEXT_ovr_2(texunit, target, pname, ¶ms);
end;
public z_GetMultiTexParameterivEXT_adr := GetFuncAdr('glGetMultiTexParameterivEXT');
public z_GetMultiTexParameterivEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32)>(z_GetMultiTexParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexParameterivEXT(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: array of Int32);
begin
z_GetMultiTexParameterivEXT_ovr_0(texunit, target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexParameterivEXT(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32);
begin
z_GetMultiTexParameterivEXT_ovr_0(texunit, target, pname, ¶ms);
end;
public z_GetMultiTexParameterivEXT_ovr_2 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetMultiTexParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexParameterivEXT(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
begin
z_GetMultiTexParameterivEXT_ovr_2(texunit, target, pname, ¶ms);
end;
public z_GetMultiTexLevelParameterfvEXT_adr := GetFuncAdr('glGetMultiTexLevelParameterfvEXT');
public z_GetMultiTexLevelParameterfvEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: single)>(z_GetMultiTexLevelParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexLevelParameterfvEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: array of single);
begin
z_GetMultiTexLevelParameterfvEXT_ovr_0(texunit, target, level, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexLevelParameterfvEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: single);
begin
z_GetMultiTexLevelParameterfvEXT_ovr_0(texunit, target, level, pname, ¶ms);
end;
public z_GetMultiTexLevelParameterfvEXT_ovr_2 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetMultiTexLevelParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexLevelParameterfvEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr);
begin
z_GetMultiTexLevelParameterfvEXT_ovr_2(texunit, target, level, pname, ¶ms);
end;
public z_GetMultiTexLevelParameterivEXT_adr := GetFuncAdr('glGetMultiTexLevelParameterivEXT');
public z_GetMultiTexLevelParameterivEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: Int32)>(z_GetMultiTexLevelParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexLevelParameterivEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: array of Int32);
begin
z_GetMultiTexLevelParameterivEXT_ovr_0(texunit, target, level, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexLevelParameterivEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: Int32);
begin
z_GetMultiTexLevelParameterivEXT_ovr_0(texunit, target, level, pname, ¶ms);
end;
public z_GetMultiTexLevelParameterivEXT_ovr_2 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetMultiTexLevelParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexLevelParameterivEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr);
begin
z_GetMultiTexLevelParameterivEXT_ovr_2(texunit, target, level, pname, ¶ms);
end;
public z_MultiTexImage3DEXT_adr := GetFuncAdr('glMultiTexImage3DEXT');
public z_MultiTexImage3DEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; level: Int32; internalformat: Int32; width: Int32; height: Int32; depth: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr)>(z_MultiTexImage3DEXT_adr);
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);
begin
z_MultiTexImage3DEXT_ovr_0(texunit, target, level, internalformat, width, height, depth, border, format, &type, pixels);
end;
public z_MultiTexSubImage3DEXT_adr := GetFuncAdr('glMultiTexSubImage3DEXT');
public z_MultiTexSubImage3DEXT_ovr_0 := GetFuncOrNil&<procedure(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_adr);
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);
begin
z_MultiTexSubImage3DEXT_ovr_0(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, &type, pixels);
end;
public z_CopyMultiTexSubImage3DEXT_adr := GetFuncAdr('glCopyMultiTexSubImage3DEXT');
public z_CopyMultiTexSubImage3DEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; x: Int32; y: Int32; width: Int32; height: Int32)>(z_CopyMultiTexSubImage3DEXT_adr);
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);
begin
z_CopyMultiTexSubImage3DEXT_ovr_0(texunit, target, level, xoffset, yoffset, zoffset, x, y, width, height);
end;
public z_EnableClientStateIndexedEXT_adr := GetFuncAdr('glEnableClientStateIndexedEXT');
public z_EnableClientStateIndexedEXT_ovr_0 := GetFuncOrNil&<procedure(&array: EnableCap; index: UInt32)>(z_EnableClientStateIndexedEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EnableClientStateIndexedEXT(&array: EnableCap; index: UInt32);
begin
z_EnableClientStateIndexedEXT_ovr_0(&array, index);
end;
public z_DisableClientStateIndexedEXT_adr := GetFuncAdr('glDisableClientStateIndexedEXT');
public z_DisableClientStateIndexedEXT_ovr_0 := GetFuncOrNil&<procedure(&array: EnableCap; index: UInt32)>(z_DisableClientStateIndexedEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DisableClientStateIndexedEXT(&array: EnableCap; index: UInt32);
begin
z_DisableClientStateIndexedEXT_ovr_0(&array, index);
end;
public z_GetFloatIndexedvEXT_adr := GetFuncAdr('glGetFloatIndexedvEXT');
public z_GetFloatIndexedvEXT_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; var data: single)>(z_GetFloatIndexedvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFloatIndexedvEXT(target: DummyEnum; index: UInt32; data: array of single);
begin
z_GetFloatIndexedvEXT_ovr_0(target, index, data[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFloatIndexedvEXT(target: DummyEnum; index: UInt32; var data: single);
begin
z_GetFloatIndexedvEXT_ovr_0(target, index, data);
end;
public z_GetFloatIndexedvEXT_ovr_2 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; data: IntPtr)>(z_GetFloatIndexedvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFloatIndexedvEXT(target: DummyEnum; index: UInt32; data: IntPtr);
begin
z_GetFloatIndexedvEXT_ovr_2(target, index, data);
end;
public z_GetDoubleIndexedvEXT_adr := GetFuncAdr('glGetDoubleIndexedvEXT');
public z_GetDoubleIndexedvEXT_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; var data: real)>(z_GetDoubleIndexedvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDoubleIndexedvEXT(target: DummyEnum; index: UInt32; data: array of real);
begin
z_GetDoubleIndexedvEXT_ovr_0(target, index, data[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDoubleIndexedvEXT(target: DummyEnum; index: UInt32; var data: real);
begin
z_GetDoubleIndexedvEXT_ovr_0(target, index, data);
end;
public z_GetDoubleIndexedvEXT_ovr_2 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; data: IntPtr)>(z_GetDoubleIndexedvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDoubleIndexedvEXT(target: DummyEnum; index: UInt32; data: IntPtr);
begin
z_GetDoubleIndexedvEXT_ovr_2(target, index, data);
end;
public z_GetPointerIndexedvEXT_adr := GetFuncAdr('glGetPointerIndexedvEXT');
public z_GetPointerIndexedvEXT_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; var data: IntPtr)>(z_GetPointerIndexedvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPointerIndexedvEXT(target: DummyEnum; index: UInt32; data: array of IntPtr);
begin
z_GetPointerIndexedvEXT_ovr_0(target, index, data[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPointerIndexedvEXT(target: DummyEnum; index: UInt32; var data: IntPtr);
begin
z_GetPointerIndexedvEXT_ovr_0(target, index, data);
end;
public z_GetPointerIndexedvEXT_ovr_2 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; data: pointer)>(z_GetPointerIndexedvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPointerIndexedvEXT(target: DummyEnum; index: UInt32; data: pointer);
begin
z_GetPointerIndexedvEXT_ovr_2(target, index, data);
end;
public z_EnableIndexedEXT_adr := GetFuncAdr('glEnableIndexedEXT');
public z_EnableIndexedEXT_ovr_0 := GetFuncOrNil&<procedure(target: EnableCap; index: UInt32)>(z_EnableIndexedEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EnableIndexedEXT(target: EnableCap; index: UInt32);
begin
z_EnableIndexedEXT_ovr_0(target, index);
end;
public z_DisableIndexedEXT_adr := GetFuncAdr('glDisableIndexedEXT');
public z_DisableIndexedEXT_ovr_0 := GetFuncOrNil&<procedure(target: EnableCap; index: UInt32)>(z_DisableIndexedEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DisableIndexedEXT(target: EnableCap; index: UInt32);
begin
z_DisableIndexedEXT_ovr_0(target, index);
end;
public z_IsEnabledIndexedEXT_adr := GetFuncAdr('glIsEnabledIndexedEXT');
public z_IsEnabledIndexedEXT_ovr_0 := GetFuncOrNil&<function(target: EnableCap; index: UInt32): boolean>(z_IsEnabledIndexedEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsEnabledIndexedEXT(target: EnableCap; index: UInt32): boolean;
begin
Result := z_IsEnabledIndexedEXT_ovr_0(target, index);
end;
public z_GetIntegerIndexedvEXT_adr := GetFuncAdr('glGetIntegerIndexedvEXT');
public z_GetIntegerIndexedvEXT_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; var data: Int32)>(z_GetIntegerIndexedvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerIndexedvEXT(target: DummyEnum; index: UInt32; data: array of Int32);
begin
z_GetIntegerIndexedvEXT_ovr_0(target, index, data[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerIndexedvEXT(target: DummyEnum; index: UInt32; var data: Int32);
begin
z_GetIntegerIndexedvEXT_ovr_0(target, index, data);
end;
public z_GetIntegerIndexedvEXT_ovr_2 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; data: IntPtr)>(z_GetIntegerIndexedvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerIndexedvEXT(target: DummyEnum; index: UInt32; data: IntPtr);
begin
z_GetIntegerIndexedvEXT_ovr_2(target, index, data);
end;
public z_GetBooleanIndexedvEXT_adr := GetFuncAdr('glGetBooleanIndexedvEXT');
public z_GetBooleanIndexedvEXT_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; var data: boolean)>(z_GetBooleanIndexedvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanIndexedvEXT(target: BufferTargetARB; index: UInt32; data: array of boolean);
begin
z_GetBooleanIndexedvEXT_ovr_0(target, index, data[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanIndexedvEXT(target: BufferTargetARB; index: UInt32; var data: boolean);
begin
z_GetBooleanIndexedvEXT_ovr_0(target, index, data);
end;
public z_GetBooleanIndexedvEXT_ovr_2 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; data: IntPtr)>(z_GetBooleanIndexedvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanIndexedvEXT(target: BufferTargetARB; index: UInt32; data: IntPtr);
begin
z_GetBooleanIndexedvEXT_ovr_2(target, index, data);
end;
public z_CompressedTextureImage3DEXT_adr := GetFuncAdr('glCompressedTextureImage3DEXT');
public z_CompressedTextureImage3DEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; border: Int32; imageSize: Int32; bits: IntPtr)>(z_CompressedTextureImage3DEXT_adr);
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);
begin
z_CompressedTextureImage3DEXT_ovr_0(texture, target, level, _internalformat, width, height, depth, border, imageSize, bits);
end;
public z_CompressedTextureImage2DEXT_adr := GetFuncAdr('glCompressedTextureImage2DEXT');
public z_CompressedTextureImage2DEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; border: Int32; imageSize: Int32; bits: IntPtr)>(z_CompressedTextureImage2DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTextureImage2DEXT(texture: UInt32; target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; border: Int32; imageSize: Int32; bits: IntPtr);
begin
z_CompressedTextureImage2DEXT_ovr_0(texture, target, level, _internalformat, width, height, border, imageSize, bits);
end;
public z_CompressedTextureImage1DEXT_adr := GetFuncAdr('glCompressedTextureImage1DEXT');
public z_CompressedTextureImage1DEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; border: Int32; imageSize: Int32; bits: IntPtr)>(z_CompressedTextureImage1DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTextureImage1DEXT(texture: UInt32; target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; border: Int32; imageSize: Int32; bits: IntPtr);
begin
z_CompressedTextureImage1DEXT_ovr_0(texture, target, level, _internalformat, width, border, imageSize, bits);
end;
public z_CompressedTextureSubImage3DEXT_adr := GetFuncAdr('glCompressedTextureSubImage3DEXT');
public z_CompressedTextureSubImage3DEXT_ovr_0 := GetFuncOrNil&<procedure(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_adr);
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);
begin
z_CompressedTextureSubImage3DEXT_ovr_0(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);
end;
public z_CompressedTextureSubImage2DEXT_adr := GetFuncAdr('glCompressedTextureSubImage2DEXT');
public z_CompressedTextureSubImage2DEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; imageSize: Int32; bits: IntPtr)>(z_CompressedTextureSubImage2DEXT_adr);
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);
begin
z_CompressedTextureSubImage2DEXT_ovr_0(texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits);
end;
public z_CompressedTextureSubImage1DEXT_adr := GetFuncAdr('glCompressedTextureSubImage1DEXT');
public z_CompressedTextureSubImage1DEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; imageSize: Int32; bits: IntPtr)>(z_CompressedTextureSubImage1DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedTextureSubImage1DEXT(texture: UInt32; target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; imageSize: Int32; bits: IntPtr);
begin
z_CompressedTextureSubImage1DEXT_ovr_0(texture, target, level, xoffset, width, format, imageSize, bits);
end;
public z_GetCompressedTextureImageEXT_adr := GetFuncAdr('glGetCompressedTextureImageEXT');
public z_GetCompressedTextureImageEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; lod: Int32; img: IntPtr)>(z_GetCompressedTextureImageEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCompressedTextureImageEXT(texture: UInt32; target: TextureTarget; lod: Int32; img: IntPtr);
begin
z_GetCompressedTextureImageEXT_ovr_0(texture, target, lod, img);
end;
public z_CompressedMultiTexImage3DEXT_adr := GetFuncAdr('glCompressedMultiTexImage3DEXT');
public z_CompressedMultiTexImage3DEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; border: Int32; imageSize: Int32; bits: IntPtr)>(z_CompressedMultiTexImage3DEXT_adr);
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);
begin
z_CompressedMultiTexImage3DEXT_ovr_0(texunit, target, level, _internalformat, width, height, depth, border, imageSize, bits);
end;
public z_CompressedMultiTexImage2DEXT_adr := GetFuncAdr('glCompressedMultiTexImage2DEXT');
public z_CompressedMultiTexImage2DEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; border: Int32; imageSize: Int32; bits: IntPtr)>(z_CompressedMultiTexImage2DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedMultiTexImage2DEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; border: Int32; imageSize: Int32; bits: IntPtr);
begin
z_CompressedMultiTexImage2DEXT_ovr_0(texunit, target, level, _internalformat, width, height, border, imageSize, bits);
end;
public z_CompressedMultiTexImage1DEXT_adr := GetFuncAdr('glCompressedMultiTexImage1DEXT');
public z_CompressedMultiTexImage1DEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; border: Int32; imageSize: Int32; bits: IntPtr)>(z_CompressedMultiTexImage1DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedMultiTexImage1DEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; border: Int32; imageSize: Int32; bits: IntPtr);
begin
z_CompressedMultiTexImage1DEXT_ovr_0(texunit, target, level, _internalformat, width, border, imageSize, bits);
end;
public z_CompressedMultiTexSubImage3DEXT_adr := GetFuncAdr('glCompressedMultiTexSubImage3DEXT');
public z_CompressedMultiTexSubImage3DEXT_ovr_0 := GetFuncOrNil&<procedure(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_adr);
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);
begin
z_CompressedMultiTexSubImage3DEXT_ovr_0(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);
end;
public z_CompressedMultiTexSubImage2DEXT_adr := GetFuncAdr('glCompressedMultiTexSubImage2DEXT');
public z_CompressedMultiTexSubImage2DEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; imageSize: Int32; bits: IntPtr)>(z_CompressedMultiTexSubImage2DEXT_adr);
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);
begin
z_CompressedMultiTexSubImage2DEXT_ovr_0(texunit, target, level, xoffset, yoffset, width, height, format, imageSize, bits);
end;
public z_CompressedMultiTexSubImage1DEXT_adr := GetFuncAdr('glCompressedMultiTexSubImage1DEXT');
public z_CompressedMultiTexSubImage1DEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; imageSize: Int32; bits: IntPtr)>(z_CompressedMultiTexSubImage1DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompressedMultiTexSubImage1DEXT(texunit: TextureUnit; target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; imageSize: Int32; bits: IntPtr);
begin
z_CompressedMultiTexSubImage1DEXT_ovr_0(texunit, target, level, xoffset, width, format, imageSize, bits);
end;
public z_GetCompressedMultiTexImageEXT_adr := GetFuncAdr('glGetCompressedMultiTexImageEXT');
public z_GetCompressedMultiTexImageEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; lod: Int32; img: IntPtr)>(z_GetCompressedMultiTexImageEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCompressedMultiTexImageEXT(texunit: TextureUnit; target: TextureTarget; lod: Int32; img: IntPtr);
begin
z_GetCompressedMultiTexImageEXT_ovr_0(texunit, target, lod, img);
end;
public z_MatrixLoadTransposefEXT_adr := GetFuncAdr('glMatrixLoadTransposefEXT');
public z_MatrixLoadTransposefEXT_ovr_0 := GetFuncOrNil&<procedure(mode: MatrixMode; var m: single)>(z_MatrixLoadTransposefEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadTransposefEXT(mode: MatrixMode; m: array of single);
begin
z_MatrixLoadTransposefEXT_ovr_0(mode, m[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadTransposefEXT(mode: MatrixMode; var m: single);
begin
z_MatrixLoadTransposefEXT_ovr_0(mode, m);
end;
public z_MatrixLoadTransposefEXT_ovr_2 := GetFuncOrNil&<procedure(mode: MatrixMode; m: IntPtr)>(z_MatrixLoadTransposefEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadTransposefEXT(mode: MatrixMode; m: IntPtr);
begin
z_MatrixLoadTransposefEXT_ovr_2(mode, m);
end;
public z_MatrixLoadTransposedEXT_adr := GetFuncAdr('glMatrixLoadTransposedEXT');
public z_MatrixLoadTransposedEXT_ovr_0 := GetFuncOrNil&<procedure(mode: MatrixMode; var m: real)>(z_MatrixLoadTransposedEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadTransposedEXT(mode: MatrixMode; m: array of real);
begin
z_MatrixLoadTransposedEXT_ovr_0(mode, m[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadTransposedEXT(mode: MatrixMode; var m: real);
begin
z_MatrixLoadTransposedEXT_ovr_0(mode, m);
end;
public z_MatrixLoadTransposedEXT_ovr_2 := GetFuncOrNil&<procedure(mode: MatrixMode; m: IntPtr)>(z_MatrixLoadTransposedEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadTransposedEXT(mode: MatrixMode; m: IntPtr);
begin
z_MatrixLoadTransposedEXT_ovr_2(mode, m);
end;
public z_MatrixMultTransposefEXT_adr := GetFuncAdr('glMatrixMultTransposefEXT');
public z_MatrixMultTransposefEXT_ovr_0 := GetFuncOrNil&<procedure(mode: MatrixMode; var m: single)>(z_MatrixMultTransposefEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultTransposefEXT(mode: MatrixMode; m: array of single);
begin
z_MatrixMultTransposefEXT_ovr_0(mode, m[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultTransposefEXT(mode: MatrixMode; var m: single);
begin
z_MatrixMultTransposefEXT_ovr_0(mode, m);
end;
public z_MatrixMultTransposefEXT_ovr_2 := GetFuncOrNil&<procedure(mode: MatrixMode; m: IntPtr)>(z_MatrixMultTransposefEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultTransposefEXT(mode: MatrixMode; m: IntPtr);
begin
z_MatrixMultTransposefEXT_ovr_2(mode, m);
end;
public z_MatrixMultTransposedEXT_adr := GetFuncAdr('glMatrixMultTransposedEXT');
public z_MatrixMultTransposedEXT_ovr_0 := GetFuncOrNil&<procedure(mode: MatrixMode; var m: real)>(z_MatrixMultTransposedEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultTransposedEXT(mode: MatrixMode; m: array of real);
begin
z_MatrixMultTransposedEXT_ovr_0(mode, m[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultTransposedEXT(mode: MatrixMode; var m: real);
begin
z_MatrixMultTransposedEXT_ovr_0(mode, m);
end;
public z_MatrixMultTransposedEXT_ovr_2 := GetFuncOrNil&<procedure(mode: MatrixMode; m: IntPtr)>(z_MatrixMultTransposedEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultTransposedEXT(mode: MatrixMode; m: IntPtr);
begin
z_MatrixMultTransposedEXT_ovr_2(mode, m);
end;
public z_NamedBufferDataEXT_adr := GetFuncAdr('glNamedBufferDataEXT');
public z_NamedBufferDataEXT_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; size: IntPtr; data: IntPtr; usage: VertexBufferObjectUsage)>(z_NamedBufferDataEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferDataEXT(buffer: UInt32; size: IntPtr; data: IntPtr; usage: VertexBufferObjectUsage);
begin
z_NamedBufferDataEXT_ovr_0(buffer, size, data, usage);
end;
public z_NamedBufferSubDataEXT_adr := GetFuncAdr('glNamedBufferSubDataEXT');
public z_NamedBufferSubDataEXT_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; offset: IntPtr; size: IntPtr; data: IntPtr)>(z_NamedBufferSubDataEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferSubDataEXT(buffer: UInt32; offset: IntPtr; size: IntPtr; data: IntPtr);
begin
z_NamedBufferSubDataEXT_ovr_0(buffer, offset, size, data);
end;
public z_MapNamedBufferEXT_adr := GetFuncAdr('glMapNamedBufferEXT');
public z_MapNamedBufferEXT_ovr_0 := GetFuncOrNil&<function(buffer: UInt32; access: BufferAccessARB): IntPtr>(z_MapNamedBufferEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapNamedBufferEXT(buffer: UInt32; access: BufferAccessARB): IntPtr;
begin
Result := z_MapNamedBufferEXT_ovr_0(buffer, access);
end;
public z_UnmapNamedBufferEXT_adr := GetFuncAdr('glUnmapNamedBufferEXT');
public z_UnmapNamedBufferEXT_ovr_0 := GetFuncOrNil&<function(buffer: UInt32): boolean>(z_UnmapNamedBufferEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function UnmapNamedBufferEXT(buffer: UInt32): boolean;
begin
Result := z_UnmapNamedBufferEXT_ovr_0(buffer);
end;
public z_GetNamedBufferParameterivEXT_adr := GetFuncAdr('glGetNamedBufferParameterivEXT');
public z_GetNamedBufferParameterivEXT_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: Int32)>(z_GetNamedBufferParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameterivEXT(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: array of Int32);
begin
z_GetNamedBufferParameterivEXT_ovr_0(buffer, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameterivEXT(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: Int32);
begin
z_GetNamedBufferParameterivEXT_ovr_0(buffer, pname, ¶ms);
end;
public z_GetNamedBufferParameterivEXT_ovr_2 := GetFuncOrNil&<procedure(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: IntPtr)>(z_GetNamedBufferParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameterivEXT(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: IntPtr);
begin
z_GetNamedBufferParameterivEXT_ovr_2(buffer, pname, ¶ms);
end;
public z_GetNamedBufferPointervEXT_adr := GetFuncAdr('glGetNamedBufferPointervEXT');
public z_GetNamedBufferPointervEXT_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: IntPtr)>(z_GetNamedBufferPointervEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferPointervEXT(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: array of IntPtr);
begin
z_GetNamedBufferPointervEXT_ovr_0(buffer, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferPointervEXT(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: IntPtr);
begin
z_GetNamedBufferPointervEXT_ovr_0(buffer, pname, ¶ms);
end;
public z_GetNamedBufferPointervEXT_ovr_2 := GetFuncOrNil&<procedure(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: pointer)>(z_GetNamedBufferPointervEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferPointervEXT(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: pointer);
begin
z_GetNamedBufferPointervEXT_ovr_2(buffer, pname, ¶ms);
end;
public z_GetNamedBufferSubDataEXT_adr := GetFuncAdr('glGetNamedBufferSubDataEXT');
public z_GetNamedBufferSubDataEXT_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; offset: IntPtr; size: IntPtr; data: IntPtr)>(z_GetNamedBufferSubDataEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferSubDataEXT(buffer: UInt32; offset: IntPtr; size: IntPtr; data: IntPtr);
begin
z_GetNamedBufferSubDataEXT_ovr_0(buffer, offset, size, data);
end;
public z_ProgramUniform1fEXT_adr := GetFuncAdr('glProgramUniform1fEXT');
public z_ProgramUniform1fEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; v0: single)>(z_ProgramUniform1fEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1fEXT(&program: UInt32; location: Int32; v0: single);
begin
z_ProgramUniform1fEXT_ovr_0(&program, location, v0);
end;
public z_ProgramUniform2fEXT_adr := GetFuncAdr('glProgramUniform2fEXT');
public z_ProgramUniform2fEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; v0: single; v1: single)>(z_ProgramUniform2fEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2fEXT(&program: UInt32; location: Int32; v0: single; v1: single);
begin
z_ProgramUniform2fEXT_ovr_0(&program, location, v0, v1);
end;
public z_ProgramUniform3fEXT_adr := GetFuncAdr('glProgramUniform3fEXT');
public z_ProgramUniform3fEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; v0: single; v1: single; v2: single)>(z_ProgramUniform3fEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3fEXT(&program: UInt32; location: Int32; v0: single; v1: single; v2: single);
begin
z_ProgramUniform3fEXT_ovr_0(&program, location, v0, v1, v2);
end;
public z_ProgramUniform4fEXT_adr := GetFuncAdr('glProgramUniform4fEXT');
public z_ProgramUniform4fEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; v0: single; v1: single; v2: single; v3: single)>(z_ProgramUniform4fEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4fEXT(&program: UInt32; location: Int32; v0: single; v1: single; v2: single; v3: single);
begin
z_ProgramUniform4fEXT_ovr_0(&program, location, v0, v1, v2, v3);
end;
public z_ProgramUniform1iEXT_adr := GetFuncAdr('glProgramUniform1iEXT');
public z_ProgramUniform1iEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; v0: Int32)>(z_ProgramUniform1iEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1iEXT(&program: UInt32; location: Int32; v0: Int32);
begin
z_ProgramUniform1iEXT_ovr_0(&program, location, v0);
end;
public z_ProgramUniform2iEXT_adr := GetFuncAdr('glProgramUniform2iEXT');
public z_ProgramUniform2iEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; v0: Int32; v1: Int32)>(z_ProgramUniform2iEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2iEXT(&program: UInt32; location: Int32; v0: Int32; v1: Int32);
begin
z_ProgramUniform2iEXT_ovr_0(&program, location, v0, v1);
end;
public z_ProgramUniform3iEXT_adr := GetFuncAdr('glProgramUniform3iEXT');
public z_ProgramUniform3iEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; v0: Int32; v1: Int32; v2: Int32)>(z_ProgramUniform3iEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3iEXT(&program: UInt32; location: Int32; v0: Int32; v1: Int32; v2: Int32);
begin
z_ProgramUniform3iEXT_ovr_0(&program, location, v0, v1, v2);
end;
public z_ProgramUniform4iEXT_adr := GetFuncAdr('glProgramUniform4iEXT');
public z_ProgramUniform4iEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; v0: Int32; v1: Int32; v2: Int32; v3: Int32)>(z_ProgramUniform4iEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4iEXT(&program: UInt32; location: Int32; v0: Int32; v1: Int32; v2: Int32; v3: Int32);
begin
z_ProgramUniform4iEXT_ovr_0(&program, location, v0, v1, v2, v3);
end;
public z_ProgramUniform1fvEXT_adr := GetFuncAdr('glProgramUniform1fvEXT');
public z_ProgramUniform1fvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: single)>(z_ProgramUniform1fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1fvEXT(&program: UInt32; location: Int32; count: Int32; value: array of single);
begin
z_ProgramUniform1fvEXT_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1fvEXT(&program: UInt32; location: Int32; count: Int32; var value: single);
begin
z_ProgramUniform1fvEXT_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform1fvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform1fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1fvEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform1fvEXT_ovr_2(&program, location, count, value);
end;
public z_ProgramUniform2fvEXT_adr := GetFuncAdr('glProgramUniform2fvEXT');
public z_ProgramUniform2fvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: single)>(z_ProgramUniform2fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2fvEXT(&program: UInt32; location: Int32; count: Int32; value: array of single);
begin
z_ProgramUniform2fvEXT_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2fvEXT(&program: UInt32; location: Int32; count: Int32; var value: single);
begin
z_ProgramUniform2fvEXT_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform2fvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform2fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2fvEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform2fvEXT_ovr_2(&program, location, count, value);
end;
public z_ProgramUniform3fvEXT_adr := GetFuncAdr('glProgramUniform3fvEXT');
public z_ProgramUniform3fvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: single)>(z_ProgramUniform3fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3fvEXT(&program: UInt32; location: Int32; count: Int32; value: array of single);
begin
z_ProgramUniform3fvEXT_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3fvEXT(&program: UInt32; location: Int32; count: Int32; var value: single);
begin
z_ProgramUniform3fvEXT_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform3fvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform3fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3fvEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform3fvEXT_ovr_2(&program, location, count, value);
end;
public z_ProgramUniform4fvEXT_adr := GetFuncAdr('glProgramUniform4fvEXT');
public z_ProgramUniform4fvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: single)>(z_ProgramUniform4fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4fvEXT(&program: UInt32; location: Int32; count: Int32; value: array of single);
begin
z_ProgramUniform4fvEXT_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4fvEXT(&program: UInt32; location: Int32; count: Int32; var value: single);
begin
z_ProgramUniform4fvEXT_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform4fvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform4fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4fvEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform4fvEXT_ovr_2(&program, location, count, value);
end;
public z_ProgramUniform1ivEXT_adr := GetFuncAdr('glProgramUniform1ivEXT');
public z_ProgramUniform1ivEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: Int32)>(z_ProgramUniform1ivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ivEXT(&program: UInt32; location: Int32; count: Int32; value: array of Int32);
begin
z_ProgramUniform1ivEXT_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ivEXT(&program: UInt32; location: Int32; count: Int32; var value: Int32);
begin
z_ProgramUniform1ivEXT_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform1ivEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform1ivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ivEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform1ivEXT_ovr_2(&program, location, count, value);
end;
public z_ProgramUniform2ivEXT_adr := GetFuncAdr('glProgramUniform2ivEXT');
public z_ProgramUniform2ivEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: Int32)>(z_ProgramUniform2ivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ivEXT(&program: UInt32; location: Int32; count: Int32; value: array of Int32);
begin
z_ProgramUniform2ivEXT_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ivEXT(&program: UInt32; location: Int32; count: Int32; var value: Int32);
begin
z_ProgramUniform2ivEXT_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform2ivEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform2ivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ivEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform2ivEXT_ovr_2(&program, location, count, value);
end;
public z_ProgramUniform3ivEXT_adr := GetFuncAdr('glProgramUniform3ivEXT');
public z_ProgramUniform3ivEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: Int32)>(z_ProgramUniform3ivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ivEXT(&program: UInt32; location: Int32; count: Int32; value: array of Int32);
begin
z_ProgramUniform3ivEXT_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ivEXT(&program: UInt32; location: Int32; count: Int32; var value: Int32);
begin
z_ProgramUniform3ivEXT_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform3ivEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform3ivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ivEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform3ivEXT_ovr_2(&program, location, count, value);
end;
public z_ProgramUniform4ivEXT_adr := GetFuncAdr('glProgramUniform4ivEXT');
public z_ProgramUniform4ivEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: Int32)>(z_ProgramUniform4ivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ivEXT(&program: UInt32; location: Int32; count: Int32; value: array of Int32);
begin
z_ProgramUniform4ivEXT_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ivEXT(&program: UInt32; location: Int32; count: Int32; var value: Int32);
begin
z_ProgramUniform4ivEXT_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform4ivEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform4ivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ivEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform4ivEXT_ovr_2(&program, location, count, value);
end;
public z_ProgramUniformMatrix2fvEXT_adr := GetFuncAdr('glProgramUniformMatrix2fvEXT');
public z_ProgramUniformMatrix2fvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single)>(z_ProgramUniformMatrix2fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_ProgramUniformMatrix2fvEXT_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_ProgramUniformMatrix2fvEXT_ovr_0(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix2fvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix2fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
begin
z_ProgramUniformMatrix2fvEXT_ovr_2(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix3fvEXT_adr := GetFuncAdr('glProgramUniformMatrix3fvEXT');
public z_ProgramUniformMatrix3fvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single)>(z_ProgramUniformMatrix3fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_ProgramUniformMatrix3fvEXT_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_ProgramUniformMatrix3fvEXT_ovr_0(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix3fvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix3fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
begin
z_ProgramUniformMatrix3fvEXT_ovr_2(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix4fvEXT_adr := GetFuncAdr('glProgramUniformMatrix4fvEXT');
public z_ProgramUniformMatrix4fvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single)>(z_ProgramUniformMatrix4fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_ProgramUniformMatrix4fvEXT_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_ProgramUniformMatrix4fvEXT_ovr_0(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix4fvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix4fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
begin
z_ProgramUniformMatrix4fvEXT_ovr_2(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix2x3fvEXT_adr := GetFuncAdr('glProgramUniformMatrix2x3fvEXT');
public z_ProgramUniformMatrix2x3fvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single)>(z_ProgramUniformMatrix2x3fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_ProgramUniformMatrix2x3fvEXT_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_ProgramUniformMatrix2x3fvEXT_ovr_0(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix2x3fvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix2x3fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
begin
z_ProgramUniformMatrix2x3fvEXT_ovr_2(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix3x2fvEXT_adr := GetFuncAdr('glProgramUniformMatrix3x2fvEXT');
public z_ProgramUniformMatrix3x2fvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single)>(z_ProgramUniformMatrix3x2fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_ProgramUniformMatrix3x2fvEXT_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_ProgramUniformMatrix3x2fvEXT_ovr_0(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix3x2fvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix3x2fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
begin
z_ProgramUniformMatrix3x2fvEXT_ovr_2(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix2x4fvEXT_adr := GetFuncAdr('glProgramUniformMatrix2x4fvEXT');
public z_ProgramUniformMatrix2x4fvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single)>(z_ProgramUniformMatrix2x4fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_ProgramUniformMatrix2x4fvEXT_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_ProgramUniformMatrix2x4fvEXT_ovr_0(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix2x4fvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix2x4fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
begin
z_ProgramUniformMatrix2x4fvEXT_ovr_2(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix4x2fvEXT_adr := GetFuncAdr('glProgramUniformMatrix4x2fvEXT');
public z_ProgramUniformMatrix4x2fvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single)>(z_ProgramUniformMatrix4x2fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_ProgramUniformMatrix4x2fvEXT_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_ProgramUniformMatrix4x2fvEXT_ovr_0(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix4x2fvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix4x2fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
begin
z_ProgramUniformMatrix4x2fvEXT_ovr_2(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix3x4fvEXT_adr := GetFuncAdr('glProgramUniformMatrix3x4fvEXT');
public z_ProgramUniformMatrix3x4fvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single)>(z_ProgramUniformMatrix3x4fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_ProgramUniformMatrix3x4fvEXT_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_ProgramUniformMatrix3x4fvEXT_ovr_0(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix3x4fvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix3x4fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
begin
z_ProgramUniformMatrix3x4fvEXT_ovr_2(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix4x3fvEXT_adr := GetFuncAdr('glProgramUniformMatrix4x3fvEXT');
public z_ProgramUniformMatrix4x3fvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single)>(z_ProgramUniformMatrix4x3fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of single);
begin
z_ProgramUniformMatrix4x3fvEXT_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: single);
begin
z_ProgramUniformMatrix4x3fvEXT_ovr_0(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix4x3fvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix4x3fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3fvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
begin
z_ProgramUniformMatrix4x3fvEXT_ovr_2(&program, location, count, transpose, value);
end;
public z_TextureBufferEXT_adr := GetFuncAdr('glTextureBufferEXT');
public z_TextureBufferEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; _internalformat: InternalFormat; buffer: UInt32)>(z_TextureBufferEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureBufferEXT(texture: UInt32; target: TextureTarget; _internalformat: InternalFormat; buffer: UInt32);
begin
z_TextureBufferEXT_ovr_0(texture, target, _internalformat, buffer);
end;
public z_MultiTexBufferEXT_adr := GetFuncAdr('glMultiTexBufferEXT');
public z_MultiTexBufferEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; internalformat: DummyEnum; buffer: UInt32)>(z_MultiTexBufferEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexBufferEXT(texunit: TextureUnit; target: TextureTarget; internalformat: DummyEnum; buffer: UInt32);
begin
z_MultiTexBufferEXT_ovr_0(texunit, target, internalformat, buffer);
end;
public z_TextureParameterIivEXT_adr := GetFuncAdr('glTextureParameterIivEXT');
public z_TextureParameterIivEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32)>(z_TextureParameterIivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIivEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: array of Int32);
begin
z_TextureParameterIivEXT_ovr_0(texture, target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIivEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32);
begin
z_TextureParameterIivEXT_ovr_0(texture, target, pname, ¶ms);
end;
public z_TextureParameterIivEXT_ovr_2 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr)>(z_TextureParameterIivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIivEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
begin
z_TextureParameterIivEXT_ovr_2(texture, target, pname, ¶ms);
end;
public z_TextureParameterIuivEXT_adr := GetFuncAdr('glTextureParameterIuivEXT');
public z_TextureParameterIuivEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; pname: TextureParameterName; var ¶ms: UInt32)>(z_TextureParameterIuivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIuivEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: array of UInt32);
begin
z_TextureParameterIuivEXT_ovr_0(texture, target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIuivEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; var ¶ms: UInt32);
begin
z_TextureParameterIuivEXT_ovr_0(texture, target, pname, ¶ms);
end;
public z_TextureParameterIuivEXT_ovr_2 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr)>(z_TextureParameterIuivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureParameterIuivEXT(texture: UInt32; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
begin
z_TextureParameterIuivEXT_ovr_2(texture, target, pname, ¶ms);
end;
public z_GetTextureParameterIivEXT_adr := GetFuncAdr('glGetTextureParameterIivEXT');
public z_GetTextureParameterIivEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32)>(z_GetTextureParameterIivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIivEXT(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: array of Int32);
begin
z_GetTextureParameterIivEXT_ovr_0(texture, target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIivEXT(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32);
begin
z_GetTextureParameterIivEXT_ovr_0(texture, target, pname, ¶ms);
end;
public z_GetTextureParameterIivEXT_ovr_2 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetTextureParameterIivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIivEXT(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
begin
z_GetTextureParameterIivEXT_ovr_2(texture, target, pname, ¶ms);
end;
public z_GetTextureParameterIuivEXT_adr := GetFuncAdr('glGetTextureParameterIuivEXT');
public z_GetTextureParameterIuivEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; var ¶ms: UInt32)>(z_GetTextureParameterIuivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIuivEXT(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: array of UInt32);
begin
z_GetTextureParameterIuivEXT_ovr_0(texture, target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIuivEXT(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; var ¶ms: UInt32);
begin
z_GetTextureParameterIuivEXT_ovr_0(texture, target, pname, ¶ms);
end;
public z_GetTextureParameterIuivEXT_ovr_2 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetTextureParameterIuivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTextureParameterIuivEXT(texture: UInt32; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
begin
z_GetTextureParameterIuivEXT_ovr_2(texture, target, pname, ¶ms);
end;
public z_MultiTexParameterIivEXT_adr := GetFuncAdr('glMultiTexParameterIivEXT');
public z_MultiTexParameterIivEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32)>(z_MultiTexParameterIivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameterIivEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: array of Int32);
begin
z_MultiTexParameterIivEXT_ovr_0(texunit, target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameterIivEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32);
begin
z_MultiTexParameterIivEXT_ovr_0(texunit, target, pname, ¶ms);
end;
public z_MultiTexParameterIivEXT_ovr_2 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr)>(z_MultiTexParameterIivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameterIivEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
begin
z_MultiTexParameterIivEXT_ovr_2(texunit, target, pname, ¶ms);
end;
public z_MultiTexParameterIuivEXT_adr := GetFuncAdr('glMultiTexParameterIuivEXT');
public z_MultiTexParameterIuivEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; var ¶ms: UInt32)>(z_MultiTexParameterIuivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameterIuivEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: array of UInt32);
begin
z_MultiTexParameterIuivEXT_ovr_0(texunit, target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameterIuivEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; var ¶ms: UInt32);
begin
z_MultiTexParameterIuivEXT_ovr_0(texunit, target, pname, ¶ms);
end;
public z_MultiTexParameterIuivEXT_ovr_2 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr)>(z_MultiTexParameterIuivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexParameterIuivEXT(texunit: TextureUnit; target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
begin
z_MultiTexParameterIuivEXT_ovr_2(texunit, target, pname, ¶ms);
end;
public z_GetMultiTexParameterIivEXT_adr := GetFuncAdr('glGetMultiTexParameterIivEXT');
public z_GetMultiTexParameterIivEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32)>(z_GetMultiTexParameterIivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexParameterIivEXT(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: array of Int32);
begin
z_GetMultiTexParameterIivEXT_ovr_0(texunit, target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexParameterIivEXT(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32);
begin
z_GetMultiTexParameterIivEXT_ovr_0(texunit, target, pname, ¶ms);
end;
public z_GetMultiTexParameterIivEXT_ovr_2 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetMultiTexParameterIivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexParameterIivEXT(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
begin
z_GetMultiTexParameterIivEXT_ovr_2(texunit, target, pname, ¶ms);
end;
public z_GetMultiTexParameterIuivEXT_adr := GetFuncAdr('glGetMultiTexParameterIuivEXT');
public z_GetMultiTexParameterIuivEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; var ¶ms: UInt32)>(z_GetMultiTexParameterIuivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexParameterIuivEXT(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: array of UInt32);
begin
z_GetMultiTexParameterIuivEXT_ovr_0(texunit, target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexParameterIuivEXT(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; var ¶ms: UInt32);
begin
z_GetMultiTexParameterIuivEXT_ovr_0(texunit, target, pname, ¶ms);
end;
public z_GetMultiTexParameterIuivEXT_ovr_2 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetMultiTexParameterIuivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultiTexParameterIuivEXT(texunit: TextureUnit; target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
begin
z_GetMultiTexParameterIuivEXT_ovr_2(texunit, target, pname, ¶ms);
end;
public z_ProgramUniform1uiEXT_adr := GetFuncAdr('glProgramUniform1uiEXT');
public z_ProgramUniform1uiEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; v0: UInt32)>(z_ProgramUniform1uiEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1uiEXT(&program: UInt32; location: Int32; v0: UInt32);
begin
z_ProgramUniform1uiEXT_ovr_0(&program, location, v0);
end;
public z_ProgramUniform2uiEXT_adr := GetFuncAdr('glProgramUniform2uiEXT');
public z_ProgramUniform2uiEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; v0: UInt32; v1: UInt32)>(z_ProgramUniform2uiEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2uiEXT(&program: UInt32; location: Int32; v0: UInt32; v1: UInt32);
begin
z_ProgramUniform2uiEXT_ovr_0(&program, location, v0, v1);
end;
public z_ProgramUniform3uiEXT_adr := GetFuncAdr('glProgramUniform3uiEXT');
public z_ProgramUniform3uiEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; v0: UInt32; v1: UInt32; v2: UInt32)>(z_ProgramUniform3uiEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3uiEXT(&program: UInt32; location: Int32; v0: UInt32; v1: UInt32; v2: UInt32);
begin
z_ProgramUniform3uiEXT_ovr_0(&program, location, v0, v1, v2);
end;
public z_ProgramUniform4uiEXT_adr := GetFuncAdr('glProgramUniform4uiEXT');
public z_ProgramUniform4uiEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; v0: UInt32; v1: UInt32; v2: UInt32; v3: UInt32)>(z_ProgramUniform4uiEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4uiEXT(&program: UInt32; location: Int32; v0: UInt32; v1: UInt32; v2: UInt32; v3: UInt32);
begin
z_ProgramUniform4uiEXT_ovr_0(&program, location, v0, v1, v2, v3);
end;
public z_ProgramUniform1uivEXT_adr := GetFuncAdr('glProgramUniform1uivEXT');
public z_ProgramUniform1uivEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: UInt32)>(z_ProgramUniform1uivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1uivEXT(&program: UInt32; location: Int32; count: Int32; value: array of UInt32);
begin
z_ProgramUniform1uivEXT_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1uivEXT(&program: UInt32; location: Int32; count: Int32; var value: UInt32);
begin
z_ProgramUniform1uivEXT_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform1uivEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform1uivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1uivEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform1uivEXT_ovr_2(&program, location, count, value);
end;
public z_ProgramUniform2uivEXT_adr := GetFuncAdr('glProgramUniform2uivEXT');
public z_ProgramUniform2uivEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: UInt32)>(z_ProgramUniform2uivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2uivEXT(&program: UInt32; location: Int32; count: Int32; value: array of UInt32);
begin
z_ProgramUniform2uivEXT_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2uivEXT(&program: UInt32; location: Int32; count: Int32; var value: UInt32);
begin
z_ProgramUniform2uivEXT_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform2uivEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform2uivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2uivEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform2uivEXT_ovr_2(&program, location, count, value);
end;
public z_ProgramUniform3uivEXT_adr := GetFuncAdr('glProgramUniform3uivEXT');
public z_ProgramUniform3uivEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: UInt32)>(z_ProgramUniform3uivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3uivEXT(&program: UInt32; location: Int32; count: Int32; value: array of UInt32);
begin
z_ProgramUniform3uivEXT_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3uivEXT(&program: UInt32; location: Int32; count: Int32; var value: UInt32);
begin
z_ProgramUniform3uivEXT_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform3uivEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform3uivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3uivEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform3uivEXT_ovr_2(&program, location, count, value);
end;
public z_ProgramUniform4uivEXT_adr := GetFuncAdr('glProgramUniform4uivEXT');
public z_ProgramUniform4uivEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: UInt32)>(z_ProgramUniform4uivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4uivEXT(&program: UInt32; location: Int32; count: Int32; value: array of UInt32);
begin
z_ProgramUniform4uivEXT_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4uivEXT(&program: UInt32; location: Int32; count: Int32; var value: UInt32);
begin
z_ProgramUniform4uivEXT_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform4uivEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform4uivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4uivEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform4uivEXT_ovr_2(&program, location, count, value);
end;
public z_NamedProgramLocalParameters4fvEXT_adr := GetFuncAdr('glNamedProgramLocalParameters4fvEXT');
public z_NamedProgramLocalParameters4fvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: single)>(z_NamedProgramLocalParameters4fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameters4fvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; ¶ms: array of single);
begin
z_NamedProgramLocalParameters4fvEXT_ovr_0(&program, target, index, count, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameters4fvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: single);
begin
z_NamedProgramLocalParameters4fvEXT_ovr_0(&program, target, index, count, ¶ms);
end;
public z_NamedProgramLocalParameters4fvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr)>(z_NamedProgramLocalParameters4fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameters4fvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr);
begin
z_NamedProgramLocalParameters4fvEXT_ovr_2(&program, target, index, count, ¶ms);
end;
public z_NamedProgramLocalParameterI4iEXT_adr := GetFuncAdr('glNamedProgramLocalParameterI4iEXT');
public z_NamedProgramLocalParameterI4iEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; index: UInt32; x: Int32; y: Int32; z: Int32; w: Int32)>(z_NamedProgramLocalParameterI4iEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameterI4iEXT(&program: UInt32; target: ProgramTarget; index: UInt32; x: Int32; y: Int32; z: Int32; w: Int32);
begin
z_NamedProgramLocalParameterI4iEXT_ovr_0(&program, target, index, x, y, z, w);
end;
public z_NamedProgramLocalParameterI4ivEXT_adr := GetFuncAdr('glNamedProgramLocalParameterI4ivEXT');
public z_NamedProgramLocalParameterI4ivEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: Int32)>(z_NamedProgramLocalParameterI4ivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameterI4ivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: array of Int32);
begin
z_NamedProgramLocalParameterI4ivEXT_ovr_0(&program, target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameterI4ivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: Int32);
begin
z_NamedProgramLocalParameterI4ivEXT_ovr_0(&program, target, index, ¶ms);
end;
public z_NamedProgramLocalParameterI4ivEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_NamedProgramLocalParameterI4ivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameterI4ivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_NamedProgramLocalParameterI4ivEXT_ovr_2(&program, target, index, ¶ms);
end;
public z_NamedProgramLocalParametersI4ivEXT_adr := GetFuncAdr('glNamedProgramLocalParametersI4ivEXT');
public z_NamedProgramLocalParametersI4ivEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: Int32)>(z_NamedProgramLocalParametersI4ivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParametersI4ivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; ¶ms: array of Int32);
begin
z_NamedProgramLocalParametersI4ivEXT_ovr_0(&program, target, index, count, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParametersI4ivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: Int32);
begin
z_NamedProgramLocalParametersI4ivEXT_ovr_0(&program, target, index, count, ¶ms);
end;
public z_NamedProgramLocalParametersI4ivEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr)>(z_NamedProgramLocalParametersI4ivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParametersI4ivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr);
begin
z_NamedProgramLocalParametersI4ivEXT_ovr_2(&program, target, index, count, ¶ms);
end;
public z_NamedProgramLocalParameterI4uiEXT_adr := GetFuncAdr('glNamedProgramLocalParameterI4uiEXT');
public z_NamedProgramLocalParameterI4uiEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; index: UInt32; x: UInt32; y: UInt32; z: UInt32; w: UInt32)>(z_NamedProgramLocalParameterI4uiEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameterI4uiEXT(&program: UInt32; target: ProgramTarget; index: UInt32; x: UInt32; y: UInt32; z: UInt32; w: UInt32);
begin
z_NamedProgramLocalParameterI4uiEXT_ovr_0(&program, target, index, x, y, z, w);
end;
public z_NamedProgramLocalParameterI4uivEXT_adr := GetFuncAdr('glNamedProgramLocalParameterI4uivEXT');
public z_NamedProgramLocalParameterI4uivEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: UInt32)>(z_NamedProgramLocalParameterI4uivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameterI4uivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: array of UInt32);
begin
z_NamedProgramLocalParameterI4uivEXT_ovr_0(&program, target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameterI4uivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: UInt32);
begin
z_NamedProgramLocalParameterI4uivEXT_ovr_0(&program, target, index, ¶ms);
end;
public z_NamedProgramLocalParameterI4uivEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_NamedProgramLocalParameterI4uivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameterI4uivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_NamedProgramLocalParameterI4uivEXT_ovr_2(&program, target, index, ¶ms);
end;
public z_NamedProgramLocalParametersI4uivEXT_adr := GetFuncAdr('glNamedProgramLocalParametersI4uivEXT');
public z_NamedProgramLocalParametersI4uivEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: UInt32)>(z_NamedProgramLocalParametersI4uivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParametersI4uivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; ¶ms: array of UInt32);
begin
z_NamedProgramLocalParametersI4uivEXT_ovr_0(&program, target, index, count, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParametersI4uivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: UInt32);
begin
z_NamedProgramLocalParametersI4uivEXT_ovr_0(&program, target, index, count, ¶ms);
end;
public z_NamedProgramLocalParametersI4uivEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr)>(z_NamedProgramLocalParametersI4uivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParametersI4uivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr);
begin
z_NamedProgramLocalParametersI4uivEXT_ovr_2(&program, target, index, count, ¶ms);
end;
public z_GetNamedProgramLocalParameterIivEXT_adr := GetFuncAdr('glGetNamedProgramLocalParameterIivEXT');
public z_GetNamedProgramLocalParameterIivEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: Int32)>(z_GetNamedProgramLocalParameterIivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramLocalParameterIivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: array of Int32);
begin
z_GetNamedProgramLocalParameterIivEXT_ovr_0(&program, target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramLocalParameterIivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: Int32);
begin
z_GetNamedProgramLocalParameterIivEXT_ovr_0(&program, target, index, ¶ms);
end;
public z_GetNamedProgramLocalParameterIivEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_GetNamedProgramLocalParameterIivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramLocalParameterIivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_GetNamedProgramLocalParameterIivEXT_ovr_2(&program, target, index, ¶ms);
end;
public z_GetNamedProgramLocalParameterIuivEXT_adr := GetFuncAdr('glGetNamedProgramLocalParameterIuivEXT');
public z_GetNamedProgramLocalParameterIuivEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: UInt32)>(z_GetNamedProgramLocalParameterIuivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramLocalParameterIuivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: array of UInt32);
begin
z_GetNamedProgramLocalParameterIuivEXT_ovr_0(&program, target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramLocalParameterIuivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: UInt32);
begin
z_GetNamedProgramLocalParameterIuivEXT_ovr_0(&program, target, index, ¶ms);
end;
public z_GetNamedProgramLocalParameterIuivEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_GetNamedProgramLocalParameterIuivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramLocalParameterIuivEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_GetNamedProgramLocalParameterIuivEXT_ovr_2(&program, target, index, ¶ms);
end;
public z_EnableClientStateiEXT_adr := GetFuncAdr('glEnableClientStateiEXT');
public z_EnableClientStateiEXT_ovr_0 := GetFuncOrNil&<procedure(&array: EnableCap; index: UInt32)>(z_EnableClientStateiEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EnableClientStateiEXT(&array: EnableCap; index: UInt32);
begin
z_EnableClientStateiEXT_ovr_0(&array, index);
end;
public z_DisableClientStateiEXT_adr := GetFuncAdr('glDisableClientStateiEXT');
public z_DisableClientStateiEXT_ovr_0 := GetFuncOrNil&<procedure(&array: EnableCap; index: UInt32)>(z_DisableClientStateiEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DisableClientStateiEXT(&array: EnableCap; index: UInt32);
begin
z_DisableClientStateiEXT_ovr_0(&array, index);
end;
public z_GetFloati_vEXT_adr := GetFuncAdr('glGetFloati_vEXT');
public z_GetFloati_vEXT_ovr_0 := GetFuncOrNil&<procedure(pname: DummyEnum; index: UInt32; var ¶ms: single)>(z_GetFloati_vEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFloati_vEXT(pname: DummyEnum; index: UInt32; ¶ms: array of single);
begin
z_GetFloati_vEXT_ovr_0(pname, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFloati_vEXT(pname: DummyEnum; index: UInt32; var ¶ms: single);
begin
z_GetFloati_vEXT_ovr_0(pname, index, ¶ms);
end;
public z_GetFloati_vEXT_ovr_2 := GetFuncOrNil&<procedure(pname: DummyEnum; index: UInt32; ¶ms: IntPtr)>(z_GetFloati_vEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFloati_vEXT(pname: DummyEnum; index: UInt32; ¶ms: IntPtr);
begin
z_GetFloati_vEXT_ovr_2(pname, index, ¶ms);
end;
public z_GetDoublei_vEXT_adr := GetFuncAdr('glGetDoublei_vEXT');
public z_GetDoublei_vEXT_ovr_0 := GetFuncOrNil&<procedure(pname: DummyEnum; index: UInt32; var ¶ms: real)>(z_GetDoublei_vEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDoublei_vEXT(pname: DummyEnum; index: UInt32; ¶ms: array of real);
begin
z_GetDoublei_vEXT_ovr_0(pname, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDoublei_vEXT(pname: DummyEnum; index: UInt32; var ¶ms: real);
begin
z_GetDoublei_vEXT_ovr_0(pname, index, ¶ms);
end;
public z_GetDoublei_vEXT_ovr_2 := GetFuncOrNil&<procedure(pname: DummyEnum; index: UInt32; ¶ms: IntPtr)>(z_GetDoublei_vEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDoublei_vEXT(pname: DummyEnum; index: UInt32; ¶ms: IntPtr);
begin
z_GetDoublei_vEXT_ovr_2(pname, index, ¶ms);
end;
public z_GetPointeri_vEXT_adr := GetFuncAdr('glGetPointeri_vEXT');
public z_GetPointeri_vEXT_ovr_0 := GetFuncOrNil&<procedure(pname: DummyEnum; index: UInt32; var ¶ms: IntPtr)>(z_GetPointeri_vEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPointeri_vEXT(pname: DummyEnum; index: UInt32; ¶ms: array of IntPtr);
begin
z_GetPointeri_vEXT_ovr_0(pname, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPointeri_vEXT(pname: DummyEnum; index: UInt32; var ¶ms: IntPtr);
begin
z_GetPointeri_vEXT_ovr_0(pname, index, ¶ms);
end;
public z_GetPointeri_vEXT_ovr_2 := GetFuncOrNil&<procedure(pname: DummyEnum; index: UInt32; ¶ms: pointer)>(z_GetPointeri_vEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPointeri_vEXT(pname: DummyEnum; index: UInt32; ¶ms: pointer);
begin
z_GetPointeri_vEXT_ovr_2(pname, index, ¶ms);
end;
public z_NamedProgramStringEXT_adr := GetFuncAdr('glNamedProgramStringEXT');
public z_NamedProgramStringEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; format: ProgramFormat; len: Int32; string: IntPtr)>(z_NamedProgramStringEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramStringEXT(&program: UInt32; target: ProgramTarget; format: ProgramFormat; len: Int32; string: IntPtr);
begin
z_NamedProgramStringEXT_ovr_0(&program, target, format, len, string);
end;
public z_NamedProgramLocalParameter4dEXT_adr := GetFuncAdr('glNamedProgramLocalParameter4dEXT');
public z_NamedProgramLocalParameter4dEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; index: UInt32; x: real; y: real; z: real; w: real)>(z_NamedProgramLocalParameter4dEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameter4dEXT(&program: UInt32; target: ProgramTarget; index: UInt32; x: real; y: real; z: real; w: real);
begin
z_NamedProgramLocalParameter4dEXT_ovr_0(&program, target, index, x, y, z, w);
end;
public z_NamedProgramLocalParameter4dvEXT_adr := GetFuncAdr('glNamedProgramLocalParameter4dvEXT');
public z_NamedProgramLocalParameter4dvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: real)>(z_NamedProgramLocalParameter4dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameter4dvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: array of real);
begin
z_NamedProgramLocalParameter4dvEXT_ovr_0(&program, target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameter4dvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: real);
begin
z_NamedProgramLocalParameter4dvEXT_ovr_0(&program, target, index, ¶ms);
end;
public z_NamedProgramLocalParameter4dvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_NamedProgramLocalParameter4dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameter4dvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_NamedProgramLocalParameter4dvEXT_ovr_2(&program, target, index, ¶ms);
end;
public z_NamedProgramLocalParameter4fEXT_adr := GetFuncAdr('glNamedProgramLocalParameter4fEXT');
public z_NamedProgramLocalParameter4fEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; index: UInt32; x: single; y: single; z: single; w: single)>(z_NamedProgramLocalParameter4fEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameter4fEXT(&program: UInt32; target: ProgramTarget; index: UInt32; x: single; y: single; z: single; w: single);
begin
z_NamedProgramLocalParameter4fEXT_ovr_0(&program, target, index, x, y, z, w);
end;
public z_NamedProgramLocalParameter4fvEXT_adr := GetFuncAdr('glNamedProgramLocalParameter4fvEXT');
public z_NamedProgramLocalParameter4fvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: single)>(z_NamedProgramLocalParameter4fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameter4fvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: array of single);
begin
z_NamedProgramLocalParameter4fvEXT_ovr_0(&program, target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameter4fvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: single);
begin
z_NamedProgramLocalParameter4fvEXT_ovr_0(&program, target, index, ¶ms);
end;
public z_NamedProgramLocalParameter4fvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_NamedProgramLocalParameter4fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedProgramLocalParameter4fvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_NamedProgramLocalParameter4fvEXT_ovr_2(&program, target, index, ¶ms);
end;
public z_GetNamedProgramLocalParameterdvEXT_adr := GetFuncAdr('glGetNamedProgramLocalParameterdvEXT');
public z_GetNamedProgramLocalParameterdvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: real)>(z_GetNamedProgramLocalParameterdvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramLocalParameterdvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: array of real);
begin
z_GetNamedProgramLocalParameterdvEXT_ovr_0(&program, target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramLocalParameterdvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: real);
begin
z_GetNamedProgramLocalParameterdvEXT_ovr_0(&program, target, index, ¶ms);
end;
public z_GetNamedProgramLocalParameterdvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_GetNamedProgramLocalParameterdvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramLocalParameterdvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_GetNamedProgramLocalParameterdvEXT_ovr_2(&program, target, index, ¶ms);
end;
public z_GetNamedProgramLocalParameterfvEXT_adr := GetFuncAdr('glGetNamedProgramLocalParameterfvEXT');
public z_GetNamedProgramLocalParameterfvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: single)>(z_GetNamedProgramLocalParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramLocalParameterfvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: array of single);
begin
z_GetNamedProgramLocalParameterfvEXT_ovr_0(&program, target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramLocalParameterfvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; var ¶ms: single);
begin
z_GetNamedProgramLocalParameterfvEXT_ovr_0(&program, target, index, ¶ms);
end;
public z_GetNamedProgramLocalParameterfvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_GetNamedProgramLocalParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramLocalParameterfvEXT(&program: UInt32; target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_GetNamedProgramLocalParameterfvEXT_ovr_2(&program, target, index, ¶ms);
end;
public z_GetNamedProgramivEXT_adr := GetFuncAdr('glGetNamedProgramivEXT');
public z_GetNamedProgramivEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; pname: ProgramPropertyARB; var ¶ms: Int32)>(z_GetNamedProgramivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramivEXT(&program: UInt32; target: ProgramTarget; pname: ProgramPropertyARB; ¶ms: array of Int32);
begin
z_GetNamedProgramivEXT_ovr_0(&program, target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramivEXT(&program: UInt32; target: ProgramTarget; pname: ProgramPropertyARB; var ¶ms: Int32);
begin
z_GetNamedProgramivEXT_ovr_0(&program, target, pname, ¶ms);
end;
public z_GetNamedProgramivEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; pname: ProgramPropertyARB; ¶ms: IntPtr)>(z_GetNamedProgramivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramivEXT(&program: UInt32; target: ProgramTarget; pname: ProgramPropertyARB; ¶ms: IntPtr);
begin
z_GetNamedProgramivEXT_ovr_2(&program, target, pname, ¶ms);
end;
public z_GetNamedProgramStringEXT_adr := GetFuncAdr('glGetNamedProgramStringEXT');
public z_GetNamedProgramStringEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; target: ProgramTarget; pname: ProgramStringProperty; string: IntPtr)>(z_GetNamedProgramStringEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedProgramStringEXT(&program: UInt32; target: ProgramTarget; pname: ProgramStringProperty; string: IntPtr);
begin
z_GetNamedProgramStringEXT_ovr_0(&program, target, pname, string);
end;
public z_NamedRenderbufferStorageEXT_adr := GetFuncAdr('glNamedRenderbufferStorageEXT');
public z_NamedRenderbufferStorageEXT_ovr_0 := GetFuncOrNil&<procedure(renderbuffer: UInt32; _internalformat: InternalFormat; width: Int32; height: Int32)>(z_NamedRenderbufferStorageEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedRenderbufferStorageEXT(renderbuffer: UInt32; _internalformat: InternalFormat; width: Int32; height: Int32);
begin
z_NamedRenderbufferStorageEXT_ovr_0(renderbuffer, _internalformat, width, height);
end;
public z_GetNamedRenderbufferParameterivEXT_adr := GetFuncAdr('glGetNamedRenderbufferParameterivEXT');
public z_GetNamedRenderbufferParameterivEXT_ovr_0 := GetFuncOrNil&<procedure(renderbuffer: UInt32; pname: RenderbufferParameterName; var ¶ms: Int32)>(z_GetNamedRenderbufferParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedRenderbufferParameterivEXT(renderbuffer: UInt32; pname: RenderbufferParameterName; ¶ms: array of Int32);
begin
z_GetNamedRenderbufferParameterivEXT_ovr_0(renderbuffer, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedRenderbufferParameterivEXT(renderbuffer: UInt32; pname: RenderbufferParameterName; var ¶ms: Int32);
begin
z_GetNamedRenderbufferParameterivEXT_ovr_0(renderbuffer, pname, ¶ms);
end;
public z_GetNamedRenderbufferParameterivEXT_ovr_2 := GetFuncOrNil&<procedure(renderbuffer: UInt32; pname: RenderbufferParameterName; ¶ms: IntPtr)>(z_GetNamedRenderbufferParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedRenderbufferParameterivEXT(renderbuffer: UInt32; pname: RenderbufferParameterName; ¶ms: IntPtr);
begin
z_GetNamedRenderbufferParameterivEXT_ovr_2(renderbuffer, pname, ¶ms);
end;
public z_NamedRenderbufferStorageMultisampleEXT_adr := GetFuncAdr('glNamedRenderbufferStorageMultisampleEXT');
public z_NamedRenderbufferStorageMultisampleEXT_ovr_0 := GetFuncOrNil&<procedure(renderbuffer: UInt32; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32)>(z_NamedRenderbufferStorageMultisampleEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedRenderbufferStorageMultisampleEXT(renderbuffer: UInt32; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32);
begin
z_NamedRenderbufferStorageMultisampleEXT_ovr_0(renderbuffer, samples, _internalformat, width, height);
end;
public z_NamedRenderbufferStorageMultisampleCoverageEXT_adr := GetFuncAdr('glNamedRenderbufferStorageMultisampleCoverageEXT');
public z_NamedRenderbufferStorageMultisampleCoverageEXT_ovr_0 := GetFuncOrNil&<procedure(renderbuffer: UInt32; coverageSamples: Int32; colorSamples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32)>(z_NamedRenderbufferStorageMultisampleCoverageEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedRenderbufferStorageMultisampleCoverageEXT(renderbuffer: UInt32; coverageSamples: Int32; colorSamples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32);
begin
z_NamedRenderbufferStorageMultisampleCoverageEXT_ovr_0(renderbuffer, coverageSamples, colorSamples, _internalformat, width, height);
end;
public z_CheckNamedFramebufferStatusEXT_adr := GetFuncAdr('glCheckNamedFramebufferStatusEXT');
public z_CheckNamedFramebufferStatusEXT_ovr_0 := GetFuncOrNil&<function(framebuffer: UInt32; target: FramebufferTarget): FramebufferStatus>(z_CheckNamedFramebufferStatusEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CheckNamedFramebufferStatusEXT(framebuffer: UInt32; target: FramebufferTarget): FramebufferStatus;
begin
Result := z_CheckNamedFramebufferStatusEXT_ovr_0(framebuffer, target);
end;
public z_NamedFramebufferTexture1DEXT_adr := GetFuncAdr('glNamedFramebufferTexture1DEXT');
public z_NamedFramebufferTexture1DEXT_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32)>(z_NamedFramebufferTexture1DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferTexture1DEXT(framebuffer: UInt32; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32);
begin
z_NamedFramebufferTexture1DEXT_ovr_0(framebuffer, attachment, textarget, texture, level);
end;
public z_NamedFramebufferTexture2DEXT_adr := GetFuncAdr('glNamedFramebufferTexture2DEXT');
public z_NamedFramebufferTexture2DEXT_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32)>(z_NamedFramebufferTexture2DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferTexture2DEXT(framebuffer: UInt32; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32);
begin
z_NamedFramebufferTexture2DEXT_ovr_0(framebuffer, attachment, textarget, texture, level);
end;
public z_NamedFramebufferTexture3DEXT_adr := GetFuncAdr('glNamedFramebufferTexture3DEXT');
public z_NamedFramebufferTexture3DEXT_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32; zoffset: Int32)>(z_NamedFramebufferTexture3DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferTexture3DEXT(framebuffer: UInt32; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32; zoffset: Int32);
begin
z_NamedFramebufferTexture3DEXT_ovr_0(framebuffer, attachment, textarget, texture, level, zoffset);
end;
public z_NamedFramebufferRenderbufferEXT_adr := GetFuncAdr('glNamedFramebufferRenderbufferEXT');
public z_NamedFramebufferRenderbufferEXT_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; attachment: FramebufferAttachment; _renderbuffertarget: RenderbufferTarget; renderbuffer: UInt32)>(z_NamedFramebufferRenderbufferEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferRenderbufferEXT(framebuffer: UInt32; attachment: FramebufferAttachment; _renderbuffertarget: RenderbufferTarget; renderbuffer: UInt32);
begin
z_NamedFramebufferRenderbufferEXT_ovr_0(framebuffer, attachment, _renderbuffertarget, renderbuffer);
end;
public z_GetNamedFramebufferAttachmentParameterivEXT_adr := GetFuncAdr('glGetNamedFramebufferAttachmentParameterivEXT');
public z_GetNamedFramebufferAttachmentParameterivEXT_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; var ¶ms: Int32)>(z_GetNamedFramebufferAttachmentParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferAttachmentParameterivEXT(framebuffer: UInt32; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: array of Int32);
begin
z_GetNamedFramebufferAttachmentParameterivEXT_ovr_0(framebuffer, attachment, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferAttachmentParameterivEXT(framebuffer: UInt32; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; var ¶ms: Int32);
begin
z_GetNamedFramebufferAttachmentParameterivEXT_ovr_0(framebuffer, attachment, pname, ¶ms);
end;
public z_GetNamedFramebufferAttachmentParameterivEXT_ovr_2 := GetFuncOrNil&<procedure(framebuffer: UInt32; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr)>(z_GetNamedFramebufferAttachmentParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferAttachmentParameterivEXT(framebuffer: UInt32; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr);
begin
z_GetNamedFramebufferAttachmentParameterivEXT_ovr_2(framebuffer, attachment, pname, ¶ms);
end;
public z_GenerateTextureMipmapEXT_adr := GetFuncAdr('glGenerateTextureMipmapEXT');
public z_GenerateTextureMipmapEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget)>(z_GenerateTextureMipmapEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenerateTextureMipmapEXT(texture: UInt32; target: TextureTarget);
begin
z_GenerateTextureMipmapEXT_ovr_0(texture, target);
end;
public z_GenerateMultiTexMipmapEXT_adr := GetFuncAdr('glGenerateMultiTexMipmapEXT');
public z_GenerateMultiTexMipmapEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget)>(z_GenerateMultiTexMipmapEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenerateMultiTexMipmapEXT(texunit: TextureUnit; target: TextureTarget);
begin
z_GenerateMultiTexMipmapEXT_ovr_0(texunit, target);
end;
public z_FramebufferDrawBufferEXT_adr := GetFuncAdr('glFramebufferDrawBufferEXT');
public z_FramebufferDrawBufferEXT_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; mode: DrawBufferMode)>(z_FramebufferDrawBufferEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferDrawBufferEXT(framebuffer: UInt32; mode: DrawBufferMode);
begin
z_FramebufferDrawBufferEXT_ovr_0(framebuffer, mode);
end;
public z_FramebufferDrawBuffersEXT_adr := GetFuncAdr('glFramebufferDrawBuffersEXT');
public z_FramebufferDrawBuffersEXT_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; n: Int32; var bufs: DrawBufferMode)>(z_FramebufferDrawBuffersEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferDrawBuffersEXT(framebuffer: UInt32; n: Int32; bufs: array of DrawBufferMode);
begin
z_FramebufferDrawBuffersEXT_ovr_0(framebuffer, n, bufs[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferDrawBuffersEXT(framebuffer: UInt32; n: Int32; var bufs: DrawBufferMode);
begin
z_FramebufferDrawBuffersEXT_ovr_0(framebuffer, n, bufs);
end;
public z_FramebufferDrawBuffersEXT_ovr_2 := GetFuncOrNil&<procedure(framebuffer: UInt32; n: Int32; bufs: IntPtr)>(z_FramebufferDrawBuffersEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferDrawBuffersEXT(framebuffer: UInt32; n: Int32; bufs: IntPtr);
begin
z_FramebufferDrawBuffersEXT_ovr_2(framebuffer, n, bufs);
end;
public z_FramebufferReadBufferEXT_adr := GetFuncAdr('glFramebufferReadBufferEXT');
public z_FramebufferReadBufferEXT_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; mode: ReadBufferMode)>(z_FramebufferReadBufferEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferReadBufferEXT(framebuffer: UInt32; mode: ReadBufferMode);
begin
z_FramebufferReadBufferEXT_ovr_0(framebuffer, mode);
end;
public z_GetFramebufferParameterivEXT_adr := GetFuncAdr('glGetFramebufferParameterivEXT');
public z_GetFramebufferParameterivEXT_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; pname: GetFramebufferParameter; var ¶ms: Int32)>(z_GetFramebufferParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferParameterivEXT(framebuffer: UInt32; pname: GetFramebufferParameter; ¶ms: array of Int32);
begin
z_GetFramebufferParameterivEXT_ovr_0(framebuffer, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferParameterivEXT(framebuffer: UInt32; pname: GetFramebufferParameter; var ¶ms: Int32);
begin
z_GetFramebufferParameterivEXT_ovr_0(framebuffer, pname, ¶ms);
end;
public z_GetFramebufferParameterivEXT_ovr_2 := GetFuncOrNil&<procedure(framebuffer: UInt32; pname: GetFramebufferParameter; ¶ms: IntPtr)>(z_GetFramebufferParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferParameterivEXT(framebuffer: UInt32; pname: GetFramebufferParameter; ¶ms: IntPtr);
begin
z_GetFramebufferParameterivEXT_ovr_2(framebuffer, pname, ¶ms);
end;
public z_NamedCopyBufferSubDataEXT_adr := GetFuncAdr('glNamedCopyBufferSubDataEXT');
public z_NamedCopyBufferSubDataEXT_ovr_0 := GetFuncOrNil&<procedure(readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr)>(z_NamedCopyBufferSubDataEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedCopyBufferSubDataEXT(readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr);
begin
z_NamedCopyBufferSubDataEXT_ovr_0(readBuffer, writeBuffer, readOffset, writeOffset, size);
end;
public z_NamedFramebufferTextureEXT_adr := GetFuncAdr('glNamedFramebufferTextureEXT');
public z_NamedFramebufferTextureEXT_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; attachment: FramebufferAttachment; texture: UInt32; level: Int32)>(z_NamedFramebufferTextureEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferTextureEXT(framebuffer: UInt32; attachment: FramebufferAttachment; texture: UInt32; level: Int32);
begin
z_NamedFramebufferTextureEXT_ovr_0(framebuffer, attachment, texture, level);
end;
public z_NamedFramebufferTextureLayerEXT_adr := GetFuncAdr('glNamedFramebufferTextureLayerEXT');
public z_NamedFramebufferTextureLayerEXT_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; attachment: FramebufferAttachment; texture: UInt32; level: Int32; layer: Int32)>(z_NamedFramebufferTextureLayerEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferTextureLayerEXT(framebuffer: UInt32; attachment: FramebufferAttachment; texture: UInt32; level: Int32; layer: Int32);
begin
z_NamedFramebufferTextureLayerEXT_ovr_0(framebuffer, attachment, texture, level, layer);
end;
public z_NamedFramebufferTextureFaceEXT_adr := GetFuncAdr('glNamedFramebufferTextureFaceEXT');
public z_NamedFramebufferTextureFaceEXT_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; attachment: FramebufferAttachment; texture: UInt32; level: Int32; face: TextureTarget)>(z_NamedFramebufferTextureFaceEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferTextureFaceEXT(framebuffer: UInt32; attachment: FramebufferAttachment; texture: UInt32; level: Int32; face: TextureTarget);
begin
z_NamedFramebufferTextureFaceEXT_ovr_0(framebuffer, attachment, texture, level, face);
end;
public z_TextureRenderbufferEXT_adr := GetFuncAdr('glTextureRenderbufferEXT');
public z_TextureRenderbufferEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; renderbuffer: UInt32)>(z_TextureRenderbufferEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureRenderbufferEXT(texture: UInt32; target: TextureTarget; renderbuffer: UInt32);
begin
z_TextureRenderbufferEXT_ovr_0(texture, target, renderbuffer);
end;
public z_MultiTexRenderbufferEXT_adr := GetFuncAdr('glMultiTexRenderbufferEXT');
public z_MultiTexRenderbufferEXT_ovr_0 := GetFuncOrNil&<procedure(texunit: TextureUnit; target: TextureTarget; renderbuffer: UInt32)>(z_MultiTexRenderbufferEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexRenderbufferEXT(texunit: TextureUnit; target: TextureTarget; renderbuffer: UInt32);
begin
z_MultiTexRenderbufferEXT_ovr_0(texunit, target, renderbuffer);
end;
public z_VertexArrayVertexOffsetEXT_adr := GetFuncAdr('glVertexArrayVertexOffsetEXT');
public z_VertexArrayVertexOffsetEXT_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; buffer: UInt32; size: Int32; &type: VertexPointerType; stride: Int32; offset: IntPtr)>(z_VertexArrayVertexOffsetEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexOffsetEXT(vaobj: UInt32; buffer: UInt32; size: Int32; &type: VertexPointerType; stride: Int32; offset: IntPtr);
begin
z_VertexArrayVertexOffsetEXT_ovr_0(vaobj, buffer, size, &type, stride, offset);
end;
public z_VertexArrayColorOffsetEXT_adr := GetFuncAdr('glVertexArrayColorOffsetEXT');
public z_VertexArrayColorOffsetEXT_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; buffer: UInt32; size: Int32; &type: ColorPointerType; stride: Int32; offset: IntPtr)>(z_VertexArrayColorOffsetEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayColorOffsetEXT(vaobj: UInt32; buffer: UInt32; size: Int32; &type: ColorPointerType; stride: Int32; offset: IntPtr);
begin
z_VertexArrayColorOffsetEXT_ovr_0(vaobj, buffer, size, &type, stride, offset);
end;
public z_VertexArrayEdgeFlagOffsetEXT_adr := GetFuncAdr('glVertexArrayEdgeFlagOffsetEXT');
public z_VertexArrayEdgeFlagOffsetEXT_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; buffer: UInt32; stride: Int32; offset: IntPtr)>(z_VertexArrayEdgeFlagOffsetEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayEdgeFlagOffsetEXT(vaobj: UInt32; buffer: UInt32; stride: Int32; offset: IntPtr);
begin
z_VertexArrayEdgeFlagOffsetEXT_ovr_0(vaobj, buffer, stride, offset);
end;
public z_VertexArrayIndexOffsetEXT_adr := GetFuncAdr('glVertexArrayIndexOffsetEXT');
public z_VertexArrayIndexOffsetEXT_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; buffer: UInt32; &type: IndexPointerType; stride: Int32; offset: IntPtr)>(z_VertexArrayIndexOffsetEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayIndexOffsetEXT(vaobj: UInt32; buffer: UInt32; &type: IndexPointerType; stride: Int32; offset: IntPtr);
begin
z_VertexArrayIndexOffsetEXT_ovr_0(vaobj, buffer, &type, stride, offset);
end;
public z_VertexArrayNormalOffsetEXT_adr := GetFuncAdr('glVertexArrayNormalOffsetEXT');
public z_VertexArrayNormalOffsetEXT_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; buffer: UInt32; &type: NormalPointerType; stride: Int32; offset: IntPtr)>(z_VertexArrayNormalOffsetEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayNormalOffsetEXT(vaobj: UInt32; buffer: UInt32; &type: NormalPointerType; stride: Int32; offset: IntPtr);
begin
z_VertexArrayNormalOffsetEXT_ovr_0(vaobj, buffer, &type, stride, offset);
end;
public z_VertexArrayTexCoordOffsetEXT_adr := GetFuncAdr('glVertexArrayTexCoordOffsetEXT');
public z_VertexArrayTexCoordOffsetEXT_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; buffer: UInt32; size: Int32; &type: TexCoordPointerType; stride: Int32; offset: IntPtr)>(z_VertexArrayTexCoordOffsetEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayTexCoordOffsetEXT(vaobj: UInt32; buffer: UInt32; size: Int32; &type: TexCoordPointerType; stride: Int32; offset: IntPtr);
begin
z_VertexArrayTexCoordOffsetEXT_ovr_0(vaobj, buffer, size, &type, stride, offset);
end;
public z_VertexArrayMultiTexCoordOffsetEXT_adr := GetFuncAdr('glVertexArrayMultiTexCoordOffsetEXT');
public z_VertexArrayMultiTexCoordOffsetEXT_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; buffer: UInt32; texunit: DummyEnum; size: Int32; &type: TexCoordPointerType; stride: Int32; offset: IntPtr)>(z_VertexArrayMultiTexCoordOffsetEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayMultiTexCoordOffsetEXT(vaobj: UInt32; buffer: UInt32; texunit: DummyEnum; size: Int32; &type: TexCoordPointerType; stride: Int32; offset: IntPtr);
begin
z_VertexArrayMultiTexCoordOffsetEXT_ovr_0(vaobj, buffer, texunit, size, &type, stride, offset);
end;
public z_VertexArrayFogCoordOffsetEXT_adr := GetFuncAdr('glVertexArrayFogCoordOffsetEXT');
public z_VertexArrayFogCoordOffsetEXT_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; buffer: UInt32; &type: FogCoordinatePointerType; stride: Int32; offset: IntPtr)>(z_VertexArrayFogCoordOffsetEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayFogCoordOffsetEXT(vaobj: UInt32; buffer: UInt32; &type: FogCoordinatePointerType; stride: Int32; offset: IntPtr);
begin
z_VertexArrayFogCoordOffsetEXT_ovr_0(vaobj, buffer, &type, stride, offset);
end;
public z_VertexArraySecondaryColorOffsetEXT_adr := GetFuncAdr('glVertexArraySecondaryColorOffsetEXT');
public z_VertexArraySecondaryColorOffsetEXT_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; buffer: UInt32; size: Int32; &type: ColorPointerType; stride: Int32; offset: IntPtr)>(z_VertexArraySecondaryColorOffsetEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArraySecondaryColorOffsetEXT(vaobj: UInt32; buffer: UInt32; size: Int32; &type: ColorPointerType; stride: Int32; offset: IntPtr);
begin
z_VertexArraySecondaryColorOffsetEXT_ovr_0(vaobj, buffer, size, &type, stride, offset);
end;
public z_VertexArrayVertexAttribOffsetEXT_adr := GetFuncAdr('glVertexArrayVertexAttribOffsetEXT');
public z_VertexArrayVertexAttribOffsetEXT_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; buffer: UInt32; index: UInt32; size: Int32; &type: VertexAttribPointerType; normalized: boolean; stride: Int32; offset: IntPtr)>(z_VertexArrayVertexAttribOffsetEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexAttribOffsetEXT(vaobj: UInt32; buffer: UInt32; index: UInt32; size: Int32; &type: VertexAttribPointerType; normalized: boolean; stride: Int32; offset: IntPtr);
begin
z_VertexArrayVertexAttribOffsetEXT_ovr_0(vaobj, buffer, index, size, &type, normalized, stride, offset);
end;
public z_VertexArrayVertexAttribIOffsetEXT_adr := GetFuncAdr('glVertexArrayVertexAttribIOffsetEXT');
public z_VertexArrayVertexAttribIOffsetEXT_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; buffer: UInt32; index: UInt32; size: Int32; &type: VertexAttribType; stride: Int32; offset: IntPtr)>(z_VertexArrayVertexAttribIOffsetEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexAttribIOffsetEXT(vaobj: UInt32; buffer: UInt32; index: UInt32; size: Int32; &type: VertexAttribType; stride: Int32; offset: IntPtr);
begin
z_VertexArrayVertexAttribIOffsetEXT_ovr_0(vaobj, buffer, index, size, &type, stride, offset);
end;
public z_EnableVertexArrayEXT_adr := GetFuncAdr('glEnableVertexArrayEXT');
public z_EnableVertexArrayEXT_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; &array: EnableCap)>(z_EnableVertexArrayEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EnableVertexArrayEXT(vaobj: UInt32; &array: EnableCap);
begin
z_EnableVertexArrayEXT_ovr_0(vaobj, &array);
end;
public z_DisableVertexArrayEXT_adr := GetFuncAdr('glDisableVertexArrayEXT');
public z_DisableVertexArrayEXT_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; &array: EnableCap)>(z_DisableVertexArrayEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DisableVertexArrayEXT(vaobj: UInt32; &array: EnableCap);
begin
z_DisableVertexArrayEXT_ovr_0(vaobj, &array);
end;
public z_EnableVertexArrayAttribEXT_adr := GetFuncAdr('glEnableVertexArrayAttribEXT');
public z_EnableVertexArrayAttribEXT_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; index: UInt32)>(z_EnableVertexArrayAttribEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EnableVertexArrayAttribEXT(vaobj: UInt32; index: UInt32);
begin
z_EnableVertexArrayAttribEXT_ovr_0(vaobj, index);
end;
public z_DisableVertexArrayAttribEXT_adr := GetFuncAdr('glDisableVertexArrayAttribEXT');
public z_DisableVertexArrayAttribEXT_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; index: UInt32)>(z_DisableVertexArrayAttribEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DisableVertexArrayAttribEXT(vaobj: UInt32; index: UInt32);
begin
z_DisableVertexArrayAttribEXT_ovr_0(vaobj, index);
end;
public z_GetVertexArrayIntegervEXT_adr := GetFuncAdr('glGetVertexArrayIntegervEXT');
public z_GetVertexArrayIntegervEXT_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; pname: VertexArrayPName; var param: Int32)>(z_GetVertexArrayIntegervEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIntegervEXT(vaobj: UInt32; pname: VertexArrayPName; param: array of Int32);
begin
z_GetVertexArrayIntegervEXT_ovr_0(vaobj, pname, param[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIntegervEXT(vaobj: UInt32; pname: VertexArrayPName; var param: Int32);
begin
z_GetVertexArrayIntegervEXT_ovr_0(vaobj, pname, param);
end;
public z_GetVertexArrayIntegervEXT_ovr_2 := GetFuncOrNil&<procedure(vaobj: UInt32; pname: VertexArrayPName; param: IntPtr)>(z_GetVertexArrayIntegervEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIntegervEXT(vaobj: UInt32; pname: VertexArrayPName; param: IntPtr);
begin
z_GetVertexArrayIntegervEXT_ovr_2(vaobj, pname, param);
end;
public z_GetVertexArrayPointervEXT_adr := GetFuncAdr('glGetVertexArrayPointervEXT');
public z_GetVertexArrayPointervEXT_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; pname: VertexArrayPName; var param: IntPtr)>(z_GetVertexArrayPointervEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayPointervEXT(vaobj: UInt32; pname: VertexArrayPName; param: array of IntPtr);
begin
z_GetVertexArrayPointervEXT_ovr_0(vaobj, pname, param[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayPointervEXT(vaobj: UInt32; pname: VertexArrayPName; var param: IntPtr);
begin
z_GetVertexArrayPointervEXT_ovr_0(vaobj, pname, param);
end;
public z_GetVertexArrayPointervEXT_ovr_2 := GetFuncOrNil&<procedure(vaobj: UInt32; pname: VertexArrayPName; param: pointer)>(z_GetVertexArrayPointervEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayPointervEXT(vaobj: UInt32; pname: VertexArrayPName; param: pointer);
begin
z_GetVertexArrayPointervEXT_ovr_2(vaobj, pname, param);
end;
public z_GetVertexArrayIntegeri_vEXT_adr := GetFuncAdr('glGetVertexArrayIntegeri_vEXT');
public z_GetVertexArrayIntegeri_vEXT_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; var param: Int32)>(z_GetVertexArrayIntegeri_vEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIntegeri_vEXT(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: array of Int32);
begin
z_GetVertexArrayIntegeri_vEXT_ovr_0(vaobj, index, pname, param[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIntegeri_vEXT(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; var param: Int32);
begin
z_GetVertexArrayIntegeri_vEXT_ovr_0(vaobj, index, pname, param);
end;
public z_GetVertexArrayIntegeri_vEXT_ovr_2 := GetFuncOrNil&<procedure(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: IntPtr)>(z_GetVertexArrayIntegeri_vEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayIntegeri_vEXT(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: IntPtr);
begin
z_GetVertexArrayIntegeri_vEXT_ovr_2(vaobj, index, pname, param);
end;
public z_GetVertexArrayPointeri_vEXT_adr := GetFuncAdr('glGetVertexArrayPointeri_vEXT');
public z_GetVertexArrayPointeri_vEXT_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; var param: IntPtr)>(z_GetVertexArrayPointeri_vEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayPointeri_vEXT(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: array of IntPtr);
begin
z_GetVertexArrayPointeri_vEXT_ovr_0(vaobj, index, pname, param[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayPointeri_vEXT(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; var param: IntPtr);
begin
z_GetVertexArrayPointeri_vEXT_ovr_0(vaobj, index, pname, param);
end;
public z_GetVertexArrayPointeri_vEXT_ovr_2 := GetFuncOrNil&<procedure(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: pointer)>(z_GetVertexArrayPointeri_vEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexArrayPointeri_vEXT(vaobj: UInt32; index: UInt32; pname: VertexArrayPName; param: pointer);
begin
z_GetVertexArrayPointeri_vEXT_ovr_2(vaobj, index, pname, param);
end;
public z_MapNamedBufferRangeEXT_adr := GetFuncAdr('glMapNamedBufferRangeEXT');
public z_MapNamedBufferRangeEXT_ovr_0 := GetFuncOrNil&<function(buffer: UInt32; offset: IntPtr; length: IntPtr; access: MapBufferAccessMask): IntPtr>(z_MapNamedBufferRangeEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapNamedBufferRangeEXT(buffer: UInt32; offset: IntPtr; length: IntPtr; access: MapBufferAccessMask): IntPtr;
begin
Result := z_MapNamedBufferRangeEXT_ovr_0(buffer, offset, length, access);
end;
public z_FlushMappedNamedBufferRangeEXT_adr := GetFuncAdr('glFlushMappedNamedBufferRangeEXT');
public z_FlushMappedNamedBufferRangeEXT_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; offset: IntPtr; length: IntPtr)>(z_FlushMappedNamedBufferRangeEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FlushMappedNamedBufferRangeEXT(buffer: UInt32; offset: IntPtr; length: IntPtr);
begin
z_FlushMappedNamedBufferRangeEXT_ovr_0(buffer, offset, length);
end;
public z_NamedBufferStorageEXT_adr := GetFuncAdr('glNamedBufferStorageEXT');
public z_NamedBufferStorageEXT_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; size: IntPtr; data: IntPtr; flags: BufferStorageMask)>(z_NamedBufferStorageEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferStorageEXT(buffer: UInt32; size: IntPtr; data: IntPtr; flags: BufferStorageMask);
begin
z_NamedBufferStorageEXT_ovr_0(buffer, size, data, flags);
end;
public z_ClearNamedBufferDataEXT_adr := GetFuncAdr('glClearNamedBufferDataEXT');
public z_ClearNamedBufferDataEXT_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; _internalformat: InternalFormat; format: PixelFormat; &type: PixelType; data: IntPtr)>(z_ClearNamedBufferDataEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedBufferDataEXT(buffer: UInt32; _internalformat: InternalFormat; format: PixelFormat; &type: PixelType; data: IntPtr);
begin
z_ClearNamedBufferDataEXT_ovr_0(buffer, _internalformat, format, &type, data);
end;
public z_ClearNamedBufferSubDataEXT_adr := GetFuncAdr('glClearNamedBufferSubDataEXT');
public z_ClearNamedBufferSubDataEXT_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; internalformat: DummyEnum; offset: IntPtr; size: IntPtr; format: PixelFormat; &type: PixelType; data: IntPtr)>(z_ClearNamedBufferSubDataEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearNamedBufferSubDataEXT(buffer: UInt32; internalformat: DummyEnum; offset: IntPtr; size: IntPtr; format: PixelFormat; &type: PixelType; data: IntPtr);
begin
z_ClearNamedBufferSubDataEXT_ovr_0(buffer, internalformat, offset, size, format, &type, data);
end;
public z_NamedFramebufferParameteriEXT_adr := GetFuncAdr('glNamedFramebufferParameteriEXT');
public z_NamedFramebufferParameteriEXT_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; pname: FramebufferParameterName; param: Int32)>(z_NamedFramebufferParameteriEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferParameteriEXT(framebuffer: UInt32; pname: FramebufferParameterName; param: Int32);
begin
z_NamedFramebufferParameteriEXT_ovr_0(framebuffer, pname, param);
end;
public z_GetNamedFramebufferParameterivEXT_adr := GetFuncAdr('glGetNamedFramebufferParameterivEXT');
public z_GetNamedFramebufferParameterivEXT_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; pname: GetFramebufferParameter; var ¶ms: Int32)>(z_GetNamedFramebufferParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferParameterivEXT(framebuffer: UInt32; pname: GetFramebufferParameter; ¶ms: array of Int32);
begin
z_GetNamedFramebufferParameterivEXT_ovr_0(framebuffer, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferParameterivEXT(framebuffer: UInt32; pname: GetFramebufferParameter; var ¶ms: Int32);
begin
z_GetNamedFramebufferParameterivEXT_ovr_0(framebuffer, pname, ¶ms);
end;
public z_GetNamedFramebufferParameterivEXT_ovr_2 := GetFuncOrNil&<procedure(framebuffer: UInt32; pname: GetFramebufferParameter; ¶ms: IntPtr)>(z_GetNamedFramebufferParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedFramebufferParameterivEXT(framebuffer: UInt32; pname: GetFramebufferParameter; ¶ms: IntPtr);
begin
z_GetNamedFramebufferParameterivEXT_ovr_2(framebuffer, pname, ¶ms);
end;
public z_ProgramUniform1dEXT_adr := GetFuncAdr('glProgramUniform1dEXT');
public z_ProgramUniform1dEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; x: real)>(z_ProgramUniform1dEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1dEXT(&program: UInt32; location: Int32; x: real);
begin
z_ProgramUniform1dEXT_ovr_0(&program, location, x);
end;
public z_ProgramUniform2dEXT_adr := GetFuncAdr('glProgramUniform2dEXT');
public z_ProgramUniform2dEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; x: real; y: real)>(z_ProgramUniform2dEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2dEXT(&program: UInt32; location: Int32; x: real; y: real);
begin
z_ProgramUniform2dEXT_ovr_0(&program, location, x, y);
end;
public z_ProgramUniform3dEXT_adr := GetFuncAdr('glProgramUniform3dEXT');
public z_ProgramUniform3dEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; x: real; y: real; z: real)>(z_ProgramUniform3dEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3dEXT(&program: UInt32; location: Int32; x: real; y: real; z: real);
begin
z_ProgramUniform3dEXT_ovr_0(&program, location, x, y, z);
end;
public z_ProgramUniform4dEXT_adr := GetFuncAdr('glProgramUniform4dEXT');
public z_ProgramUniform4dEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; x: real; y: real; z: real; w: real)>(z_ProgramUniform4dEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4dEXT(&program: UInt32; location: Int32; x: real; y: real; z: real; w: real);
begin
z_ProgramUniform4dEXT_ovr_0(&program, location, x, y, z, w);
end;
public z_ProgramUniform1dvEXT_adr := GetFuncAdr('glProgramUniform1dvEXT');
public z_ProgramUniform1dvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: real)>(z_ProgramUniform1dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1dvEXT(&program: UInt32; location: Int32; count: Int32; value: array of real);
begin
z_ProgramUniform1dvEXT_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1dvEXT(&program: UInt32; location: Int32; count: Int32; var value: real);
begin
z_ProgramUniform1dvEXT_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform1dvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform1dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1dvEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform1dvEXT_ovr_2(&program, location, count, value);
end;
public z_ProgramUniform2dvEXT_adr := GetFuncAdr('glProgramUniform2dvEXT');
public z_ProgramUniform2dvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: real)>(z_ProgramUniform2dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2dvEXT(&program: UInt32; location: Int32; count: Int32; value: array of real);
begin
z_ProgramUniform2dvEXT_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2dvEXT(&program: UInt32; location: Int32; count: Int32; var value: real);
begin
z_ProgramUniform2dvEXT_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform2dvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform2dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2dvEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform2dvEXT_ovr_2(&program, location, count, value);
end;
public z_ProgramUniform3dvEXT_adr := GetFuncAdr('glProgramUniform3dvEXT');
public z_ProgramUniform3dvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: real)>(z_ProgramUniform3dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3dvEXT(&program: UInt32; location: Int32; count: Int32; value: array of real);
begin
z_ProgramUniform3dvEXT_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3dvEXT(&program: UInt32; location: Int32; count: Int32; var value: real);
begin
z_ProgramUniform3dvEXT_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform3dvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform3dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3dvEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform3dvEXT_ovr_2(&program, location, count, value);
end;
public z_ProgramUniform4dvEXT_adr := GetFuncAdr('glProgramUniform4dvEXT');
public z_ProgramUniform4dvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: real)>(z_ProgramUniform4dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4dvEXT(&program: UInt32; location: Int32; count: Int32; value: array of real);
begin
z_ProgramUniform4dvEXT_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4dvEXT(&program: UInt32; location: Int32; count: Int32; var value: real);
begin
z_ProgramUniform4dvEXT_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform4dvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform4dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4dvEXT(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform4dvEXT_ovr_2(&program, location, count, value);
end;
public z_ProgramUniformMatrix2dvEXT_adr := GetFuncAdr('glProgramUniformMatrix2dvEXT');
public z_ProgramUniformMatrix2dvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real)>(z_ProgramUniformMatrix2dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real);
begin
z_ProgramUniformMatrix2dvEXT_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
begin
z_ProgramUniformMatrix2dvEXT_ovr_0(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix2dvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix2dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
begin
z_ProgramUniformMatrix2dvEXT_ovr_2(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix3dvEXT_adr := GetFuncAdr('glProgramUniformMatrix3dvEXT');
public z_ProgramUniformMatrix3dvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real)>(z_ProgramUniformMatrix3dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real);
begin
z_ProgramUniformMatrix3dvEXT_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
begin
z_ProgramUniformMatrix3dvEXT_ovr_0(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix3dvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix3dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
begin
z_ProgramUniformMatrix3dvEXT_ovr_2(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix4dvEXT_adr := GetFuncAdr('glProgramUniformMatrix4dvEXT');
public z_ProgramUniformMatrix4dvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real)>(z_ProgramUniformMatrix4dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real);
begin
z_ProgramUniformMatrix4dvEXT_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
begin
z_ProgramUniformMatrix4dvEXT_ovr_0(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix4dvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix4dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
begin
z_ProgramUniformMatrix4dvEXT_ovr_2(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix2x3dvEXT_adr := GetFuncAdr('glProgramUniformMatrix2x3dvEXT');
public z_ProgramUniformMatrix2x3dvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real)>(z_ProgramUniformMatrix2x3dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real);
begin
z_ProgramUniformMatrix2x3dvEXT_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
begin
z_ProgramUniformMatrix2x3dvEXT_ovr_0(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix2x3dvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix2x3dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x3dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
begin
z_ProgramUniformMatrix2x3dvEXT_ovr_2(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix2x4dvEXT_adr := GetFuncAdr('glProgramUniformMatrix2x4dvEXT');
public z_ProgramUniformMatrix2x4dvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real)>(z_ProgramUniformMatrix2x4dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real);
begin
z_ProgramUniformMatrix2x4dvEXT_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
begin
z_ProgramUniformMatrix2x4dvEXT_ovr_0(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix2x4dvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix2x4dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix2x4dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
begin
z_ProgramUniformMatrix2x4dvEXT_ovr_2(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix3x2dvEXT_adr := GetFuncAdr('glProgramUniformMatrix3x2dvEXT');
public z_ProgramUniformMatrix3x2dvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real)>(z_ProgramUniformMatrix3x2dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real);
begin
z_ProgramUniformMatrix3x2dvEXT_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
begin
z_ProgramUniformMatrix3x2dvEXT_ovr_0(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix3x2dvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix3x2dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x2dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
begin
z_ProgramUniformMatrix3x2dvEXT_ovr_2(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix3x4dvEXT_adr := GetFuncAdr('glProgramUniformMatrix3x4dvEXT');
public z_ProgramUniformMatrix3x4dvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real)>(z_ProgramUniformMatrix3x4dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real);
begin
z_ProgramUniformMatrix3x4dvEXT_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
begin
z_ProgramUniformMatrix3x4dvEXT_ovr_0(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix3x4dvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix3x4dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix3x4dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
begin
z_ProgramUniformMatrix3x4dvEXT_ovr_2(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix4x2dvEXT_adr := GetFuncAdr('glProgramUniformMatrix4x2dvEXT');
public z_ProgramUniformMatrix4x2dvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real)>(z_ProgramUniformMatrix4x2dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real);
begin
z_ProgramUniformMatrix4x2dvEXT_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
begin
z_ProgramUniformMatrix4x2dvEXT_ovr_0(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix4x2dvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix4x2dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x2dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
begin
z_ProgramUniformMatrix4x2dvEXT_ovr_2(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix4x3dvEXT_adr := GetFuncAdr('glProgramUniformMatrix4x3dvEXT');
public z_ProgramUniformMatrix4x3dvEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real)>(z_ProgramUniformMatrix4x3dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: array of real);
begin
z_ProgramUniformMatrix4x3dvEXT_ovr_0(&program, location, count, transpose, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; var value: real);
begin
z_ProgramUniformMatrix4x3dvEXT_ovr_0(&program, location, count, transpose, value);
end;
public z_ProgramUniformMatrix4x3dvEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr)>(z_ProgramUniformMatrix4x3dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformMatrix4x3dvEXT(&program: UInt32; location: Int32; count: Int32; transpose: boolean; value: IntPtr);
begin
z_ProgramUniformMatrix4x3dvEXT_ovr_2(&program, location, count, transpose, value);
end;
public z_TextureBufferRangeEXT_adr := GetFuncAdr('glTextureBufferRangeEXT');
public z_TextureBufferRangeEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; _internalformat: InternalFormat; buffer: UInt32; offset: IntPtr; size: IntPtr)>(z_TextureBufferRangeEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureBufferRangeEXT(texture: UInt32; target: TextureTarget; _internalformat: InternalFormat; buffer: UInt32; offset: IntPtr; size: IntPtr);
begin
z_TextureBufferRangeEXT_ovr_0(texture, target, _internalformat, buffer, offset, size);
end;
public z_TextureStorage1DEXT_adr := GetFuncAdr('glTextureStorage1DEXT');
public z_TextureStorage1DEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: DummyEnum; levels: Int32; _internalformat: InternalFormat; width: Int32)>(z_TextureStorage1DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorage1DEXT(texture: UInt32; target: DummyEnum; levels: Int32; _internalformat: InternalFormat; width: Int32);
begin
z_TextureStorage1DEXT_ovr_0(texture, target, levels, _internalformat, width);
end;
public z_TextureStorage2DEXT_adr := GetFuncAdr('glTextureStorage2DEXT');
public z_TextureStorage2DEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: DummyEnum; levels: Int32; _internalformat: InternalFormat; width: Int32; height: Int32)>(z_TextureStorage2DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorage2DEXT(texture: UInt32; target: DummyEnum; levels: Int32; _internalformat: InternalFormat; width: Int32; height: Int32);
begin
z_TextureStorage2DEXT_ovr_0(texture, target, levels, _internalformat, width, height);
end;
public z_TextureStorage3DEXT_adr := GetFuncAdr('glTextureStorage3DEXT');
public z_TextureStorage3DEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: DummyEnum; levels: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32)>(z_TextureStorage3DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorage3DEXT(texture: UInt32; target: DummyEnum; levels: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32);
begin
z_TextureStorage3DEXT_ovr_0(texture, target, levels, _internalformat, width, height, depth);
end;
public z_TextureStorage2DMultisampleEXT_adr := GetFuncAdr('glTextureStorage2DMultisampleEXT');
public z_TextureStorage2DMultisampleEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; fixedsamplelocations: boolean)>(z_TextureStorage2DMultisampleEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorage2DMultisampleEXT(texture: UInt32; target: TextureTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; fixedsamplelocations: boolean);
begin
z_TextureStorage2DMultisampleEXT_ovr_0(texture, target, samples, _internalformat, width, height, fixedsamplelocations);
end;
public z_TextureStorage3DMultisampleEXT_adr := GetFuncAdr('glTextureStorage3DMultisampleEXT');
public z_TextureStorage3DMultisampleEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: DummyEnum; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; fixedsamplelocations: boolean)>(z_TextureStorage3DMultisampleEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorage3DMultisampleEXT(texture: UInt32; target: DummyEnum; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; fixedsamplelocations: boolean);
begin
z_TextureStorage3DMultisampleEXT_ovr_0(texture, target, samples, _internalformat, width, height, depth, fixedsamplelocations);
end;
public z_VertexArrayBindVertexBufferEXT_adr := GetFuncAdr('glVertexArrayBindVertexBufferEXT');
public z_VertexArrayBindVertexBufferEXT_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; bindingindex: UInt32; buffer: UInt32; offset: IntPtr; stride: Int32)>(z_VertexArrayBindVertexBufferEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayBindVertexBufferEXT(vaobj: UInt32; bindingindex: UInt32; buffer: UInt32; offset: IntPtr; stride: Int32);
begin
z_VertexArrayBindVertexBufferEXT_ovr_0(vaobj, bindingindex, buffer, offset, stride);
end;
public z_VertexArrayVertexAttribFormatEXT_adr := GetFuncAdr('glVertexArrayVertexAttribFormatEXT');
public z_VertexArrayVertexAttribFormatEXT_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; attribindex: UInt32; size: Int32; &type: VertexAttribType; normalized: boolean; relativeoffset: UInt32)>(z_VertexArrayVertexAttribFormatEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexAttribFormatEXT(vaobj: UInt32; attribindex: UInt32; size: Int32; &type: VertexAttribType; normalized: boolean; relativeoffset: UInt32);
begin
z_VertexArrayVertexAttribFormatEXT_ovr_0(vaobj, attribindex, size, &type, normalized, relativeoffset);
end;
public z_VertexArrayVertexAttribIFormatEXT_adr := GetFuncAdr('glVertexArrayVertexAttribIFormatEXT');
public z_VertexArrayVertexAttribIFormatEXT_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; attribindex: UInt32; size: Int32; &type: VertexAttribIType; relativeoffset: UInt32)>(z_VertexArrayVertexAttribIFormatEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexAttribIFormatEXT(vaobj: UInt32; attribindex: UInt32; size: Int32; &type: VertexAttribIType; relativeoffset: UInt32);
begin
z_VertexArrayVertexAttribIFormatEXT_ovr_0(vaobj, attribindex, size, &type, relativeoffset);
end;
public z_VertexArrayVertexAttribLFormatEXT_adr := GetFuncAdr('glVertexArrayVertexAttribLFormatEXT');
public z_VertexArrayVertexAttribLFormatEXT_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; attribindex: UInt32; size: Int32; &type: VertexAttribLType; relativeoffset: UInt32)>(z_VertexArrayVertexAttribLFormatEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexAttribLFormatEXT(vaobj: UInt32; attribindex: UInt32; size: Int32; &type: VertexAttribLType; relativeoffset: UInt32);
begin
z_VertexArrayVertexAttribLFormatEXT_ovr_0(vaobj, attribindex, size, &type, relativeoffset);
end;
public z_VertexArrayVertexAttribBindingEXT_adr := GetFuncAdr('glVertexArrayVertexAttribBindingEXT');
public z_VertexArrayVertexAttribBindingEXT_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; attribindex: UInt32; bindingindex: UInt32)>(z_VertexArrayVertexAttribBindingEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexAttribBindingEXT(vaobj: UInt32; attribindex: UInt32; bindingindex: UInt32);
begin
z_VertexArrayVertexAttribBindingEXT_ovr_0(vaobj, attribindex, bindingindex);
end;
public z_VertexArrayVertexBindingDivisorEXT_adr := GetFuncAdr('glVertexArrayVertexBindingDivisorEXT');
public z_VertexArrayVertexBindingDivisorEXT_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; bindingindex: UInt32; divisor: UInt32)>(z_VertexArrayVertexBindingDivisorEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexBindingDivisorEXT(vaobj: UInt32; bindingindex: UInt32; divisor: UInt32);
begin
z_VertexArrayVertexBindingDivisorEXT_ovr_0(vaobj, bindingindex, divisor);
end;
public z_VertexArrayVertexAttribLOffsetEXT_adr := GetFuncAdr('glVertexArrayVertexAttribLOffsetEXT');
public z_VertexArrayVertexAttribLOffsetEXT_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; buffer: UInt32; index: UInt32; size: Int32; &type: VertexAttribLType; stride: Int32; offset: IntPtr)>(z_VertexArrayVertexAttribLOffsetEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexAttribLOffsetEXT(vaobj: UInt32; buffer: UInt32; index: UInt32; size: Int32; &type: VertexAttribLType; stride: Int32; offset: IntPtr);
begin
z_VertexArrayVertexAttribLOffsetEXT_ovr_0(vaobj, buffer, index, size, &type, stride, offset);
end;
public z_TexturePageCommitmentEXT_adr := GetFuncAdr('glTexturePageCommitmentEXT');
public z_TexturePageCommitmentEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; commit: boolean)>(z_TexturePageCommitmentEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexturePageCommitmentEXT(texture: UInt32; level: Int32; xoffset: Int32; yoffset: Int32; zoffset: Int32; width: Int32; height: Int32; depth: Int32; commit: boolean);
begin
z_TexturePageCommitmentEXT_ovr_0(texture, level, xoffset, yoffset, zoffset, width, height, depth, commit);
end;
public z_VertexArrayVertexAttribDivisorEXT_adr := GetFuncAdr('glVertexArrayVertexAttribDivisorEXT');
public z_VertexArrayVertexAttribDivisorEXT_ovr_0 := GetFuncOrNil&<procedure(vaobj: UInt32; index: UInt32; divisor: UInt32)>(z_VertexArrayVertexAttribDivisorEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayVertexAttribDivisorEXT(vaobj: UInt32; index: UInt32; divisor: UInt32);
begin
z_VertexArrayVertexAttribDivisorEXT_ovr_0(vaobj, index, divisor);
end;
end;
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);
public z_ColorMaskIndexedEXT_adr := GetFuncAdr('glColorMaskIndexedEXT');
public z_ColorMaskIndexedEXT_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; r: boolean; g: boolean; b: boolean; a: boolean)>(z_ColorMaskIndexedEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorMaskIndexedEXT(index: UInt32; r: boolean; g: boolean; b: boolean; a: boolean);
begin
z_ColorMaskIndexedEXT_ovr_0(index, r, g, b, a);
end;
public z_GetBooleanIndexedvEXT_adr := GetFuncAdr('glGetBooleanIndexedvEXT');
public z_GetBooleanIndexedvEXT_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; var data: boolean)>(z_GetBooleanIndexedvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanIndexedvEXT(target: BufferTargetARB; index: UInt32; data: array of boolean);
begin
z_GetBooleanIndexedvEXT_ovr_0(target, index, data[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanIndexedvEXT(target: BufferTargetARB; index: UInt32; var data: boolean);
begin
z_GetBooleanIndexedvEXT_ovr_0(target, index, data);
end;
public z_GetBooleanIndexedvEXT_ovr_2 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; data: IntPtr)>(z_GetBooleanIndexedvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanIndexedvEXT(target: BufferTargetARB; index: UInt32; data: IntPtr);
begin
z_GetBooleanIndexedvEXT_ovr_2(target, index, data);
end;
public z_GetIntegerIndexedvEXT_adr := GetFuncAdr('glGetIntegerIndexedvEXT');
public z_GetIntegerIndexedvEXT_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; var data: Int32)>(z_GetIntegerIndexedvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerIndexedvEXT(target: DummyEnum; index: UInt32; data: array of Int32);
begin
z_GetIntegerIndexedvEXT_ovr_0(target, index, data[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerIndexedvEXT(target: DummyEnum; index: UInt32; var data: Int32);
begin
z_GetIntegerIndexedvEXT_ovr_0(target, index, data);
end;
public z_GetIntegerIndexedvEXT_ovr_2 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; data: IntPtr)>(z_GetIntegerIndexedvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerIndexedvEXT(target: DummyEnum; index: UInt32; data: IntPtr);
begin
z_GetIntegerIndexedvEXT_ovr_2(target, index, data);
end;
public z_EnableIndexedEXT_adr := GetFuncAdr('glEnableIndexedEXT');
public z_EnableIndexedEXT_ovr_0 := GetFuncOrNil&<procedure(target: EnableCap; index: UInt32)>(z_EnableIndexedEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EnableIndexedEXT(target: EnableCap; index: UInt32);
begin
z_EnableIndexedEXT_ovr_0(target, index);
end;
public z_DisableIndexedEXT_adr := GetFuncAdr('glDisableIndexedEXT');
public z_DisableIndexedEXT_ovr_0 := GetFuncOrNil&<procedure(target: EnableCap; index: UInt32)>(z_DisableIndexedEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DisableIndexedEXT(target: EnableCap; index: UInt32);
begin
z_DisableIndexedEXT_ovr_0(target, index);
end;
public z_IsEnabledIndexedEXT_adr := GetFuncAdr('glIsEnabledIndexedEXT');
public z_IsEnabledIndexedEXT_ovr_0 := GetFuncOrNil&<function(target: EnableCap; index: UInt32): boolean>(z_IsEnabledIndexedEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsEnabledIndexedEXT(target: EnableCap; index: UInt32): boolean;
begin
Result := z_IsEnabledIndexedEXT_ovr_0(target, index);
end;
end;
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);
public z_DrawArraysInstancedEXT_adr := GetFuncAdr('glDrawArraysInstancedEXT');
public z_DrawArraysInstancedEXT_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; start: Int32; count: Int32; primcount: Int32)>(z_DrawArraysInstancedEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawArraysInstancedEXT(mode: PrimitiveType; start: Int32; count: Int32; primcount: Int32);
begin
z_DrawArraysInstancedEXT_ovr_0(mode, start, count, primcount);
end;
public z_DrawElementsInstancedEXT_adr := GetFuncAdr('glDrawElementsInstancedEXT');
public z_DrawElementsInstancedEXT_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: Int32; &type: DrawElementsType; indices: IntPtr; primcount: Int32)>(z_DrawElementsInstancedEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawElementsInstancedEXT(mode: PrimitiveType; count: Int32; &type: DrawElementsType; indices: IntPtr; primcount: Int32);
begin
z_DrawElementsInstancedEXT_ovr_0(mode, count, &type, indices, primcount);
end;
end;
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);
public z_DrawRangeElementsEXT_adr := GetFuncAdr('glDrawRangeElementsEXT');
public z_DrawRangeElementsEXT_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; start: UInt32; &end: UInt32; count: Int32; &type: DrawElementsType; indices: IntPtr)>(z_DrawRangeElementsEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawRangeElementsEXT(mode: PrimitiveType; start: UInt32; &end: UInt32; count: Int32; &type: DrawElementsType; indices: IntPtr);
begin
z_DrawRangeElementsEXT_ovr_0(mode, start, &end, count, &type, indices);
end;
end;
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);
public z_BufferStorageExternalEXT_adr := GetFuncAdr('glBufferStorageExternalEXT');
public z_BufferStorageExternalEXT_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; offset: IntPtr; size: IntPtr; clientBuffer: GLeglClientBufferEXT; flags: BufferStorageMask)>(z_BufferStorageExternalEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferStorageExternalEXT(target: DummyEnum; offset: IntPtr; size: IntPtr; clientBuffer: GLeglClientBufferEXT; flags: BufferStorageMask);
begin
z_BufferStorageExternalEXT_ovr_0(target, offset, size, clientBuffer, flags);
end;
public z_NamedBufferStorageExternalEXT_adr := GetFuncAdr('glNamedBufferStorageExternalEXT');
public z_NamedBufferStorageExternalEXT_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; offset: IntPtr; size: IntPtr; clientBuffer: GLeglClientBufferEXT; flags: BufferStorageMask)>(z_NamedBufferStorageExternalEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferStorageExternalEXT(buffer: UInt32; offset: IntPtr; size: IntPtr; clientBuffer: GLeglClientBufferEXT; flags: BufferStorageMask);
begin
z_NamedBufferStorageExternalEXT_ovr_0(buffer, offset, size, clientBuffer, flags);
end;
end;
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);
public z_FogCoordfEXT_adr := GetFuncAdr('glFogCoordfEXT');
public z_FogCoordfEXT_ovr_0 := GetFuncOrNil&<procedure(coord: single)>(z_FogCoordfEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordfEXT(coord: single);
begin
z_FogCoordfEXT_ovr_0(coord);
end;
public z_FogCoordfvEXT_adr := GetFuncAdr('glFogCoordfvEXT');
public z_FogCoordfvEXT_ovr_0 := GetFuncOrNil&<procedure(var coord: single)>(z_FogCoordfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordfvEXT(coord: array of single);
begin
z_FogCoordfvEXT_ovr_0(coord[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordfvEXT(var coord: single);
begin
z_FogCoordfvEXT_ovr_0(coord);
end;
public z_FogCoordfvEXT_ovr_2 := GetFuncOrNil&<procedure(coord: IntPtr)>(z_FogCoordfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordfvEXT(coord: IntPtr);
begin
z_FogCoordfvEXT_ovr_2(coord);
end;
public z_FogCoorddEXT_adr := GetFuncAdr('glFogCoorddEXT');
public z_FogCoorddEXT_ovr_0 := GetFuncOrNil&<procedure(coord: real)>(z_FogCoorddEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoorddEXT(coord: real);
begin
z_FogCoorddEXT_ovr_0(coord);
end;
public z_FogCoorddvEXT_adr := GetFuncAdr('glFogCoorddvEXT');
public z_FogCoorddvEXT_ovr_0 := GetFuncOrNil&<procedure(var coord: real)>(z_FogCoorddvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoorddvEXT(coord: array of real);
begin
z_FogCoorddvEXT_ovr_0(coord[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoorddvEXT(var coord: real);
begin
z_FogCoorddvEXT_ovr_0(coord);
end;
public z_FogCoorddvEXT_ovr_2 := GetFuncOrNil&<procedure(coord: IntPtr)>(z_FogCoorddvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoorddvEXT(coord: IntPtr);
begin
z_FogCoorddvEXT_ovr_2(coord);
end;
public z_FogCoordPointerEXT_adr := GetFuncAdr('glFogCoordPointerEXT');
public z_FogCoordPointerEXT_ovr_0 := GetFuncOrNil&<procedure(&type: FogPointerTypeEXT; stride: Int32; pointer: IntPtr)>(z_FogCoordPointerEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordPointerEXT(&type: FogPointerTypeEXT; stride: Int32; pointer: IntPtr);
begin
z_FogCoordPointerEXT_ovr_0(&type, stride, pointer);
end;
end;
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);
public z_BlitFramebufferEXT_adr := GetFuncAdr('glBlitFramebufferEXT');
public z_BlitFramebufferEXT_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_BlitFramebufferEXT_adr);
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);
begin
z_BlitFramebufferEXT_ovr_0(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
end;
end;
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);
public z_RenderbufferStorageMultisampleEXT_adr := GetFuncAdr('glRenderbufferStorageMultisampleEXT');
public z_RenderbufferStorageMultisampleEXT_ovr_0 := GetFuncOrNil&<procedure(target: RenderbufferTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32)>(z_RenderbufferStorageMultisampleEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RenderbufferStorageMultisampleEXT(target: RenderbufferTarget; samples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32);
begin
z_RenderbufferStorageMultisampleEXT_ovr_0(target, samples, _internalformat, width, height);
end;
end;
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);
public z_IsRenderbufferEXT_adr := GetFuncAdr('glIsRenderbufferEXT');
public z_IsRenderbufferEXT_ovr_0 := GetFuncOrNil&<function(renderbuffer: UInt32): boolean>(z_IsRenderbufferEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsRenderbufferEXT(renderbuffer: UInt32): boolean;
begin
Result := z_IsRenderbufferEXT_ovr_0(renderbuffer);
end;
public z_BindRenderbufferEXT_adr := GetFuncAdr('glBindRenderbufferEXT');
public z_BindRenderbufferEXT_ovr_0 := GetFuncOrNil&<procedure(target: RenderbufferTarget; renderbuffer: UInt32)>(z_BindRenderbufferEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindRenderbufferEXT(target: RenderbufferTarget; renderbuffer: UInt32);
begin
z_BindRenderbufferEXT_ovr_0(target, renderbuffer);
end;
public z_DeleteRenderbuffersEXT_adr := GetFuncAdr('glDeleteRenderbuffersEXT');
public z_DeleteRenderbuffersEXT_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var renderbuffers: UInt32)>(z_DeleteRenderbuffersEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteRenderbuffersEXT(n: Int32; renderbuffers: array of UInt32);
begin
z_DeleteRenderbuffersEXT_ovr_0(n, renderbuffers[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteRenderbuffersEXT(n: Int32; var renderbuffers: UInt32);
begin
z_DeleteRenderbuffersEXT_ovr_0(n, renderbuffers);
end;
public z_DeleteRenderbuffersEXT_ovr_2 := GetFuncOrNil&<procedure(n: Int32; renderbuffers: IntPtr)>(z_DeleteRenderbuffersEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteRenderbuffersEXT(n: Int32; renderbuffers: IntPtr);
begin
z_DeleteRenderbuffersEXT_ovr_2(n, renderbuffers);
end;
public z_GenRenderbuffersEXT_adr := GetFuncAdr('glGenRenderbuffersEXT');
public z_GenRenderbuffersEXT_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var renderbuffers: UInt32)>(z_GenRenderbuffersEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenRenderbuffersEXT(n: Int32; renderbuffers: array of UInt32);
begin
z_GenRenderbuffersEXT_ovr_0(n, renderbuffers[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenRenderbuffersEXT(n: Int32; var renderbuffers: UInt32);
begin
z_GenRenderbuffersEXT_ovr_0(n, renderbuffers);
end;
public z_GenRenderbuffersEXT_ovr_2 := GetFuncOrNil&<procedure(n: Int32; renderbuffers: IntPtr)>(z_GenRenderbuffersEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenRenderbuffersEXT(n: Int32; renderbuffers: IntPtr);
begin
z_GenRenderbuffersEXT_ovr_2(n, renderbuffers);
end;
public z_RenderbufferStorageEXT_adr := GetFuncAdr('glRenderbufferStorageEXT');
public z_RenderbufferStorageEXT_ovr_0 := GetFuncOrNil&<procedure(target: RenderbufferTarget; _internalformat: InternalFormat; width: Int32; height: Int32)>(z_RenderbufferStorageEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RenderbufferStorageEXT(target: RenderbufferTarget; _internalformat: InternalFormat; width: Int32; height: Int32);
begin
z_RenderbufferStorageEXT_ovr_0(target, _internalformat, width, height);
end;
public z_GetRenderbufferParameterivEXT_adr := GetFuncAdr('glGetRenderbufferParameterivEXT');
public z_GetRenderbufferParameterivEXT_ovr_0 := GetFuncOrNil&<procedure(target: RenderbufferTarget; pname: RenderbufferParameterName; var ¶ms: Int32)>(z_GetRenderbufferParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetRenderbufferParameterivEXT(target: RenderbufferTarget; pname: RenderbufferParameterName; ¶ms: array of Int32);
begin
z_GetRenderbufferParameterivEXT_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetRenderbufferParameterivEXT(target: RenderbufferTarget; pname: RenderbufferParameterName; var ¶ms: Int32);
begin
z_GetRenderbufferParameterivEXT_ovr_0(target, pname, ¶ms);
end;
public z_GetRenderbufferParameterivEXT_ovr_2 := GetFuncOrNil&<procedure(target: RenderbufferTarget; pname: RenderbufferParameterName; ¶ms: IntPtr)>(z_GetRenderbufferParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetRenderbufferParameterivEXT(target: RenderbufferTarget; pname: RenderbufferParameterName; ¶ms: IntPtr);
begin
z_GetRenderbufferParameterivEXT_ovr_2(target, pname, ¶ms);
end;
public z_IsFramebufferEXT_adr := GetFuncAdr('glIsFramebufferEXT');
public z_IsFramebufferEXT_ovr_0 := GetFuncOrNil&<function(framebuffer: UInt32): boolean>(z_IsFramebufferEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsFramebufferEXT(framebuffer: UInt32): boolean;
begin
Result := z_IsFramebufferEXT_ovr_0(framebuffer);
end;
public z_BindFramebufferEXT_adr := GetFuncAdr('glBindFramebufferEXT');
public z_BindFramebufferEXT_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; framebuffer: UInt32)>(z_BindFramebufferEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindFramebufferEXT(target: FramebufferTarget; framebuffer: UInt32);
begin
z_BindFramebufferEXT_ovr_0(target, framebuffer);
end;
public z_DeleteFramebuffersEXT_adr := GetFuncAdr('glDeleteFramebuffersEXT');
public z_DeleteFramebuffersEXT_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var framebuffers: UInt32)>(z_DeleteFramebuffersEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFramebuffersEXT(n: Int32; framebuffers: array of UInt32);
begin
z_DeleteFramebuffersEXT_ovr_0(n, framebuffers[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFramebuffersEXT(n: Int32; var framebuffers: UInt32);
begin
z_DeleteFramebuffersEXT_ovr_0(n, framebuffers);
end;
public z_DeleteFramebuffersEXT_ovr_2 := GetFuncOrNil&<procedure(n: Int32; framebuffers: IntPtr)>(z_DeleteFramebuffersEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFramebuffersEXT(n: Int32; framebuffers: IntPtr);
begin
z_DeleteFramebuffersEXT_ovr_2(n, framebuffers);
end;
public z_GenFramebuffersEXT_adr := GetFuncAdr('glGenFramebuffersEXT');
public z_GenFramebuffersEXT_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var framebuffers: UInt32)>(z_GenFramebuffersEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenFramebuffersEXT(n: Int32; framebuffers: array of UInt32);
begin
z_GenFramebuffersEXT_ovr_0(n, framebuffers[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenFramebuffersEXT(n: Int32; var framebuffers: UInt32);
begin
z_GenFramebuffersEXT_ovr_0(n, framebuffers);
end;
public z_GenFramebuffersEXT_ovr_2 := GetFuncOrNil&<procedure(n: Int32; framebuffers: IntPtr)>(z_GenFramebuffersEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenFramebuffersEXT(n: Int32; framebuffers: IntPtr);
begin
z_GenFramebuffersEXT_ovr_2(n, framebuffers);
end;
public z_CheckFramebufferStatusEXT_adr := GetFuncAdr('glCheckFramebufferStatusEXT');
public z_CheckFramebufferStatusEXT_ovr_0 := GetFuncOrNil&<function(target: FramebufferTarget): FramebufferStatus>(z_CheckFramebufferStatusEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CheckFramebufferStatusEXT(target: FramebufferTarget): FramebufferStatus;
begin
Result := z_CheckFramebufferStatusEXT_ovr_0(target);
end;
public z_FramebufferTexture1DEXT_adr := GetFuncAdr('glFramebufferTexture1DEXT');
public z_FramebufferTexture1DEXT_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32)>(z_FramebufferTexture1DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTexture1DEXT(target: FramebufferTarget; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32);
begin
z_FramebufferTexture1DEXT_ovr_0(target, attachment, textarget, texture, level);
end;
public z_FramebufferTexture2DEXT_adr := GetFuncAdr('glFramebufferTexture2DEXT');
public z_FramebufferTexture2DEXT_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32)>(z_FramebufferTexture2DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTexture2DEXT(target: FramebufferTarget; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32);
begin
z_FramebufferTexture2DEXT_ovr_0(target, attachment, textarget, texture, level);
end;
public z_FramebufferTexture3DEXT_adr := GetFuncAdr('glFramebufferTexture3DEXT');
public z_FramebufferTexture3DEXT_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32; zoffset: Int32)>(z_FramebufferTexture3DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTexture3DEXT(target: FramebufferTarget; attachment: FramebufferAttachment; textarget: TextureTarget; texture: UInt32; level: Int32; zoffset: Int32);
begin
z_FramebufferTexture3DEXT_ovr_0(target, attachment, textarget, texture, level, zoffset);
end;
public z_FramebufferRenderbufferEXT_adr := GetFuncAdr('glFramebufferRenderbufferEXT');
public z_FramebufferRenderbufferEXT_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; attachment: FramebufferAttachment; _renderbuffertarget: RenderbufferTarget; renderbuffer: UInt32)>(z_FramebufferRenderbufferEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferRenderbufferEXT(target: FramebufferTarget; attachment: FramebufferAttachment; _renderbuffertarget: RenderbufferTarget; renderbuffer: UInt32);
begin
z_FramebufferRenderbufferEXT_ovr_0(target, attachment, _renderbuffertarget, renderbuffer);
end;
public z_GetFramebufferAttachmentParameterivEXT_adr := GetFuncAdr('glGetFramebufferAttachmentParameterivEXT');
public z_GetFramebufferAttachmentParameterivEXT_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; var ¶ms: Int32)>(z_GetFramebufferAttachmentParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferAttachmentParameterivEXT(target: FramebufferTarget; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: array of Int32);
begin
z_GetFramebufferAttachmentParameterivEXT_ovr_0(target, attachment, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferAttachmentParameterivEXT(target: FramebufferTarget; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; var ¶ms: Int32);
begin
z_GetFramebufferAttachmentParameterivEXT_ovr_0(target, attachment, pname, ¶ms);
end;
public z_GetFramebufferAttachmentParameterivEXT_ovr_2 := GetFuncOrNil&<procedure(target: FramebufferTarget; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr)>(z_GetFramebufferAttachmentParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferAttachmentParameterivEXT(target: FramebufferTarget; attachment: FramebufferAttachment; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr);
begin
z_GetFramebufferAttachmentParameterivEXT_ovr_2(target, attachment, pname, ¶ms);
end;
public z_GenerateMipmapEXT_adr := GetFuncAdr('glGenerateMipmapEXT');
public z_GenerateMipmapEXT_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget)>(z_GenerateMipmapEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenerateMipmapEXT(target: TextureTarget);
begin
z_GenerateMipmapEXT_ovr_0(target);
end;
end;
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);
public z_ProgramParameteriEXT_adr := GetFuncAdr('glProgramParameteriEXT');
public z_ProgramParameteriEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; pname: ProgramParameterPName; value: Int32)>(z_ProgramParameteriEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameteriEXT(&program: UInt32; pname: ProgramParameterPName; value: Int32);
begin
z_ProgramParameteriEXT_ovr_0(&program, pname, value);
end;
end;
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);
public z_ProgramEnvParameters4fvEXT_adr := GetFuncAdr('glProgramEnvParameters4fvEXT');
public z_ProgramEnvParameters4fvEXT_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: single)>(z_ProgramEnvParameters4fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameters4fvEXT(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: array of single);
begin
z_ProgramEnvParameters4fvEXT_ovr_0(target, index, count, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameters4fvEXT(target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: single);
begin
z_ProgramEnvParameters4fvEXT_ovr_0(target, index, count, ¶ms);
end;
public z_ProgramEnvParameters4fvEXT_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr)>(z_ProgramEnvParameters4fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameters4fvEXT(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr);
begin
z_ProgramEnvParameters4fvEXT_ovr_2(target, index, count, ¶ms);
end;
public z_ProgramLocalParameters4fvEXT_adr := GetFuncAdr('glProgramLocalParameters4fvEXT');
public z_ProgramLocalParameters4fvEXT_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: single)>(z_ProgramLocalParameters4fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameters4fvEXT(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: array of single);
begin
z_ProgramLocalParameters4fvEXT_ovr_0(target, index, count, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameters4fvEXT(target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: single);
begin
z_ProgramLocalParameters4fvEXT_ovr_0(target, index, count, ¶ms);
end;
public z_ProgramLocalParameters4fvEXT_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr)>(z_ProgramLocalParameters4fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameters4fvEXT(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr);
begin
z_ProgramLocalParameters4fvEXT_ovr_2(target, index, count, ¶ms);
end;
end;
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);
public z_GetUniformuivEXT_adr := GetFuncAdr('glGetUniformuivEXT');
public z_GetUniformuivEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; var ¶ms: UInt32)>(z_GetUniformuivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformuivEXT(&program: UInt32; location: Int32; ¶ms: array of UInt32);
begin
z_GetUniformuivEXT_ovr_0(&program, location, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformuivEXT(&program: UInt32; location: Int32; var ¶ms: UInt32);
begin
z_GetUniformuivEXT_ovr_0(&program, location, ¶ms);
end;
public z_GetUniformuivEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; ¶ms: IntPtr)>(z_GetUniformuivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformuivEXT(&program: UInt32; location: Int32; ¶ms: IntPtr);
begin
z_GetUniformuivEXT_ovr_2(&program, location, ¶ms);
end;
public z_BindFragDataLocationEXT_adr := GetFuncAdr('glBindFragDataLocationEXT');
public z_BindFragDataLocationEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; color: UInt32; name: IntPtr)>(z_BindFragDataLocationEXT_adr);
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);
begin
z_BindFragDataLocationEXT_ovr_0(&program, color, name);
end;
public z_GetFragDataLocationEXT_adr := GetFuncAdr('glGetFragDataLocationEXT');
public z_GetFragDataLocationEXT_ovr_0 := GetFuncOrNil&<function(&program: UInt32; name: IntPtr): Int32>(z_GetFragDataLocationEXT_adr);
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;
begin
Result := z_GetFragDataLocationEXT_ovr_0(&program, name);
end;
public z_Uniform1uiEXT_adr := GetFuncAdr('glUniform1uiEXT');
public z_Uniform1uiEXT_ovr_0 := GetFuncOrNil&<procedure(location: Int32; v0: UInt32)>(z_Uniform1uiEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1uiEXT(location: Int32; v0: UInt32);
begin
z_Uniform1uiEXT_ovr_0(location, v0);
end;
public z_Uniform2uiEXT_adr := GetFuncAdr('glUniform2uiEXT');
public z_Uniform2uiEXT_ovr_0 := GetFuncOrNil&<procedure(location: Int32; v0: UInt32; v1: UInt32)>(z_Uniform2uiEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2uiEXT(location: Int32; v0: UInt32; v1: UInt32);
begin
z_Uniform2uiEXT_ovr_0(location, v0, v1);
end;
public z_Uniform3uiEXT_adr := GetFuncAdr('glUniform3uiEXT');
public z_Uniform3uiEXT_ovr_0 := GetFuncOrNil&<procedure(location: Int32; v0: UInt32; v1: UInt32; v2: UInt32)>(z_Uniform3uiEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3uiEXT(location: Int32; v0: UInt32; v1: UInt32; v2: UInt32);
begin
z_Uniform3uiEXT_ovr_0(location, v0, v1, v2);
end;
public z_Uniform4uiEXT_adr := GetFuncAdr('glUniform4uiEXT');
public z_Uniform4uiEXT_ovr_0 := GetFuncOrNil&<procedure(location: Int32; v0: UInt32; v1: UInt32; v2: UInt32; v3: UInt32)>(z_Uniform4uiEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4uiEXT(location: Int32; v0: UInt32; v1: UInt32; v2: UInt32; v3: UInt32);
begin
z_Uniform4uiEXT_ovr_0(location, v0, v1, v2, v3);
end;
public z_Uniform1uivEXT_adr := GetFuncAdr('glUniform1uivEXT');
public z_Uniform1uivEXT_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: UInt32)>(z_Uniform1uivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1uivEXT(location: Int32; count: Int32; value: array of UInt32);
begin
z_Uniform1uivEXT_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1uivEXT(location: Int32; count: Int32; var value: UInt32);
begin
z_Uniform1uivEXT_ovr_0(location, count, value);
end;
public z_Uniform1uivEXT_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform1uivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1uivEXT(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform1uivEXT_ovr_2(location, count, value);
end;
public z_Uniform2uivEXT_adr := GetFuncAdr('glUniform2uivEXT');
public z_Uniform2uivEXT_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: UInt32)>(z_Uniform2uivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2uivEXT(location: Int32; count: Int32; value: array of UInt32);
begin
z_Uniform2uivEXT_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2uivEXT(location: Int32; count: Int32; var value: UInt32);
begin
z_Uniform2uivEXT_ovr_0(location, count, value);
end;
public z_Uniform2uivEXT_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform2uivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2uivEXT(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform2uivEXT_ovr_2(location, count, value);
end;
public z_Uniform3uivEXT_adr := GetFuncAdr('glUniform3uivEXT');
public z_Uniform3uivEXT_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: UInt32)>(z_Uniform3uivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3uivEXT(location: Int32; count: Int32; value: array of UInt32);
begin
z_Uniform3uivEXT_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3uivEXT(location: Int32; count: Int32; var value: UInt32);
begin
z_Uniform3uivEXT_ovr_0(location, count, value);
end;
public z_Uniform3uivEXT_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform3uivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3uivEXT(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform3uivEXT_ovr_2(location, count, value);
end;
public z_Uniform4uivEXT_adr := GetFuncAdr('glUniform4uivEXT');
public z_Uniform4uivEXT_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: UInt32)>(z_Uniform4uivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4uivEXT(location: Int32; count: Int32; value: array of UInt32);
begin
z_Uniform4uivEXT_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4uivEXT(location: Int32; count: Int32; var value: UInt32);
begin
z_Uniform4uivEXT_ovr_0(location, count, value);
end;
public z_Uniform4uivEXT_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform4uivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4uivEXT(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform4uivEXT_ovr_2(location, count, value);
end;
end;
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);
public z_GetHistogramEXT_adr := GetFuncAdr('glGetHistogramEXT');
public z_GetHistogramEXT_ovr_0 := GetFuncOrNil&<procedure(target: HistogramTargetEXT; reset: boolean; format: PixelFormat; &type: PixelType; values: IntPtr)>(z_GetHistogramEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetHistogramEXT(target: HistogramTargetEXT; reset: boolean; format: PixelFormat; &type: PixelType; values: IntPtr);
begin
z_GetHistogramEXT_ovr_0(target, reset, format, &type, values);
end;
public z_GetHistogramParameterfvEXT_adr := GetFuncAdr('glGetHistogramParameterfvEXT');
public z_GetHistogramParameterfvEXT_ovr_0 := GetFuncOrNil&<procedure(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; var ¶ms: single)>(z_GetHistogramParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetHistogramParameterfvEXT(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: array of single);
begin
z_GetHistogramParameterfvEXT_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetHistogramParameterfvEXT(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; var ¶ms: single);
begin
z_GetHistogramParameterfvEXT_ovr_0(target, pname, ¶ms);
end;
public z_GetHistogramParameterfvEXT_ovr_2 := GetFuncOrNil&<procedure(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: IntPtr)>(z_GetHistogramParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetHistogramParameterfvEXT(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: IntPtr);
begin
z_GetHistogramParameterfvEXT_ovr_2(target, pname, ¶ms);
end;
public z_GetHistogramParameterivEXT_adr := GetFuncAdr('glGetHistogramParameterivEXT');
public z_GetHistogramParameterivEXT_ovr_0 := GetFuncOrNil&<procedure(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; var ¶ms: Int32)>(z_GetHistogramParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetHistogramParameterivEXT(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: array of Int32);
begin
z_GetHistogramParameterivEXT_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetHistogramParameterivEXT(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; var ¶ms: Int32);
begin
z_GetHistogramParameterivEXT_ovr_0(target, pname, ¶ms);
end;
public z_GetHistogramParameterivEXT_ovr_2 := GetFuncOrNil&<procedure(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: IntPtr)>(z_GetHistogramParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetHistogramParameterivEXT(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: IntPtr);
begin
z_GetHistogramParameterivEXT_ovr_2(target, pname, ¶ms);
end;
public z_GetMinmaxEXT_adr := GetFuncAdr('glGetMinmaxEXT');
public z_GetMinmaxEXT_ovr_0 := GetFuncOrNil&<procedure(target: MinmaxTargetEXT; reset: boolean; format: PixelFormat; &type: PixelType; values: IntPtr)>(z_GetMinmaxEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMinmaxEXT(target: MinmaxTargetEXT; reset: boolean; format: PixelFormat; &type: PixelType; values: IntPtr);
begin
z_GetMinmaxEXT_ovr_0(target, reset, format, &type, values);
end;
public z_GetMinmaxParameterfvEXT_adr := GetFuncAdr('glGetMinmaxParameterfvEXT');
public z_GetMinmaxParameterfvEXT_ovr_0 := GetFuncOrNil&<procedure(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; var ¶ms: single)>(z_GetMinmaxParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMinmaxParameterfvEXT(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; ¶ms: array of single);
begin
z_GetMinmaxParameterfvEXT_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMinmaxParameterfvEXT(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; var ¶ms: single);
begin
z_GetMinmaxParameterfvEXT_ovr_0(target, pname, ¶ms);
end;
public z_GetMinmaxParameterfvEXT_ovr_2 := GetFuncOrNil&<procedure(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; ¶ms: IntPtr)>(z_GetMinmaxParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMinmaxParameterfvEXT(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; ¶ms: IntPtr);
begin
z_GetMinmaxParameterfvEXT_ovr_2(target, pname, ¶ms);
end;
public z_GetMinmaxParameterivEXT_adr := GetFuncAdr('glGetMinmaxParameterivEXT');
public z_GetMinmaxParameterivEXT_ovr_0 := GetFuncOrNil&<procedure(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; var ¶ms: Int32)>(z_GetMinmaxParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMinmaxParameterivEXT(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; ¶ms: array of Int32);
begin
z_GetMinmaxParameterivEXT_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMinmaxParameterivEXT(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; var ¶ms: Int32);
begin
z_GetMinmaxParameterivEXT_ovr_0(target, pname, ¶ms);
end;
public z_GetMinmaxParameterivEXT_ovr_2 := GetFuncOrNil&<procedure(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; ¶ms: IntPtr)>(z_GetMinmaxParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMinmaxParameterivEXT(target: MinmaxTargetEXT; pname: GetMinmaxParameterPNameEXT; ¶ms: IntPtr);
begin
z_GetMinmaxParameterivEXT_ovr_2(target, pname, ¶ms);
end;
public z_HistogramEXT_adr := GetFuncAdr('glHistogramEXT');
public z_HistogramEXT_ovr_0 := GetFuncOrNil&<procedure(target: HistogramTargetEXT; width: Int32; _internalformat: InternalFormat; sink: boolean)>(z_HistogramEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure HistogramEXT(target: HistogramTargetEXT; width: Int32; _internalformat: InternalFormat; sink: boolean);
begin
z_HistogramEXT_ovr_0(target, width, _internalformat, sink);
end;
public z_MinmaxEXT_adr := GetFuncAdr('glMinmaxEXT');
public z_MinmaxEXT_ovr_0 := GetFuncOrNil&<procedure(target: MinmaxTargetEXT; _internalformat: InternalFormat; sink: boolean)>(z_MinmaxEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MinmaxEXT(target: MinmaxTargetEXT; _internalformat: InternalFormat; sink: boolean);
begin
z_MinmaxEXT_ovr_0(target, _internalformat, sink);
end;
public z_ResetHistogramEXT_adr := GetFuncAdr('glResetHistogramEXT');
public z_ResetHistogramEXT_ovr_0 := GetFuncOrNil&<procedure(target: HistogramTargetEXT)>(z_ResetHistogramEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ResetHistogramEXT(target: HistogramTargetEXT);
begin
z_ResetHistogramEXT_ovr_0(target);
end;
public z_ResetMinmaxEXT_adr := GetFuncAdr('glResetMinmaxEXT');
public z_ResetMinmaxEXT_ovr_0 := GetFuncOrNil&<procedure(target: MinmaxTargetEXT)>(z_ResetMinmaxEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ResetMinmaxEXT(target: MinmaxTargetEXT);
begin
z_ResetMinmaxEXT_ovr_0(target);
end;
end;
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);
public z_IndexFuncEXT_adr := GetFuncAdr('glIndexFuncEXT');
public z_IndexFuncEXT_ovr_0 := GetFuncOrNil&<procedure(func: IndexFunctionEXT; ref: single)>(z_IndexFuncEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IndexFuncEXT(func: IndexFunctionEXT; ref: single);
begin
z_IndexFuncEXT_ovr_0(func, ref);
end;
end;
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);
public z_IndexMaterialEXT_adr := GetFuncAdr('glIndexMaterialEXT');
public z_IndexMaterialEXT_ovr_0 := GetFuncOrNil&<procedure(face: DummyEnum; mode: IndexMaterialParameterEXT)>(z_IndexMaterialEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IndexMaterialEXT(face: DummyEnum; mode: IndexMaterialParameterEXT);
begin
z_IndexMaterialEXT_ovr_0(face, mode);
end;
end;
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);
public z_ApplyTextureEXT_adr := GetFuncAdr('glApplyTextureEXT');
public z_ApplyTextureEXT_ovr_0 := GetFuncOrNil&<procedure(mode: LightTextureModeEXT)>(z_ApplyTextureEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ApplyTextureEXT(mode: LightTextureModeEXT);
begin
z_ApplyTextureEXT_ovr_0(mode);
end;
public z_TextureLightEXT_adr := GetFuncAdr('glTextureLightEXT');
public z_TextureLightEXT_ovr_0 := GetFuncOrNil&<procedure(pname: LightTexturePNameEXT)>(z_TextureLightEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureLightEXT(pname: LightTexturePNameEXT);
begin
z_TextureLightEXT_ovr_0(pname);
end;
public z_TextureMaterialEXT_adr := GetFuncAdr('glTextureMaterialEXT');
public z_TextureMaterialEXT_ovr_0 := GetFuncOrNil&<procedure(face: DummyEnum; mode: MaterialParameter)>(z_TextureMaterialEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureMaterialEXT(face: DummyEnum; mode: MaterialParameter);
begin
z_TextureMaterialEXT_ovr_0(face, mode);
end;
end;
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);
public z_GetUnsignedBytevEXT_adr := GetFuncAdr('glGetUnsignedBytevEXT');
public z_GetUnsignedBytevEXT_ovr_0 := GetFuncOrNil&<procedure(pname: GetPName; var data: Byte)>(z_GetUnsignedBytevEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUnsignedBytevEXT(pname: GetPName; data: array of Byte);
begin
z_GetUnsignedBytevEXT_ovr_0(pname, data[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUnsignedBytevEXT(pname: GetPName; var data: Byte);
begin
z_GetUnsignedBytevEXT_ovr_0(pname, data);
end;
public z_GetUnsignedBytevEXT_ovr_2 := GetFuncOrNil&<procedure(pname: GetPName; data: IntPtr)>(z_GetUnsignedBytevEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUnsignedBytevEXT(pname: GetPName; data: IntPtr);
begin
z_GetUnsignedBytevEXT_ovr_2(pname, data);
end;
public z_GetUnsignedBytei_vEXT_adr := GetFuncAdr('glGetUnsignedBytei_vEXT');
public z_GetUnsignedBytei_vEXT_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; var data: Byte)>(z_GetUnsignedBytei_vEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUnsignedBytei_vEXT(target: DummyEnum; index: UInt32; data: array of Byte);
begin
z_GetUnsignedBytei_vEXT_ovr_0(target, index, data[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUnsignedBytei_vEXT(target: DummyEnum; index: UInt32; var data: Byte);
begin
z_GetUnsignedBytei_vEXT_ovr_0(target, index, data);
end;
public z_GetUnsignedBytei_vEXT_ovr_2 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; data: IntPtr)>(z_GetUnsignedBytei_vEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUnsignedBytei_vEXT(target: DummyEnum; index: UInt32; data: IntPtr);
begin
z_GetUnsignedBytei_vEXT_ovr_2(target, index, data);
end;
public z_DeleteMemoryObjectsEXT_adr := GetFuncAdr('glDeleteMemoryObjectsEXT');
public z_DeleteMemoryObjectsEXT_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var memoryObjects: UInt32)>(z_DeleteMemoryObjectsEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteMemoryObjectsEXT(n: Int32; memoryObjects: array of UInt32);
begin
z_DeleteMemoryObjectsEXT_ovr_0(n, memoryObjects[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteMemoryObjectsEXT(n: Int32; var memoryObjects: UInt32);
begin
z_DeleteMemoryObjectsEXT_ovr_0(n, memoryObjects);
end;
public z_DeleteMemoryObjectsEXT_ovr_2 := GetFuncOrNil&<procedure(n: Int32; memoryObjects: IntPtr)>(z_DeleteMemoryObjectsEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteMemoryObjectsEXT(n: Int32; memoryObjects: IntPtr);
begin
z_DeleteMemoryObjectsEXT_ovr_2(n, memoryObjects);
end;
public z_IsMemoryObjectEXT_adr := GetFuncAdr('glIsMemoryObjectEXT');
public z_IsMemoryObjectEXT_ovr_0 := GetFuncOrNil&<function(memoryObject: UInt32): boolean>(z_IsMemoryObjectEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsMemoryObjectEXT(memoryObject: UInt32): boolean;
begin
Result := z_IsMemoryObjectEXT_ovr_0(memoryObject);
end;
public z_CreateMemoryObjectsEXT_adr := GetFuncAdr('glCreateMemoryObjectsEXT');
public z_CreateMemoryObjectsEXT_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var memoryObjects: UInt32)>(z_CreateMemoryObjectsEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateMemoryObjectsEXT(n: Int32; memoryObjects: array of UInt32);
begin
z_CreateMemoryObjectsEXT_ovr_0(n, memoryObjects[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateMemoryObjectsEXT(n: Int32; var memoryObjects: UInt32);
begin
z_CreateMemoryObjectsEXT_ovr_0(n, memoryObjects);
end;
public z_CreateMemoryObjectsEXT_ovr_2 := GetFuncOrNil&<procedure(n: Int32; memoryObjects: IntPtr)>(z_CreateMemoryObjectsEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateMemoryObjectsEXT(n: Int32; memoryObjects: IntPtr);
begin
z_CreateMemoryObjectsEXT_ovr_2(n, memoryObjects);
end;
public z_MemoryObjectParameterivEXT_adr := GetFuncAdr('glMemoryObjectParameterivEXT');
public z_MemoryObjectParameterivEXT_ovr_0 := GetFuncOrNil&<procedure(memoryObject: UInt32; pname: MemoryObjectParameterName; var ¶ms: Int32)>(z_MemoryObjectParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MemoryObjectParameterivEXT(memoryObject: UInt32; pname: MemoryObjectParameterName; ¶ms: array of Int32);
begin
z_MemoryObjectParameterivEXT_ovr_0(memoryObject, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MemoryObjectParameterivEXT(memoryObject: UInt32; pname: MemoryObjectParameterName; var ¶ms: Int32);
begin
z_MemoryObjectParameterivEXT_ovr_0(memoryObject, pname, ¶ms);
end;
public z_MemoryObjectParameterivEXT_ovr_2 := GetFuncOrNil&<procedure(memoryObject: UInt32; pname: MemoryObjectParameterName; ¶ms: IntPtr)>(z_MemoryObjectParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MemoryObjectParameterivEXT(memoryObject: UInt32; pname: MemoryObjectParameterName; ¶ms: IntPtr);
begin
z_MemoryObjectParameterivEXT_ovr_2(memoryObject, pname, ¶ms);
end;
public z_GetMemoryObjectParameterivEXT_adr := GetFuncAdr('glGetMemoryObjectParameterivEXT');
public z_GetMemoryObjectParameterivEXT_ovr_0 := GetFuncOrNil&<procedure(memoryObject: UInt32; pname: MemoryObjectParameterName; var ¶ms: Int32)>(z_GetMemoryObjectParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMemoryObjectParameterivEXT(memoryObject: UInt32; pname: MemoryObjectParameterName; ¶ms: array of Int32);
begin
z_GetMemoryObjectParameterivEXT_ovr_0(memoryObject, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMemoryObjectParameterivEXT(memoryObject: UInt32; pname: MemoryObjectParameterName; var ¶ms: Int32);
begin
z_GetMemoryObjectParameterivEXT_ovr_0(memoryObject, pname, ¶ms);
end;
public z_GetMemoryObjectParameterivEXT_ovr_2 := GetFuncOrNil&<procedure(memoryObject: UInt32; pname: MemoryObjectParameterName; ¶ms: IntPtr)>(z_GetMemoryObjectParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMemoryObjectParameterivEXT(memoryObject: UInt32; pname: MemoryObjectParameterName; ¶ms: IntPtr);
begin
z_GetMemoryObjectParameterivEXT_ovr_2(memoryObject, pname, ¶ms);
end;
public z_TexStorageMem2DEXT_adr := GetFuncAdr('glTexStorageMem2DEXT');
public z_TexStorageMem2DEXT_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; levels: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; memory: UInt32; offset: UInt64)>(z_TexStorageMem2DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexStorageMem2DEXT(target: TextureTarget; levels: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; memory: UInt32; offset: UInt64);
begin
z_TexStorageMem2DEXT_ovr_0(target, levels, internalFormat, width, height, memory, offset);
end;
public z_TexStorageMem2DMultisampleEXT_adr := GetFuncAdr('glTexStorageMem2DMultisampleEXT');
public z_TexStorageMem2DMultisampleEXT_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; samples: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; fixedSampleLocations: boolean; memory: UInt32; offset: UInt64)>(z_TexStorageMem2DMultisampleEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexStorageMem2DMultisampleEXT(target: TextureTarget; samples: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; fixedSampleLocations: boolean; memory: UInt32; offset: UInt64);
begin
z_TexStorageMem2DMultisampleEXT_ovr_0(target, samples, internalFormat, width, height, fixedSampleLocations, memory, offset);
end;
public z_TexStorageMem3DEXT_adr := GetFuncAdr('glTexStorageMem3DEXT');
public z_TexStorageMem3DEXT_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; levels: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; depth: Int32; memory: UInt32; offset: UInt64)>(z_TexStorageMem3DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexStorageMem3DEXT(target: TextureTarget; levels: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; depth: Int32; memory: UInt32; offset: UInt64);
begin
z_TexStorageMem3DEXT_ovr_0(target, levels, internalFormat, width, height, depth, memory, offset);
end;
public z_TexStorageMem3DMultisampleEXT_adr := GetFuncAdr('glTexStorageMem3DMultisampleEXT');
public z_TexStorageMem3DMultisampleEXT_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; samples: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; depth: Int32; fixedSampleLocations: boolean; memory: UInt32; offset: UInt64)>(z_TexStorageMem3DMultisampleEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexStorageMem3DMultisampleEXT(target: TextureTarget; samples: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; depth: Int32; fixedSampleLocations: boolean; memory: UInt32; offset: UInt64);
begin
z_TexStorageMem3DMultisampleEXT_ovr_0(target, samples, internalFormat, width, height, depth, fixedSampleLocations, memory, offset);
end;
public z_BufferStorageMemEXT_adr := GetFuncAdr('glBufferStorageMemEXT');
public z_BufferStorageMemEXT_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; size: IntPtr; memory: UInt32; offset: UInt64)>(z_BufferStorageMemEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferStorageMemEXT(target: BufferTargetARB; size: IntPtr; memory: UInt32; offset: UInt64);
begin
z_BufferStorageMemEXT_ovr_0(target, size, memory, offset);
end;
public z_TextureStorageMem2DEXT_adr := GetFuncAdr('glTextureStorageMem2DEXT');
public z_TextureStorageMem2DEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; levels: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; memory: UInt32; offset: UInt64)>(z_TextureStorageMem2DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorageMem2DEXT(texture: UInt32; levels: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; memory: UInt32; offset: UInt64);
begin
z_TextureStorageMem2DEXT_ovr_0(texture, levels, internalFormat, width, height, memory, offset);
end;
public z_TextureStorageMem2DMultisampleEXT_adr := GetFuncAdr('glTextureStorageMem2DMultisampleEXT');
public z_TextureStorageMem2DMultisampleEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; samples: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; fixedSampleLocations: boolean; memory: UInt32; offset: UInt64)>(z_TextureStorageMem2DMultisampleEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorageMem2DMultisampleEXT(texture: UInt32; samples: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; fixedSampleLocations: boolean; memory: UInt32; offset: UInt64);
begin
z_TextureStorageMem2DMultisampleEXT_ovr_0(texture, samples, internalFormat, width, height, fixedSampleLocations, memory, offset);
end;
public z_TextureStorageMem3DEXT_adr := GetFuncAdr('glTextureStorageMem3DEXT');
public z_TextureStorageMem3DEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; levels: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; depth: Int32; memory: UInt32; offset: UInt64)>(z_TextureStorageMem3DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorageMem3DEXT(texture: UInt32; levels: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; depth: Int32; memory: UInt32; offset: UInt64);
begin
z_TextureStorageMem3DEXT_ovr_0(texture, levels, internalFormat, width, height, depth, memory, offset);
end;
public z_TextureStorageMem3DMultisampleEXT_adr := GetFuncAdr('glTextureStorageMem3DMultisampleEXT');
public z_TextureStorageMem3DMultisampleEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; samples: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; depth: Int32; fixedSampleLocations: boolean; memory: UInt32; offset: UInt64)>(z_TextureStorageMem3DMultisampleEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorageMem3DMultisampleEXT(texture: UInt32; samples: Int32; internalFormat: DummyEnum; width: Int32; height: Int32; depth: Int32; fixedSampleLocations: boolean; memory: UInt32; offset: UInt64);
begin
z_TextureStorageMem3DMultisampleEXT_ovr_0(texture, samples, internalFormat, width, height, depth, fixedSampleLocations, memory, offset);
end;
public z_NamedBufferStorageMemEXT_adr := GetFuncAdr('glNamedBufferStorageMemEXT');
public z_NamedBufferStorageMemEXT_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; size: IntPtr; memory: UInt32; offset: UInt64)>(z_NamedBufferStorageMemEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferStorageMemEXT(buffer: UInt32; size: IntPtr; memory: UInt32; offset: UInt64);
begin
z_NamedBufferStorageMemEXT_ovr_0(buffer, size, memory, offset);
end;
public z_TexStorageMem1DEXT_adr := GetFuncAdr('glTexStorageMem1DEXT');
public z_TexStorageMem1DEXT_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; levels: Int32; internalFormat: DummyEnum; width: Int32; memory: UInt32; offset: UInt64)>(z_TexStorageMem1DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexStorageMem1DEXT(target: TextureTarget; levels: Int32; internalFormat: DummyEnum; width: Int32; memory: UInt32; offset: UInt64);
begin
z_TexStorageMem1DEXT_ovr_0(target, levels, internalFormat, width, memory, offset);
end;
public z_TextureStorageMem1DEXT_adr := GetFuncAdr('glTextureStorageMem1DEXT');
public z_TextureStorageMem1DEXT_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; levels: Int32; internalFormat: DummyEnum; width: Int32; memory: UInt32; offset: UInt64)>(z_TextureStorageMem1DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureStorageMem1DEXT(texture: UInt32; levels: Int32; internalFormat: DummyEnum; width: Int32; memory: UInt32; offset: UInt64);
begin
z_TextureStorageMem1DEXT_ovr_0(texture, levels, internalFormat, width, memory, offset);
end;
end;
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);
public z_ImportMemoryFdEXT_adr := GetFuncAdr('glImportMemoryFdEXT');
public z_ImportMemoryFdEXT_ovr_0 := GetFuncOrNil&<procedure(memory: UInt32; size: UInt64; handleType: ExternalHandleType; fd: Int32)>(z_ImportMemoryFdEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImportMemoryFdEXT(memory: UInt32; size: UInt64; handleType: ExternalHandleType; fd: Int32);
begin
z_ImportMemoryFdEXT_ovr_0(memory, size, handleType, fd);
end;
end;
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);
public z_ImportMemoryWin32HandleEXT_adr := GetFuncAdr('glImportMemoryWin32HandleEXT');
public z_ImportMemoryWin32HandleEXT_ovr_0 := GetFuncOrNil&<procedure(memory: UInt32; size: UInt64; handleType: ExternalHandleType; handle: IntPtr)>(z_ImportMemoryWin32HandleEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImportMemoryWin32HandleEXT(memory: UInt32; size: UInt64; handleType: ExternalHandleType; handle: IntPtr);
begin
z_ImportMemoryWin32HandleEXT_ovr_0(memory, size, handleType, handle);
end;
public z_ImportMemoryWin32NameEXT_adr := GetFuncAdr('glImportMemoryWin32NameEXT');
public z_ImportMemoryWin32NameEXT_ovr_0 := GetFuncOrNil&<procedure(memory: UInt32; size: UInt64; handleType: ExternalHandleType; name: IntPtr)>(z_ImportMemoryWin32NameEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImportMemoryWin32NameEXT(memory: UInt32; size: UInt64; handleType: ExternalHandleType; name: IntPtr);
begin
z_ImportMemoryWin32NameEXT_ovr_0(memory, size, handleType, name);
end;
end;
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);
public z_MultiDrawArraysEXT_adr := GetFuncAdr('glMultiDrawArraysEXT');
public z_MultiDrawArraysEXT_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; var first: Int32; var count: Int32; primcount: Int32)>(z_MultiDrawArraysEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysEXT(mode: PrimitiveType; first: array of Int32; count: array of Int32; primcount: Int32);
begin
z_MultiDrawArraysEXT_ovr_0(mode, first[0], count[0], primcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysEXT(mode: PrimitiveType; first: array of Int32; var count: Int32; primcount: Int32);
begin
z_MultiDrawArraysEXT_ovr_0(mode, first[0], count, primcount);
end;
public z_MultiDrawArraysEXT_ovr_2 := GetFuncOrNil&<procedure(mode: PrimitiveType; var first: Int32; count: IntPtr; primcount: Int32)>(z_MultiDrawArraysEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysEXT(mode: PrimitiveType; first: array of Int32; count: IntPtr; primcount: Int32);
begin
z_MultiDrawArraysEXT_ovr_2(mode, first[0], count, primcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysEXT(mode: PrimitiveType; var first: Int32; count: array of Int32; primcount: Int32);
begin
z_MultiDrawArraysEXT_ovr_0(mode, first, count[0], primcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysEXT(mode: PrimitiveType; var first: Int32; var count: Int32; primcount: Int32);
begin
z_MultiDrawArraysEXT_ovr_0(mode, first, count, primcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysEXT(mode: PrimitiveType; var first: Int32; count: IntPtr; primcount: Int32);
begin
z_MultiDrawArraysEXT_ovr_2(mode, first, count, primcount);
end;
public z_MultiDrawArraysEXT_ovr_6 := GetFuncOrNil&<procedure(mode: PrimitiveType; first: IntPtr; var count: Int32; primcount: Int32)>(z_MultiDrawArraysEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysEXT(mode: PrimitiveType; first: IntPtr; count: array of Int32; primcount: Int32);
begin
z_MultiDrawArraysEXT_ovr_6(mode, first, count[0], primcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysEXT(mode: PrimitiveType; first: IntPtr; var count: Int32; primcount: Int32);
begin
z_MultiDrawArraysEXT_ovr_6(mode, first, count, primcount);
end;
public z_MultiDrawArraysEXT_ovr_8 := GetFuncOrNil&<procedure(mode: PrimitiveType; first: IntPtr; count: IntPtr; primcount: Int32)>(z_MultiDrawArraysEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysEXT(mode: PrimitiveType; first: IntPtr; count: IntPtr; primcount: Int32);
begin
z_MultiDrawArraysEXT_ovr_8(mode, first, count, primcount);
end;
public z_MultiDrawElementsEXT_adr := GetFuncAdr('glMultiDrawElementsEXT');
public z_MultiDrawElementsEXT_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; primcount: Int32)>(z_MultiDrawElementsEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsEXT(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: array of IntPtr; primcount: Int32);
begin
z_MultiDrawElementsEXT_ovr_0(mode, count[0], &type, indices[0], primcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsEXT(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; var indices: IntPtr; primcount: Int32);
begin
z_MultiDrawElementsEXT_ovr_0(mode, count[0], &type, indices, primcount);
end;
public z_MultiDrawElementsEXT_ovr_2 := GetFuncOrNil&<procedure(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; primcount: Int32)>(z_MultiDrawElementsEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsEXT(mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: pointer; primcount: Int32);
begin
z_MultiDrawElementsEXT_ovr_2(mode, count[0], &type, indices, primcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsEXT(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: array of IntPtr; primcount: Int32);
begin
z_MultiDrawElementsEXT_ovr_0(mode, count, &type, indices[0], primcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsEXT(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; primcount: Int32);
begin
z_MultiDrawElementsEXT_ovr_0(mode, count, &type, indices, primcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsEXT(mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; primcount: Int32);
begin
z_MultiDrawElementsEXT_ovr_2(mode, count, &type, indices, primcount);
end;
public z_MultiDrawElementsEXT_ovr_6 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; primcount: Int32)>(z_MultiDrawElementsEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsEXT(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: array of IntPtr; primcount: Int32);
begin
z_MultiDrawElementsEXT_ovr_6(mode, count, &type, indices[0], primcount);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsEXT(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; primcount: Int32);
begin
z_MultiDrawElementsEXT_ovr_6(mode, count, &type, indices, primcount);
end;
public z_MultiDrawElementsEXT_ovr_8 := GetFuncOrNil&<procedure(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; primcount: Int32)>(z_MultiDrawElementsEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsEXT(mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; primcount: Int32);
begin
z_MultiDrawElementsEXT_ovr_8(mode, count, &type, indices, primcount);
end;
end;
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);
public z_SampleMaskEXT_adr := GetFuncAdr('glSampleMaskEXT');
public z_SampleMaskEXT_ovr_0 := GetFuncOrNil&<procedure(value: single; invert: boolean)>(z_SampleMaskEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SampleMaskEXT(value: single; invert: boolean);
begin
z_SampleMaskEXT_ovr_0(value, invert);
end;
public z_SamplePatternEXT_adr := GetFuncAdr('glSamplePatternEXT');
public z_SamplePatternEXT_ovr_0 := GetFuncOrNil&<procedure(pattern: OpenGL.SamplePatternEXT)>(z_SamplePatternEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplePatternEXT(pattern: OpenGL.SamplePatternEXT);
begin
z_SamplePatternEXT_ovr_0(pattern);
end;
end;
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);
public z_ColorTableEXT_adr := GetFuncAdr('glColorTableEXT');
public z_ColorTableEXT_ovr_0 := GetFuncOrNil&<procedure(target: ColorTableTarget; _internalFormat: InternalFormat; width: Int32; format: PixelFormat; &type: PixelType; table: IntPtr)>(z_ColorTableEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorTableEXT(target: ColorTableTarget; _internalFormat: InternalFormat; width: Int32; format: PixelFormat; &type: PixelType; table: IntPtr);
begin
z_ColorTableEXT_ovr_0(target, _internalFormat, width, format, &type, table);
end;
public z_GetColorTableEXT_adr := GetFuncAdr('glGetColorTableEXT');
public z_GetColorTableEXT_ovr_0 := GetFuncOrNil&<procedure(target: ColorTableTarget; format: PixelFormat; &type: PixelType; data: IntPtr)>(z_GetColorTableEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableEXT(target: ColorTableTarget; format: PixelFormat; &type: PixelType; data: IntPtr);
begin
z_GetColorTableEXT_ovr_0(target, format, &type, data);
end;
public z_GetColorTableParameterivEXT_adr := GetFuncAdr('glGetColorTableParameterivEXT');
public z_GetColorTableParameterivEXT_ovr_0 := GetFuncOrNil&<procedure(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; var ¶ms: Int32)>(z_GetColorTableParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameterivEXT(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; ¶ms: array of Int32);
begin
z_GetColorTableParameterivEXT_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameterivEXT(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; var ¶ms: Int32);
begin
z_GetColorTableParameterivEXT_ovr_0(target, pname, ¶ms);
end;
public z_GetColorTableParameterivEXT_ovr_2 := GetFuncOrNil&<procedure(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; ¶ms: IntPtr)>(z_GetColorTableParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameterivEXT(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; ¶ms: IntPtr);
begin
z_GetColorTableParameterivEXT_ovr_2(target, pname, ¶ms);
end;
public z_GetColorTableParameterfvEXT_adr := GetFuncAdr('glGetColorTableParameterfvEXT');
public z_GetColorTableParameterfvEXT_ovr_0 := GetFuncOrNil&<procedure(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; var ¶ms: single)>(z_GetColorTableParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameterfvEXT(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; ¶ms: array of single);
begin
z_GetColorTableParameterfvEXT_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameterfvEXT(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; var ¶ms: single);
begin
z_GetColorTableParameterfvEXT_ovr_0(target, pname, ¶ms);
end;
public z_GetColorTableParameterfvEXT_ovr_2 := GetFuncOrNil&<procedure(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; ¶ms: IntPtr)>(z_GetColorTableParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameterfvEXT(target: ColorTableTarget; pname: GetColorTableParameterPNameSGI; ¶ms: IntPtr);
begin
z_GetColorTableParameterfvEXT_ovr_2(target, pname, ¶ms);
end;
end;
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);
public z_PixelTransformParameteriEXT_adr := GetFuncAdr('glPixelTransformParameteriEXT');
public z_PixelTransformParameteriEXT_ovr_0 := GetFuncOrNil&<procedure(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; param: Int32)>(z_PixelTransformParameteriEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTransformParameteriEXT(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; param: Int32);
begin
z_PixelTransformParameteriEXT_ovr_0(target, pname, param);
end;
public z_PixelTransformParameterfEXT_adr := GetFuncAdr('glPixelTransformParameterfEXT');
public z_PixelTransformParameterfEXT_ovr_0 := GetFuncOrNil&<procedure(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; param: single)>(z_PixelTransformParameterfEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTransformParameterfEXT(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; param: single);
begin
z_PixelTransformParameterfEXT_ovr_0(target, pname, param);
end;
public z_PixelTransformParameterivEXT_adr := GetFuncAdr('glPixelTransformParameterivEXT');
public z_PixelTransformParameterivEXT_ovr_0 := GetFuncOrNil&<procedure(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; var ¶ms: Int32)>(z_PixelTransformParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTransformParameterivEXT(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; ¶ms: array of Int32);
begin
z_PixelTransformParameterivEXT_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTransformParameterivEXT(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; var ¶ms: Int32);
begin
z_PixelTransformParameterivEXT_ovr_0(target, pname, ¶ms);
end;
public z_PixelTransformParameterivEXT_ovr_2 := GetFuncOrNil&<procedure(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; ¶ms: IntPtr)>(z_PixelTransformParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTransformParameterivEXT(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; ¶ms: IntPtr);
begin
z_PixelTransformParameterivEXT_ovr_2(target, pname, ¶ms);
end;
public z_PixelTransformParameterfvEXT_adr := GetFuncAdr('glPixelTransformParameterfvEXT');
public z_PixelTransformParameterfvEXT_ovr_0 := GetFuncOrNil&<procedure(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; var ¶ms: single)>(z_PixelTransformParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTransformParameterfvEXT(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; ¶ms: array of single);
begin
z_PixelTransformParameterfvEXT_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTransformParameterfvEXT(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; var ¶ms: single);
begin
z_PixelTransformParameterfvEXT_ovr_0(target, pname, ¶ms);
end;
public z_PixelTransformParameterfvEXT_ovr_2 := GetFuncOrNil&<procedure(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; ¶ms: IntPtr)>(z_PixelTransformParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTransformParameterfvEXT(target: PixelTransformTargetEXT; pname: PixelTransformPNameEXT; ¶ms: IntPtr);
begin
z_PixelTransformParameterfvEXT_ovr_2(target, pname, ¶ms);
end;
public z_GetPixelTransformParameterivEXT_adr := GetFuncAdr('glGetPixelTransformParameterivEXT');
public z_GetPixelTransformParameterivEXT_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; pname: DummyEnum; var ¶ms: Int32)>(z_GetPixelTransformParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelTransformParameterivEXT(target: DummyEnum; pname: DummyEnum; ¶ms: array of Int32);
begin
z_GetPixelTransformParameterivEXT_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelTransformParameterivEXT(target: DummyEnum; pname: DummyEnum; var ¶ms: Int32);
begin
z_GetPixelTransformParameterivEXT_ovr_0(target, pname, ¶ms);
end;
public z_GetPixelTransformParameterivEXT_ovr_2 := GetFuncOrNil&<procedure(target: DummyEnum; pname: DummyEnum; ¶ms: IntPtr)>(z_GetPixelTransformParameterivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelTransformParameterivEXT(target: DummyEnum; pname: DummyEnum; ¶ms: IntPtr);
begin
z_GetPixelTransformParameterivEXT_ovr_2(target, pname, ¶ms);
end;
public z_GetPixelTransformParameterfvEXT_adr := GetFuncAdr('glGetPixelTransformParameterfvEXT');
public z_GetPixelTransformParameterfvEXT_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; pname: DummyEnum; var ¶ms: single)>(z_GetPixelTransformParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelTransformParameterfvEXT(target: DummyEnum; pname: DummyEnum; ¶ms: array of single);
begin
z_GetPixelTransformParameterfvEXT_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelTransformParameterfvEXT(target: DummyEnum; pname: DummyEnum; var ¶ms: single);
begin
z_GetPixelTransformParameterfvEXT_ovr_0(target, pname, ¶ms);
end;
public z_GetPixelTransformParameterfvEXT_ovr_2 := GetFuncOrNil&<procedure(target: DummyEnum; pname: DummyEnum; ¶ms: IntPtr)>(z_GetPixelTransformParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelTransformParameterfvEXT(target: DummyEnum; pname: DummyEnum; ¶ms: IntPtr);
begin
z_GetPixelTransformParameterfvEXT_ovr_2(target, pname, ¶ms);
end;
end;
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);
public z_PointParameterfEXT_adr := GetFuncAdr('glPointParameterfEXT');
public z_PointParameterfEXT_ovr_0 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; param: single)>(z_PointParameterfEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfEXT(pname: PointParameterNameARB; param: single);
begin
z_PointParameterfEXT_ovr_0(pname, param);
end;
public z_PointParameterfvEXT_adr := GetFuncAdr('glPointParameterfvEXT');
public z_PointParameterfvEXT_ovr_0 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; var ¶ms: single)>(z_PointParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfvEXT(pname: PointParameterNameARB; ¶ms: array of single);
begin
z_PointParameterfvEXT_ovr_0(pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfvEXT(pname: PointParameterNameARB; var ¶ms: single);
begin
z_PointParameterfvEXT_ovr_0(pname, ¶ms);
end;
public z_PointParameterfvEXT_ovr_2 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; ¶ms: IntPtr)>(z_PointParameterfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfvEXT(pname: PointParameterNameARB; ¶ms: IntPtr);
begin
z_PointParameterfvEXT_ovr_2(pname, ¶ms);
end;
end;
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);
public z_PolygonOffsetEXT_adr := GetFuncAdr('glPolygonOffsetEXT');
public z_PolygonOffsetEXT_ovr_0 := GetFuncOrNil&<procedure(factor: single; bias: single)>(z_PolygonOffsetEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PolygonOffsetEXT(factor: single; bias: single);
begin
z_PolygonOffsetEXT_ovr_0(factor, bias);
end;
end;
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);
public z_PolygonOffsetClampEXT_adr := GetFuncAdr('glPolygonOffsetClampEXT');
public z_PolygonOffsetClampEXT_ovr_0 := GetFuncOrNil&<procedure(factor: single; units: single; clamp: single)>(z_PolygonOffsetClampEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PolygonOffsetClampEXT(factor: single; units: single; clamp: single);
begin
z_PolygonOffsetClampEXT_ovr_0(factor, units, clamp);
end;
end;
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);
public z_ProvokingVertexEXT_adr := GetFuncAdr('glProvokingVertexEXT');
public z_ProvokingVertexEXT_ovr_0 := GetFuncOrNil&<procedure(mode: VertexProvokingMode)>(z_ProvokingVertexEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProvokingVertexEXT(mode: VertexProvokingMode);
begin
z_ProvokingVertexEXT_ovr_0(mode);
end;
end;
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);
public z_RasterSamplesEXT_adr := GetFuncAdr('glRasterSamplesEXT');
public z_RasterSamplesEXT_ovr_0 := GetFuncOrNil&<procedure(samples: UInt32; fixedsamplelocations: boolean)>(z_RasterSamplesEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterSamplesEXT(samples: UInt32; fixedsamplelocations: boolean);
begin
z_RasterSamplesEXT_ovr_0(samples, fixedsamplelocations);
end;
end;
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);
public z_GetUnsignedBytevEXT_adr := GetFuncAdr('glGetUnsignedBytevEXT');
public z_GetUnsignedBytevEXT_ovr_0 := GetFuncOrNil&<procedure(pname: GetPName; var data: Byte)>(z_GetUnsignedBytevEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUnsignedBytevEXT(pname: GetPName; data: array of Byte);
begin
z_GetUnsignedBytevEXT_ovr_0(pname, data[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUnsignedBytevEXT(pname: GetPName; var data: Byte);
begin
z_GetUnsignedBytevEXT_ovr_0(pname, data);
end;
public z_GetUnsignedBytevEXT_ovr_2 := GetFuncOrNil&<procedure(pname: GetPName; data: IntPtr)>(z_GetUnsignedBytevEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUnsignedBytevEXT(pname: GetPName; data: IntPtr);
begin
z_GetUnsignedBytevEXT_ovr_2(pname, data);
end;
public z_GetUnsignedBytei_vEXT_adr := GetFuncAdr('glGetUnsignedBytei_vEXT');
public z_GetUnsignedBytei_vEXT_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; var data: Byte)>(z_GetUnsignedBytei_vEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUnsignedBytei_vEXT(target: DummyEnum; index: UInt32; data: array of Byte);
begin
z_GetUnsignedBytei_vEXT_ovr_0(target, index, data[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUnsignedBytei_vEXT(target: DummyEnum; index: UInt32; var data: Byte);
begin
z_GetUnsignedBytei_vEXT_ovr_0(target, index, data);
end;
public z_GetUnsignedBytei_vEXT_ovr_2 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; data: IntPtr)>(z_GetUnsignedBytei_vEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUnsignedBytei_vEXT(target: DummyEnum; index: UInt32; data: IntPtr);
begin
z_GetUnsignedBytei_vEXT_ovr_2(target, index, data);
end;
public z_GenSemaphoresEXT_adr := GetFuncAdr('glGenSemaphoresEXT');
public z_GenSemaphoresEXT_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var semaphores: UInt32)>(z_GenSemaphoresEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenSemaphoresEXT(n: Int32; semaphores: array of UInt32);
begin
z_GenSemaphoresEXT_ovr_0(n, semaphores[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenSemaphoresEXT(n: Int32; var semaphores: UInt32);
begin
z_GenSemaphoresEXT_ovr_0(n, semaphores);
end;
public z_GenSemaphoresEXT_ovr_2 := GetFuncOrNil&<procedure(n: Int32; semaphores: IntPtr)>(z_GenSemaphoresEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenSemaphoresEXT(n: Int32; semaphores: IntPtr);
begin
z_GenSemaphoresEXT_ovr_2(n, semaphores);
end;
public z_DeleteSemaphoresEXT_adr := GetFuncAdr('glDeleteSemaphoresEXT');
public z_DeleteSemaphoresEXT_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var semaphores: UInt32)>(z_DeleteSemaphoresEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteSemaphoresEXT(n: Int32; semaphores: array of UInt32);
begin
z_DeleteSemaphoresEXT_ovr_0(n, semaphores[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteSemaphoresEXT(n: Int32; var semaphores: UInt32);
begin
z_DeleteSemaphoresEXT_ovr_0(n, semaphores);
end;
public z_DeleteSemaphoresEXT_ovr_2 := GetFuncOrNil&<procedure(n: Int32; semaphores: IntPtr)>(z_DeleteSemaphoresEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteSemaphoresEXT(n: Int32; semaphores: IntPtr);
begin
z_DeleteSemaphoresEXT_ovr_2(n, semaphores);
end;
public z_IsSemaphoreEXT_adr := GetFuncAdr('glIsSemaphoreEXT');
public z_IsSemaphoreEXT_ovr_0 := GetFuncOrNil&<function(semaphore: UInt32): boolean>(z_IsSemaphoreEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsSemaphoreEXT(semaphore: UInt32): boolean;
begin
Result := z_IsSemaphoreEXT_ovr_0(semaphore);
end;
public z_SemaphoreParameterui64vEXT_adr := GetFuncAdr('glSemaphoreParameterui64vEXT');
public z_SemaphoreParameterui64vEXT_ovr_0 := GetFuncOrNil&<procedure(semaphore: UInt32; pname: SemaphoreParameterName; var ¶ms: UInt64)>(z_SemaphoreParameterui64vEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SemaphoreParameterui64vEXT(semaphore: UInt32; pname: SemaphoreParameterName; ¶ms: array of UInt64);
begin
z_SemaphoreParameterui64vEXT_ovr_0(semaphore, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SemaphoreParameterui64vEXT(semaphore: UInt32; pname: SemaphoreParameterName; var ¶ms: UInt64);
begin
z_SemaphoreParameterui64vEXT_ovr_0(semaphore, pname, ¶ms);
end;
public z_SemaphoreParameterui64vEXT_ovr_2 := GetFuncOrNil&<procedure(semaphore: UInt32; pname: SemaphoreParameterName; ¶ms: IntPtr)>(z_SemaphoreParameterui64vEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SemaphoreParameterui64vEXT(semaphore: UInt32; pname: SemaphoreParameterName; ¶ms: IntPtr);
begin
z_SemaphoreParameterui64vEXT_ovr_2(semaphore, pname, ¶ms);
end;
public z_GetSemaphoreParameterui64vEXT_adr := GetFuncAdr('glGetSemaphoreParameterui64vEXT');
public z_GetSemaphoreParameterui64vEXT_ovr_0 := GetFuncOrNil&<procedure(semaphore: UInt32; pname: SemaphoreParameterName; var ¶ms: UInt64)>(z_GetSemaphoreParameterui64vEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSemaphoreParameterui64vEXT(semaphore: UInt32; pname: SemaphoreParameterName; ¶ms: array of UInt64);
begin
z_GetSemaphoreParameterui64vEXT_ovr_0(semaphore, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSemaphoreParameterui64vEXT(semaphore: UInt32; pname: SemaphoreParameterName; var ¶ms: UInt64);
begin
z_GetSemaphoreParameterui64vEXT_ovr_0(semaphore, pname, ¶ms);
end;
public z_GetSemaphoreParameterui64vEXT_ovr_2 := GetFuncOrNil&<procedure(semaphore: UInt32; pname: SemaphoreParameterName; ¶ms: IntPtr)>(z_GetSemaphoreParameterui64vEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSemaphoreParameterui64vEXT(semaphore: UInt32; pname: SemaphoreParameterName; ¶ms: IntPtr);
begin
z_GetSemaphoreParameterui64vEXT_ovr_2(semaphore, pname, ¶ms);
end;
public z_WaitSemaphoreEXT_adr := GetFuncAdr('glWaitSemaphoreEXT');
public z_WaitSemaphoreEXT_ovr_0 := GetFuncOrNil&<procedure(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; var textures: UInt32; var srcLayouts: TextureLayout)>(z_WaitSemaphoreEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; textures: array of UInt32; srcLayouts: array of TextureLayout);
begin
z_WaitSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures[0], srcLayouts[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; textures: array of UInt32; var srcLayouts: TextureLayout);
begin
z_WaitSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures[0], srcLayouts);
end;
public z_WaitSemaphoreEXT_ovr_2 := GetFuncOrNil&<procedure(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; var textures: UInt32; srcLayouts: IntPtr)>(z_WaitSemaphoreEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; textures: array of UInt32; srcLayouts: IntPtr);
begin
z_WaitSemaphoreEXT_ovr_2(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures[0], srcLayouts);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; var textures: UInt32; srcLayouts: array of TextureLayout);
begin
z_WaitSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, srcLayouts[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; var textures: UInt32; var srcLayouts: TextureLayout);
begin
z_WaitSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, srcLayouts);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; var textures: UInt32; srcLayouts: IntPtr);
begin
z_WaitSemaphoreEXT_ovr_2(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, srcLayouts);
end;
public z_WaitSemaphoreEXT_ovr_6 := GetFuncOrNil&<procedure(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; var srcLayouts: TextureLayout)>(z_WaitSemaphoreEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; textures: IntPtr; srcLayouts: array of TextureLayout);
begin
z_WaitSemaphoreEXT_ovr_6(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, srcLayouts[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; textures: IntPtr; var srcLayouts: TextureLayout);
begin
z_WaitSemaphoreEXT_ovr_6(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, srcLayouts);
end;
public z_WaitSemaphoreEXT_ovr_8 := GetFuncOrNil&<procedure(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; srcLayouts: IntPtr)>(z_WaitSemaphoreEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; textures: IntPtr; srcLayouts: IntPtr);
begin
z_WaitSemaphoreEXT_ovr_8(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, srcLayouts);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: array of UInt32; srcLayouts: array of TextureLayout);
begin
z_WaitSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], srcLayouts[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: array of UInt32; var srcLayouts: TextureLayout);
begin
z_WaitSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], srcLayouts);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: array of UInt32; srcLayouts: IntPtr);
begin
z_WaitSemaphoreEXT_ovr_2(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], srcLayouts);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; var textures: UInt32; srcLayouts: array of TextureLayout);
begin
z_WaitSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; var textures: UInt32; var srcLayouts: TextureLayout);
begin
z_WaitSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; var textures: UInt32; srcLayouts: IntPtr);
begin
z_WaitSemaphoreEXT_ovr_2(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; srcLayouts: array of TextureLayout);
begin
z_WaitSemaphoreEXT_ovr_6(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; var srcLayouts: TextureLayout);
begin
z_WaitSemaphoreEXT_ovr_6(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; srcLayouts: IntPtr);
begin
z_WaitSemaphoreEXT_ovr_8(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts);
end;
public z_WaitSemaphoreEXT_ovr_18 := GetFuncOrNil&<procedure(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; var srcLayouts: TextureLayout)>(z_WaitSemaphoreEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: array of UInt32; srcLayouts: array of TextureLayout);
begin
z_WaitSemaphoreEXT_ovr_18(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], srcLayouts[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: array of UInt32; var srcLayouts: TextureLayout);
begin
z_WaitSemaphoreEXT_ovr_18(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], srcLayouts);
end;
public z_WaitSemaphoreEXT_ovr_20 := GetFuncOrNil&<procedure(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; srcLayouts: IntPtr)>(z_WaitSemaphoreEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: array of UInt32; srcLayouts: IntPtr);
begin
z_WaitSemaphoreEXT_ovr_20(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], srcLayouts);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; srcLayouts: array of TextureLayout);
begin
z_WaitSemaphoreEXT_ovr_18(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; var srcLayouts: TextureLayout);
begin
z_WaitSemaphoreEXT_ovr_18(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; srcLayouts: IntPtr);
begin
z_WaitSemaphoreEXT_ovr_20(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts);
end;
public z_WaitSemaphoreEXT_ovr_24 := GetFuncOrNil&<procedure(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; var srcLayouts: TextureLayout)>(z_WaitSemaphoreEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; srcLayouts: array of TextureLayout);
begin
z_WaitSemaphoreEXT_ovr_24(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; var srcLayouts: TextureLayout);
begin
z_WaitSemaphoreEXT_ovr_24(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts);
end;
public z_WaitSemaphoreEXT_ovr_26 := GetFuncOrNil&<procedure(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; srcLayouts: IntPtr)>(z_WaitSemaphoreEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; srcLayouts: IntPtr);
begin
z_WaitSemaphoreEXT_ovr_26(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts);
end;
public z_SignalSemaphoreEXT_adr := GetFuncAdr('glSignalSemaphoreEXT');
public z_SignalSemaphoreEXT_ovr_0 := GetFuncOrNil&<procedure(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; var textures: UInt32; var dstLayouts: TextureLayout)>(z_SignalSemaphoreEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; textures: array of UInt32; dstLayouts: array of TextureLayout);
begin
z_SignalSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures[0], dstLayouts[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; textures: array of UInt32; var dstLayouts: TextureLayout);
begin
z_SignalSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures[0], dstLayouts);
end;
public z_SignalSemaphoreEXT_ovr_2 := GetFuncOrNil&<procedure(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; var textures: UInt32; dstLayouts: IntPtr)>(z_SignalSemaphoreEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; textures: array of UInt32; dstLayouts: IntPtr);
begin
z_SignalSemaphoreEXT_ovr_2(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures[0], dstLayouts);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; var textures: UInt32; dstLayouts: array of TextureLayout);
begin
z_SignalSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, dstLayouts[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; var textures: UInt32; var dstLayouts: TextureLayout);
begin
z_SignalSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, dstLayouts);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; var textures: UInt32; dstLayouts: IntPtr);
begin
z_SignalSemaphoreEXT_ovr_2(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, dstLayouts);
end;
public z_SignalSemaphoreEXT_ovr_6 := GetFuncOrNil&<procedure(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; var dstLayouts: TextureLayout)>(z_SignalSemaphoreEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; textures: IntPtr; dstLayouts: array of TextureLayout);
begin
z_SignalSemaphoreEXT_ovr_6(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, dstLayouts[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; textures: IntPtr; var dstLayouts: TextureLayout);
begin
z_SignalSemaphoreEXT_ovr_6(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, dstLayouts);
end;
public z_SignalSemaphoreEXT_ovr_8 := GetFuncOrNil&<procedure(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; dstLayouts: IntPtr)>(z_SignalSemaphoreEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: array of UInt32; numTextureBarriers: UInt32; textures: IntPtr; dstLayouts: IntPtr);
begin
z_SignalSemaphoreEXT_ovr_8(semaphore, numBufferBarriers, buffers[0], numTextureBarriers, textures, dstLayouts);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: array of UInt32; dstLayouts: array of TextureLayout);
begin
z_SignalSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], dstLayouts[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: array of UInt32; var dstLayouts: TextureLayout);
begin
z_SignalSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], dstLayouts);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: array of UInt32; dstLayouts: IntPtr);
begin
z_SignalSemaphoreEXT_ovr_2(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], dstLayouts);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; var textures: UInt32; dstLayouts: array of TextureLayout);
begin
z_SignalSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; var textures: UInt32; var dstLayouts: TextureLayout);
begin
z_SignalSemaphoreEXT_ovr_0(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; var textures: UInt32; dstLayouts: IntPtr);
begin
z_SignalSemaphoreEXT_ovr_2(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; dstLayouts: array of TextureLayout);
begin
z_SignalSemaphoreEXT_ovr_6(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; var dstLayouts: TextureLayout);
begin
z_SignalSemaphoreEXT_ovr_6(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; var buffers: UInt32; numTextureBarriers: UInt32; textures: IntPtr; dstLayouts: IntPtr);
begin
z_SignalSemaphoreEXT_ovr_8(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts);
end;
public z_SignalSemaphoreEXT_ovr_18 := GetFuncOrNil&<procedure(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; var dstLayouts: TextureLayout)>(z_SignalSemaphoreEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: array of UInt32; dstLayouts: array of TextureLayout);
begin
z_SignalSemaphoreEXT_ovr_18(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], dstLayouts[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: array of UInt32; var dstLayouts: TextureLayout);
begin
z_SignalSemaphoreEXT_ovr_18(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], dstLayouts);
end;
public z_SignalSemaphoreEXT_ovr_20 := GetFuncOrNil&<procedure(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; dstLayouts: IntPtr)>(z_SignalSemaphoreEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: array of UInt32; dstLayouts: IntPtr);
begin
z_SignalSemaphoreEXT_ovr_20(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures[0], dstLayouts);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; dstLayouts: array of TextureLayout);
begin
z_SignalSemaphoreEXT_ovr_18(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; var dstLayouts: TextureLayout);
begin
z_SignalSemaphoreEXT_ovr_18(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; var textures: UInt32; dstLayouts: IntPtr);
begin
z_SignalSemaphoreEXT_ovr_20(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts);
end;
public z_SignalSemaphoreEXT_ovr_24 := GetFuncOrNil&<procedure(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; var dstLayouts: TextureLayout)>(z_SignalSemaphoreEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; dstLayouts: array of TextureLayout);
begin
z_SignalSemaphoreEXT_ovr_24(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; var dstLayouts: TextureLayout);
begin
z_SignalSemaphoreEXT_ovr_24(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts);
end;
public z_SignalSemaphoreEXT_ovr_26 := GetFuncOrNil&<procedure(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; dstLayouts: IntPtr)>(z_SignalSemaphoreEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreEXT(semaphore: UInt32; numBufferBarriers: UInt32; buffers: IntPtr; numTextureBarriers: UInt32; textures: IntPtr; dstLayouts: IntPtr);
begin
z_SignalSemaphoreEXT_ovr_26(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts);
end;
end;
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);
public z_ImportSemaphoreFdEXT_adr := GetFuncAdr('glImportSemaphoreFdEXT');
public z_ImportSemaphoreFdEXT_ovr_0 := GetFuncOrNil&<procedure(semaphore: UInt32; handleType: ExternalHandleType; fd: Int32)>(z_ImportSemaphoreFdEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImportSemaphoreFdEXT(semaphore: UInt32; handleType: ExternalHandleType; fd: Int32);
begin
z_ImportSemaphoreFdEXT_ovr_0(semaphore, handleType, fd);
end;
end;
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);
public z_ImportSemaphoreWin32HandleEXT_adr := GetFuncAdr('glImportSemaphoreWin32HandleEXT');
public z_ImportSemaphoreWin32HandleEXT_ovr_0 := GetFuncOrNil&<procedure(semaphore: UInt32; handleType: ExternalHandleType; handle: IntPtr)>(z_ImportSemaphoreWin32HandleEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImportSemaphoreWin32HandleEXT(semaphore: UInt32; handleType: ExternalHandleType; handle: IntPtr);
begin
z_ImportSemaphoreWin32HandleEXT_ovr_0(semaphore, handleType, handle);
end;
public z_ImportSemaphoreWin32NameEXT_adr := GetFuncAdr('glImportSemaphoreWin32NameEXT');
public z_ImportSemaphoreWin32NameEXT_ovr_0 := GetFuncOrNil&<procedure(semaphore: UInt32; handleType: ExternalHandleType; name: IntPtr)>(z_ImportSemaphoreWin32NameEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImportSemaphoreWin32NameEXT(semaphore: UInt32; handleType: ExternalHandleType; name: IntPtr);
begin
z_ImportSemaphoreWin32NameEXT_ovr_0(semaphore, handleType, name);
end;
end;
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);
public z_SecondaryColor3bEXT_adr := GetFuncAdr('glSecondaryColor3bEXT');
public z_SecondaryColor3bEXT_ovr_0 := GetFuncOrNil&<procedure(red: SByte; green: SByte; blue: SByte)>(z_SecondaryColor3bEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3bEXT(red: SByte; green: SByte; blue: SByte);
begin
z_SecondaryColor3bEXT_ovr_0(red, green, blue);
end;
public z_SecondaryColor3bvEXT_adr := GetFuncAdr('glSecondaryColor3bvEXT');
public z_SecondaryColor3bvEXT_ovr_0 := GetFuncOrNil&<procedure(var v: SByte)>(z_SecondaryColor3bvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3bvEXT(v: array of SByte);
begin
z_SecondaryColor3bvEXT_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3bvEXT(var v: SByte);
begin
z_SecondaryColor3bvEXT_ovr_0(v);
end;
public z_SecondaryColor3bvEXT_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3bvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3bvEXT(v: IntPtr);
begin
z_SecondaryColor3bvEXT_ovr_2(v);
end;
public z_SecondaryColor3dEXT_adr := GetFuncAdr('glSecondaryColor3dEXT');
public z_SecondaryColor3dEXT_ovr_0 := GetFuncOrNil&<procedure(red: real; green: real; blue: real)>(z_SecondaryColor3dEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3dEXT(red: real; green: real; blue: real);
begin
z_SecondaryColor3dEXT_ovr_0(red, green, blue);
end;
public z_SecondaryColor3dvEXT_adr := GetFuncAdr('glSecondaryColor3dvEXT');
public z_SecondaryColor3dvEXT_ovr_0 := GetFuncOrNil&<procedure(var v: real)>(z_SecondaryColor3dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3dvEXT(v: array of real);
begin
z_SecondaryColor3dvEXT_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3dvEXT(var v: real);
begin
z_SecondaryColor3dvEXT_ovr_0(v);
end;
public z_SecondaryColor3dvEXT_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3dvEXT(v: IntPtr);
begin
z_SecondaryColor3dvEXT_ovr_2(v);
end;
public z_SecondaryColor3fEXT_adr := GetFuncAdr('glSecondaryColor3fEXT');
public z_SecondaryColor3fEXT_ovr_0 := GetFuncOrNil&<procedure(red: single; green: single; blue: single)>(z_SecondaryColor3fEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3fEXT(red: single; green: single; blue: single);
begin
z_SecondaryColor3fEXT_ovr_0(red, green, blue);
end;
public z_SecondaryColor3fvEXT_adr := GetFuncAdr('glSecondaryColor3fvEXT');
public z_SecondaryColor3fvEXT_ovr_0 := GetFuncOrNil&<procedure(var v: single)>(z_SecondaryColor3fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3fvEXT(v: array of single);
begin
z_SecondaryColor3fvEXT_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3fvEXT(var v: single);
begin
z_SecondaryColor3fvEXT_ovr_0(v);
end;
public z_SecondaryColor3fvEXT_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3fvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3fvEXT(v: IntPtr);
begin
z_SecondaryColor3fvEXT_ovr_2(v);
end;
public z_SecondaryColor3iEXT_adr := GetFuncAdr('glSecondaryColor3iEXT');
public z_SecondaryColor3iEXT_ovr_0 := GetFuncOrNil&<procedure(red: Int32; green: Int32; blue: Int32)>(z_SecondaryColor3iEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3iEXT(red: Int32; green: Int32; blue: Int32);
begin
z_SecondaryColor3iEXT_ovr_0(red, green, blue);
end;
public z_SecondaryColor3ivEXT_adr := GetFuncAdr('glSecondaryColor3ivEXT');
public z_SecondaryColor3ivEXT_ovr_0 := GetFuncOrNil&<procedure(var v: Int32)>(z_SecondaryColor3ivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3ivEXT(v: array of Int32);
begin
z_SecondaryColor3ivEXT_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3ivEXT(var v: Int32);
begin
z_SecondaryColor3ivEXT_ovr_0(v);
end;
public z_SecondaryColor3ivEXT_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3ivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3ivEXT(v: IntPtr);
begin
z_SecondaryColor3ivEXT_ovr_2(v);
end;
public z_SecondaryColor3sEXT_adr := GetFuncAdr('glSecondaryColor3sEXT');
public z_SecondaryColor3sEXT_ovr_0 := GetFuncOrNil&<procedure(red: Int16; green: Int16; blue: Int16)>(z_SecondaryColor3sEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3sEXT(red: Int16; green: Int16; blue: Int16);
begin
z_SecondaryColor3sEXT_ovr_0(red, green, blue);
end;
public z_SecondaryColor3svEXT_adr := GetFuncAdr('glSecondaryColor3svEXT');
public z_SecondaryColor3svEXT_ovr_0 := GetFuncOrNil&<procedure(var v: Int16)>(z_SecondaryColor3svEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3svEXT(v: array of Int16);
begin
z_SecondaryColor3svEXT_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3svEXT(var v: Int16);
begin
z_SecondaryColor3svEXT_ovr_0(v);
end;
public z_SecondaryColor3svEXT_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3svEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3svEXT(v: IntPtr);
begin
z_SecondaryColor3svEXT_ovr_2(v);
end;
public z_SecondaryColor3ubEXT_adr := GetFuncAdr('glSecondaryColor3ubEXT');
public z_SecondaryColor3ubEXT_ovr_0 := GetFuncOrNil&<procedure(red: Byte; green: Byte; blue: Byte)>(z_SecondaryColor3ubEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3ubEXT(red: Byte; green: Byte; blue: Byte);
begin
z_SecondaryColor3ubEXT_ovr_0(red, green, blue);
end;
public z_SecondaryColor3ubvEXT_adr := GetFuncAdr('glSecondaryColor3ubvEXT');
public z_SecondaryColor3ubvEXT_ovr_0 := GetFuncOrNil&<procedure(var v: Byte)>(z_SecondaryColor3ubvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3ubvEXT(v: array of Byte);
begin
z_SecondaryColor3ubvEXT_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3ubvEXT(var v: Byte);
begin
z_SecondaryColor3ubvEXT_ovr_0(v);
end;
public z_SecondaryColor3ubvEXT_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3ubvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3ubvEXT(v: IntPtr);
begin
z_SecondaryColor3ubvEXT_ovr_2(v);
end;
public z_SecondaryColor3uiEXT_adr := GetFuncAdr('glSecondaryColor3uiEXT');
public z_SecondaryColor3uiEXT_ovr_0 := GetFuncOrNil&<procedure(red: UInt32; green: UInt32; blue: UInt32)>(z_SecondaryColor3uiEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3uiEXT(red: UInt32; green: UInt32; blue: UInt32);
begin
z_SecondaryColor3uiEXT_ovr_0(red, green, blue);
end;
public z_SecondaryColor3uivEXT_adr := GetFuncAdr('glSecondaryColor3uivEXT');
public z_SecondaryColor3uivEXT_ovr_0 := GetFuncOrNil&<procedure(var v: UInt32)>(z_SecondaryColor3uivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3uivEXT(v: array of UInt32);
begin
z_SecondaryColor3uivEXT_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3uivEXT(var v: UInt32);
begin
z_SecondaryColor3uivEXT_ovr_0(v);
end;
public z_SecondaryColor3uivEXT_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3uivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3uivEXT(v: IntPtr);
begin
z_SecondaryColor3uivEXT_ovr_2(v);
end;
public z_SecondaryColor3usEXT_adr := GetFuncAdr('glSecondaryColor3usEXT');
public z_SecondaryColor3usEXT_ovr_0 := GetFuncOrNil&<procedure(red: UInt16; green: UInt16; blue: UInt16)>(z_SecondaryColor3usEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3usEXT(red: UInt16; green: UInt16; blue: UInt16);
begin
z_SecondaryColor3usEXT_ovr_0(red, green, blue);
end;
public z_SecondaryColor3usvEXT_adr := GetFuncAdr('glSecondaryColor3usvEXT');
public z_SecondaryColor3usvEXT_ovr_0 := GetFuncOrNil&<procedure(var v: UInt16)>(z_SecondaryColor3usvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3usvEXT(v: array of UInt16);
begin
z_SecondaryColor3usvEXT_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3usvEXT(var v: UInt16);
begin
z_SecondaryColor3usvEXT_ovr_0(v);
end;
public z_SecondaryColor3usvEXT_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3usvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3usvEXT(v: IntPtr);
begin
z_SecondaryColor3usvEXT_ovr_2(v);
end;
public z_SecondaryColorPointerEXT_adr := GetFuncAdr('glSecondaryColorPointerEXT');
public z_SecondaryColorPointerEXT_ovr_0 := GetFuncOrNil&<procedure(size: Int32; &type: ColorPointerType; stride: Int32; pointer: IntPtr)>(z_SecondaryColorPointerEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColorPointerEXT(size: Int32; &type: ColorPointerType; stride: Int32; pointer: IntPtr);
begin
z_SecondaryColorPointerEXT_ovr_0(size, &type, stride, pointer);
end;
end;
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);
public z_UseShaderProgramEXT_adr := GetFuncAdr('glUseShaderProgramEXT');
public z_UseShaderProgramEXT_ovr_0 := GetFuncOrNil&<procedure(&type: DummyEnum; &program: UInt32)>(z_UseShaderProgramEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UseShaderProgramEXT(&type: DummyEnum; &program: UInt32);
begin
z_UseShaderProgramEXT_ovr_0(&type, &program);
end;
public z_ActiveProgramEXT_adr := GetFuncAdr('glActiveProgramEXT');
public z_ActiveProgramEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32)>(z_ActiveProgramEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ActiveProgramEXT(&program: UInt32);
begin
z_ActiveProgramEXT_ovr_0(&program);
end;
public z_CreateShaderProgramEXT_adr := GetFuncAdr('glCreateShaderProgramEXT');
public z_CreateShaderProgramEXT_ovr_0 := GetFuncOrNil&<function(&type: ShaderType; _string: IntPtr): UInt32>(z_CreateShaderProgramEXT_adr);
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;
begin
Result := z_CreateShaderProgramEXT_ovr_0(&type, _string);
end;
end;
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);
public z_FramebufferFetchBarrierEXT_adr := GetFuncAdr('glFramebufferFetchBarrierEXT');
public z_FramebufferFetchBarrierEXT_ovr_0 := GetFuncOrNil&<procedure>(z_FramebufferFetchBarrierEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferFetchBarrierEXT;
begin
z_FramebufferFetchBarrierEXT_ovr_0;
end;
end;
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);
public z_BindImageTextureEXT_adr := GetFuncAdr('glBindImageTextureEXT');
public z_BindImageTextureEXT_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; texture: UInt32; level: Int32; layered: boolean; layer: Int32; access: BufferAccessARB; format: Int32)>(z_BindImageTextureEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindImageTextureEXT(index: UInt32; texture: UInt32; level: Int32; layered: boolean; layer: Int32; access: BufferAccessARB; format: Int32);
begin
z_BindImageTextureEXT_ovr_0(index, texture, level, layered, layer, access, format);
end;
public z_MemoryBarrierEXT_adr := GetFuncAdr('glMemoryBarrierEXT');
public z_MemoryBarrierEXT_ovr_0 := GetFuncOrNil&<procedure(barriers: MemoryBarrierMask)>(z_MemoryBarrierEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MemoryBarrierEXT(barriers: MemoryBarrierMask);
begin
z_MemoryBarrierEXT_ovr_0(barriers);
end;
end;
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);
public z_StencilClearTagEXT_adr := GetFuncAdr('glStencilClearTagEXT');
public z_StencilClearTagEXT_ovr_0 := GetFuncOrNil&<procedure(stencilTagBits: Int32; stencilClearTag: UInt32)>(z_StencilClearTagEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilClearTagEXT(stencilTagBits: Int32; stencilClearTag: UInt32);
begin
z_StencilClearTagEXT_ovr_0(stencilTagBits, stencilClearTag);
end;
end;
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);
public z_ActiveStencilFaceEXT_adr := GetFuncAdr('glActiveStencilFaceEXT');
public z_ActiveStencilFaceEXT_ovr_0 := GetFuncOrNil&<procedure(face: StencilFaceDirection)>(z_ActiveStencilFaceEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ActiveStencilFaceEXT(face: StencilFaceDirection);
begin
z_ActiveStencilFaceEXT_ovr_0(face);
end;
end;
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);
public z_TexSubImage1DEXT_adr := GetFuncAdr('glTexSubImage1DEXT');
public z_TexSubImage1DEXT_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr)>(z_TexSubImage1DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexSubImage1DEXT(target: TextureTarget; level: Int32; xoffset: Int32; width: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
begin
z_TexSubImage1DEXT_ovr_0(target, level, xoffset, width, format, &type, pixels);
end;
public z_TexSubImage2DEXT_adr := GetFuncAdr('glTexSubImage2DEXT');
public z_TexSubImage2DEXT_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr)>(z_TexSubImage2DEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexSubImage2DEXT(target: TextureTarget; level: Int32; xoffset: Int32; yoffset: Int32; width: Int32; height: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr);
begin
z_TexSubImage2DEXT_ovr_0(target, level, xoffset, yoffset, width, height, format, &type, pixels);
end;
end;
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);
public z_TexImage3DEXT_adr := GetFuncAdr('glTexImage3DEXT');
public z_TexImage3DEXT_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr)>(z_TexImage3DEXT_adr);
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);
begin
z_TexImage3DEXT_ovr_0(target, level, _internalformat, width, height, depth, border, format, &type, pixels);
end;
public z_TexSubImage3DEXT_adr := GetFuncAdr('glTexSubImage3DEXT');
public z_TexSubImage3DEXT_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_TexSubImage3DEXT_adr);
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);
begin
z_TexSubImage3DEXT_ovr_0(target, level, xoffset, yoffset, zoffset, width, height, depth, format, &type, pixels);
end;
end;
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);
public z_FramebufferTextureLayerEXT_adr := GetFuncAdr('glFramebufferTextureLayerEXT');
public z_FramebufferTextureLayerEXT_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; attachment: FramebufferAttachment; texture: UInt32; level: Int32; layer: Int32)>(z_FramebufferTextureLayerEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTextureLayerEXT(target: FramebufferTarget; attachment: FramebufferAttachment; texture: UInt32; level: Int32; layer: Int32);
begin
z_FramebufferTextureLayerEXT_ovr_0(target, attachment, texture, level, layer);
end;
end;
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);
public z_TexBufferEXT_adr := GetFuncAdr('glTexBufferEXT');
public z_TexBufferEXT_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; _internalformat: InternalFormat; buffer: UInt32)>(z_TexBufferEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexBufferEXT(target: TextureTarget; _internalformat: InternalFormat; buffer: UInt32);
begin
z_TexBufferEXT_ovr_0(target, _internalformat, buffer);
end;
end;
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);
public z_TexParameterIivEXT_adr := GetFuncAdr('glTexParameterIivEXT');
public z_TexParameterIivEXT_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32)>(z_TexParameterIivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterIivEXT(target: TextureTarget; pname: TextureParameterName; ¶ms: array of Int32);
begin
z_TexParameterIivEXT_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterIivEXT(target: TextureTarget; pname: TextureParameterName; var ¶ms: Int32);
begin
z_TexParameterIivEXT_ovr_0(target, pname, ¶ms);
end;
public z_TexParameterIivEXT_ovr_2 := GetFuncOrNil&<procedure(target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr)>(z_TexParameterIivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterIivEXT(target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
begin
z_TexParameterIivEXT_ovr_2(target, pname, ¶ms);
end;
public z_TexParameterIuivEXT_adr := GetFuncAdr('glTexParameterIuivEXT');
public z_TexParameterIuivEXT_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; pname: TextureParameterName; var ¶ms: UInt32)>(z_TexParameterIuivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterIuivEXT(target: TextureTarget; pname: TextureParameterName; ¶ms: array of UInt32);
begin
z_TexParameterIuivEXT_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterIuivEXT(target: TextureTarget; pname: TextureParameterName; var ¶ms: UInt32);
begin
z_TexParameterIuivEXT_ovr_0(target, pname, ¶ms);
end;
public z_TexParameterIuivEXT_ovr_2 := GetFuncOrNil&<procedure(target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr)>(z_TexParameterIuivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterIuivEXT(target: TextureTarget; pname: TextureParameterName; ¶ms: IntPtr);
begin
z_TexParameterIuivEXT_ovr_2(target, pname, ¶ms);
end;
public z_GetTexParameterIivEXT_adr := GetFuncAdr('glGetTexParameterIivEXT');
public z_GetTexParameterIivEXT_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32)>(z_GetTexParameterIivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterIivEXT(target: TextureTarget; pname: GetTextureParameter; ¶ms: array of Int32);
begin
z_GetTexParameterIivEXT_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterIivEXT(target: TextureTarget; pname: GetTextureParameter; var ¶ms: Int32);
begin
z_GetTexParameterIivEXT_ovr_0(target, pname, ¶ms);
end;
public z_GetTexParameterIivEXT_ovr_2 := GetFuncOrNil&<procedure(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetTexParameterIivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterIivEXT(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
begin
z_GetTexParameterIivEXT_ovr_2(target, pname, ¶ms);
end;
public z_GetTexParameterIuivEXT_adr := GetFuncAdr('glGetTexParameterIuivEXT');
public z_GetTexParameterIuivEXT_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; pname: GetTextureParameter; var ¶ms: UInt32)>(z_GetTexParameterIuivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterIuivEXT(target: TextureTarget; pname: GetTextureParameter; ¶ms: array of UInt32);
begin
z_GetTexParameterIuivEXT_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterIuivEXT(target: TextureTarget; pname: GetTextureParameter; var ¶ms: UInt32);
begin
z_GetTexParameterIuivEXT_ovr_0(target, pname, ¶ms);
end;
public z_GetTexParameterIuivEXT_ovr_2 := GetFuncOrNil&<procedure(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetTexParameterIuivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterIuivEXT(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
begin
z_GetTexParameterIuivEXT_ovr_2(target, pname, ¶ms);
end;
public z_ClearColorIiEXT_adr := GetFuncAdr('glClearColorIiEXT');
public z_ClearColorIiEXT_ovr_0 := GetFuncOrNil&<procedure(red: Int32; green: Int32; blue: Int32; alpha: Int32)>(z_ClearColorIiEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearColorIiEXT(red: Int32; green: Int32; blue: Int32; alpha: Int32);
begin
z_ClearColorIiEXT_ovr_0(red, green, blue, alpha);
end;
public z_ClearColorIuiEXT_adr := GetFuncAdr('glClearColorIuiEXT');
public z_ClearColorIuiEXT_ovr_0 := GetFuncOrNil&<procedure(red: UInt32; green: UInt32; blue: UInt32; alpha: UInt32)>(z_ClearColorIuiEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearColorIuiEXT(red: UInt32; green: UInt32; blue: UInt32; alpha: UInt32);
begin
z_ClearColorIuiEXT_ovr_0(red, green, blue, alpha);
end;
end;
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);
public z_AreTexturesResidentEXT_adr := GetFuncAdr('glAreTexturesResidentEXT');
public z_AreTexturesResidentEXT_ovr_0 := GetFuncOrNil&<function(n: Int32; var textures: UInt32; var residences: boolean): boolean>(z_AreTexturesResidentEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResidentEXT(n: Int32; textures: array of UInt32; residences: array of boolean): boolean;
begin
Result := z_AreTexturesResidentEXT_ovr_0(n, textures[0], residences[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResidentEXT(n: Int32; textures: array of UInt32; var residences: boolean): boolean;
begin
Result := z_AreTexturesResidentEXT_ovr_0(n, textures[0], residences);
end;
public z_AreTexturesResidentEXT_ovr_2 := GetFuncOrNil&<function(n: Int32; var textures: UInt32; residences: IntPtr): boolean>(z_AreTexturesResidentEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResidentEXT(n: Int32; textures: array of UInt32; residences: IntPtr): boolean;
begin
Result := z_AreTexturesResidentEXT_ovr_2(n, textures[0], residences);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResidentEXT(n: Int32; var textures: UInt32; residences: array of boolean): boolean;
begin
Result := z_AreTexturesResidentEXT_ovr_0(n, textures, residences[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResidentEXT(n: Int32; var textures: UInt32; var residences: boolean): boolean;
begin
Result := z_AreTexturesResidentEXT_ovr_0(n, textures, residences);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResidentEXT(n: Int32; var textures: UInt32; residences: IntPtr): boolean;
begin
Result := z_AreTexturesResidentEXT_ovr_2(n, textures, residences);
end;
public z_AreTexturesResidentEXT_ovr_6 := GetFuncOrNil&<function(n: Int32; textures: IntPtr; var residences: boolean): boolean>(z_AreTexturesResidentEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResidentEXT(n: Int32; textures: IntPtr; residences: array of boolean): boolean;
begin
Result := z_AreTexturesResidentEXT_ovr_6(n, textures, residences[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResidentEXT(n: Int32; textures: IntPtr; var residences: boolean): boolean;
begin
Result := z_AreTexturesResidentEXT_ovr_6(n, textures, residences);
end;
public z_AreTexturesResidentEXT_ovr_8 := GetFuncOrNil&<function(n: Int32; textures: IntPtr; residences: IntPtr): boolean>(z_AreTexturesResidentEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreTexturesResidentEXT(n: Int32; textures: IntPtr; residences: IntPtr): boolean;
begin
Result := z_AreTexturesResidentEXT_ovr_8(n, textures, residences);
end;
public z_BindTextureEXT_adr := GetFuncAdr('glBindTextureEXT');
public z_BindTextureEXT_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; texture: UInt32)>(z_BindTextureEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindTextureEXT(target: TextureTarget; texture: UInt32);
begin
z_BindTextureEXT_ovr_0(target, texture);
end;
public z_DeleteTexturesEXT_adr := GetFuncAdr('glDeleteTexturesEXT');
public z_DeleteTexturesEXT_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var textures: UInt32)>(z_DeleteTexturesEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteTexturesEXT(n: Int32; textures: array of UInt32);
begin
z_DeleteTexturesEXT_ovr_0(n, textures[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteTexturesEXT(n: Int32; var textures: UInt32);
begin
z_DeleteTexturesEXT_ovr_0(n, textures);
end;
public z_DeleteTexturesEXT_ovr_2 := GetFuncOrNil&<procedure(n: Int32; textures: IntPtr)>(z_DeleteTexturesEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteTexturesEXT(n: Int32; textures: IntPtr);
begin
z_DeleteTexturesEXT_ovr_2(n, textures);
end;
public z_GenTexturesEXT_adr := GetFuncAdr('glGenTexturesEXT');
public z_GenTexturesEXT_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var textures: UInt32)>(z_GenTexturesEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenTexturesEXT(n: Int32; textures: array of UInt32);
begin
z_GenTexturesEXT_ovr_0(n, textures[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenTexturesEXT(n: Int32; var textures: UInt32);
begin
z_GenTexturesEXT_ovr_0(n, textures);
end;
public z_GenTexturesEXT_ovr_2 := GetFuncOrNil&<procedure(n: Int32; textures: IntPtr)>(z_GenTexturesEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenTexturesEXT(n: Int32; textures: IntPtr);
begin
z_GenTexturesEXT_ovr_2(n, textures);
end;
public z_IsTextureEXT_adr := GetFuncAdr('glIsTextureEXT');
public z_IsTextureEXT_ovr_0 := GetFuncOrNil&<function(texture: UInt32): boolean>(z_IsTextureEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsTextureEXT(texture: UInt32): boolean;
begin
Result := z_IsTextureEXT_ovr_0(texture);
end;
public z_PrioritizeTexturesEXT_adr := GetFuncAdr('glPrioritizeTexturesEXT');
public z_PrioritizeTexturesEXT_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var textures: UInt32; var priorities: single)>(z_PrioritizeTexturesEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesEXT(n: Int32; textures: array of UInt32; priorities: array of single);
begin
z_PrioritizeTexturesEXT_ovr_0(n, textures[0], priorities[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesEXT(n: Int32; textures: array of UInt32; var priorities: single);
begin
z_PrioritizeTexturesEXT_ovr_0(n, textures[0], priorities);
end;
public z_PrioritizeTexturesEXT_ovr_2 := GetFuncOrNil&<procedure(n: Int32; var textures: UInt32; priorities: IntPtr)>(z_PrioritizeTexturesEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesEXT(n: Int32; textures: array of UInt32; priorities: IntPtr);
begin
z_PrioritizeTexturesEXT_ovr_2(n, textures[0], priorities);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesEXT(n: Int32; var textures: UInt32; priorities: array of single);
begin
z_PrioritizeTexturesEXT_ovr_0(n, textures, priorities[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesEXT(n: Int32; var textures: UInt32; var priorities: single);
begin
z_PrioritizeTexturesEXT_ovr_0(n, textures, priorities);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesEXT(n: Int32; var textures: UInt32; priorities: IntPtr);
begin
z_PrioritizeTexturesEXT_ovr_2(n, textures, priorities);
end;
public z_PrioritizeTexturesEXT_ovr_6 := GetFuncOrNil&<procedure(n: Int32; textures: IntPtr; var priorities: single)>(z_PrioritizeTexturesEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesEXT(n: Int32; textures: IntPtr; priorities: array of single);
begin
z_PrioritizeTexturesEXT_ovr_6(n, textures, priorities[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesEXT(n: Int32; textures: IntPtr; var priorities: single);
begin
z_PrioritizeTexturesEXT_ovr_6(n, textures, priorities);
end;
public z_PrioritizeTexturesEXT_ovr_8 := GetFuncOrNil&<procedure(n: Int32; textures: IntPtr; priorities: IntPtr)>(z_PrioritizeTexturesEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesEXT(n: Int32; textures: IntPtr; priorities: IntPtr);
begin
z_PrioritizeTexturesEXT_ovr_8(n, textures, priorities);
end;
end;
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);
public z_TextureNormalEXT_adr := GetFuncAdr('glTextureNormalEXT');
public z_TextureNormalEXT_ovr_0 := GetFuncOrNil&<procedure(mode: TextureNormalModeEXT)>(z_TextureNormalEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureNormalEXT(mode: TextureNormalModeEXT);
begin
z_TextureNormalEXT_ovr_0(mode);
end;
end;
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);
public z_GetQueryObjecti64vEXT_adr := GetFuncAdr('glGetQueryObjecti64vEXT');
public z_GetQueryObjecti64vEXT_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; pname: QueryObjectParameterName; var ¶ms: Int64)>(z_GetQueryObjecti64vEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjecti64vEXT(id: UInt32; pname: QueryObjectParameterName; ¶ms: array of Int64);
begin
z_GetQueryObjecti64vEXT_ovr_0(id, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjecti64vEXT(id: UInt32; pname: QueryObjectParameterName; var ¶ms: Int64);
begin
z_GetQueryObjecti64vEXT_ovr_0(id, pname, ¶ms);
end;
public z_GetQueryObjecti64vEXT_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr)>(z_GetQueryObjecti64vEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjecti64vEXT(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr);
begin
z_GetQueryObjecti64vEXT_ovr_2(id, pname, ¶ms);
end;
public z_GetQueryObjectui64vEXT_adr := GetFuncAdr('glGetQueryObjectui64vEXT');
public z_GetQueryObjectui64vEXT_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; pname: QueryObjectParameterName; var ¶ms: UInt64)>(z_GetQueryObjectui64vEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectui64vEXT(id: UInt32; pname: QueryObjectParameterName; ¶ms: array of UInt64);
begin
z_GetQueryObjectui64vEXT_ovr_0(id, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectui64vEXT(id: UInt32; pname: QueryObjectParameterName; var ¶ms: UInt64);
begin
z_GetQueryObjectui64vEXT_ovr_0(id, pname, ¶ms);
end;
public z_GetQueryObjectui64vEXT_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr)>(z_GetQueryObjectui64vEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetQueryObjectui64vEXT(id: UInt32; pname: QueryObjectParameterName; ¶ms: IntPtr);
begin
z_GetQueryObjectui64vEXT_ovr_2(id, pname, ¶ms);
end;
end;
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);
public z_BeginTransformFeedbackEXT_adr := GetFuncAdr('glBeginTransformFeedbackEXT');
public z_BeginTransformFeedbackEXT_ovr_0 := GetFuncOrNil&<procedure(primitiveMode: PrimitiveType)>(z_BeginTransformFeedbackEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginTransformFeedbackEXT(primitiveMode: PrimitiveType);
begin
z_BeginTransformFeedbackEXT_ovr_0(primitiveMode);
end;
public z_EndTransformFeedbackEXT_adr := GetFuncAdr('glEndTransformFeedbackEXT');
public z_EndTransformFeedbackEXT_ovr_0 := GetFuncOrNil&<procedure>(z_EndTransformFeedbackEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndTransformFeedbackEXT;
begin
z_EndTransformFeedbackEXT_ovr_0;
end;
public z_BindBufferRangeEXT_adr := GetFuncAdr('glBindBufferRangeEXT');
public z_BindBufferRangeEXT_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; buffer: UInt32; offset: IntPtr; size: IntPtr)>(z_BindBufferRangeEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferRangeEXT(target: BufferTargetARB; index: UInt32; buffer: UInt32; offset: IntPtr; size: IntPtr);
begin
z_BindBufferRangeEXT_ovr_0(target, index, buffer, offset, size);
end;
public z_BindBufferOffsetEXT_adr := GetFuncAdr('glBindBufferOffsetEXT');
public z_BindBufferOffsetEXT_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; buffer: UInt32; offset: IntPtr)>(z_BindBufferOffsetEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferOffsetEXT(target: BufferTargetARB; index: UInt32; buffer: UInt32; offset: IntPtr);
begin
z_BindBufferOffsetEXT_ovr_0(target, index, buffer, offset);
end;
public z_BindBufferBaseEXT_adr := GetFuncAdr('glBindBufferBaseEXT');
public z_BindBufferBaseEXT_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; buffer: UInt32)>(z_BindBufferBaseEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferBaseEXT(target: BufferTargetARB; index: UInt32; buffer: UInt32);
begin
z_BindBufferBaseEXT_ovr_0(target, index, buffer);
end;
public z_TransformFeedbackVaryingsEXT_adr := GetFuncAdr('glTransformFeedbackVaryingsEXT');
public z_TransformFeedbackVaryingsEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; count: Int32; var varyings: IntPtr; bufferMode: DummyEnum)>(z_TransformFeedbackVaryingsEXT_adr);
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));
z_TransformFeedbackVaryingsEXT_ovr_0(&program, count, par_3_str_ptr[0], bufferMode);
foreach var arr_el1 in par_3_str_ptr do Marshal.FreeHGlobal(arr_el1);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackVaryingsEXT(&program: UInt32; count: Int32; varyings: array of IntPtr; bufferMode: DummyEnum);
begin
z_TransformFeedbackVaryingsEXT_ovr_0(&program, count, varyings[0], bufferMode);
end;
public z_TransformFeedbackVaryingsEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; count: Int32; varyings: IntPtr; bufferMode: DummyEnum)>(z_TransformFeedbackVaryingsEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackVaryingsEXT(&program: UInt32; count: Int32; varyings: IntPtr; bufferMode: DummyEnum);
begin
z_TransformFeedbackVaryingsEXT_ovr_2(&program, count, varyings, bufferMode);
end;
public z_GetTransformFeedbackVaryingEXT_adr := GetFuncAdr('glGetTransformFeedbackVaryingEXT');
public z_GetTransformFeedbackVaryingEXT_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; var &type: GlslTypeToken; name: IntPtr)>(z_GetTransformFeedbackVaryingEXT_adr);
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);
begin
z_GetTransformFeedbackVaryingEXT_ovr_0(&program, index, bufSize, length[0], size[0], &type[0], name);
end;
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);
begin
z_GetTransformFeedbackVaryingEXT_ovr_0(&program, index, bufSize, length[0], size[0], &type, name);
end;
public z_GetTransformFeedbackVaryingEXT_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetTransformFeedbackVaryingEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: array of Int32; &type: IntPtr; name: IntPtr);
begin
z_GetTransformFeedbackVaryingEXT_ovr_2(&program, index, bufSize, length[0], size[0], &type, name);
end;
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);
begin
z_GetTransformFeedbackVaryingEXT_ovr_0(&program, index, bufSize, length[0], size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; var size: Int32; var &type: GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVaryingEXT_ovr_0(&program, index, bufSize, length[0], size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; var size: Int32; &type: IntPtr; name: IntPtr);
begin
z_GetTransformFeedbackVaryingEXT_ovr_2(&program, index, bufSize, length[0], size, &type, name);
end;
public z_GetTransformFeedbackVaryingEXT_ovr_6 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; var &type: GlslTypeToken; name: IntPtr)>(z_GetTransformFeedbackVaryingEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: IntPtr; &type: array of GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVaryingEXT_ovr_6(&program, index, bufSize, length[0], size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: IntPtr; var &type: GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVaryingEXT_ovr_6(&program, index, bufSize, length[0], size, &type, name);
end;
public z_GetTransformFeedbackVaryingEXT_ovr_8 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetTransformFeedbackVaryingEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: IntPtr; &type: IntPtr; name: IntPtr);
begin
z_GetTransformFeedbackVaryingEXT_ovr_8(&program, index, bufSize, length[0], size, &type, name);
end;
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);
begin
z_GetTransformFeedbackVaryingEXT_ovr_0(&program, index, bufSize, length, size[0], &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: array of Int32; var &type: GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVaryingEXT_ovr_0(&program, index, bufSize, length, size[0], &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: array of Int32; &type: IntPtr; name: IntPtr);
begin
z_GetTransformFeedbackVaryingEXT_ovr_2(&program, index, bufSize, length, size[0], &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: array of GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVaryingEXT_ovr_0(&program, index, bufSize, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; var &type: GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVaryingEXT_ovr_0(&program, index, bufSize, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr);
begin
z_GetTransformFeedbackVaryingEXT_ovr_2(&program, index, bufSize, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: array of GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVaryingEXT_ovr_6(&program, index, bufSize, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; var &type: GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVaryingEXT_ovr_6(&program, index, bufSize, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr);
begin
z_GetTransformFeedbackVaryingEXT_ovr_8(&program, index, bufSize, length, size, &type, name);
end;
public z_GetTransformFeedbackVaryingEXT_ovr_18 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: GlslTypeToken; name: IntPtr)>(z_GetTransformFeedbackVaryingEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: array of Int32; &type: array of GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVaryingEXT_ovr_18(&program, index, bufSize, length, size[0], &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: array of Int32; var &type: GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVaryingEXT_ovr_18(&program, index, bufSize, length, size[0], &type, name);
end;
public z_GetTransformFeedbackVaryingEXT_ovr_20 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetTransformFeedbackVaryingEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: array of Int32; &type: IntPtr; name: IntPtr);
begin
z_GetTransformFeedbackVaryingEXT_ovr_20(&program, index, bufSize, length, size[0], &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: array of GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVaryingEXT_ovr_18(&program, index, bufSize, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVaryingEXT_ovr_18(&program, index, bufSize, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
begin
z_GetTransformFeedbackVaryingEXT_ovr_20(&program, index, bufSize, length, size, &type, name);
end;
public z_GetTransformFeedbackVaryingEXT_ovr_24 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: GlslTypeToken; name: IntPtr)>(z_GetTransformFeedbackVaryingEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: array of GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVaryingEXT_ovr_24(&program, index, bufSize, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: GlslTypeToken; name: IntPtr);
begin
z_GetTransformFeedbackVaryingEXT_ovr_24(&program, index, bufSize, length, size, &type, name);
end;
public z_GetTransformFeedbackVaryingEXT_ovr_26 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetTransformFeedbackVaryingEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingEXT(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
begin
z_GetTransformFeedbackVaryingEXT_ovr_26(&program, index, bufSize, length, size, &type, name);
end;
end;
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);
public z_ArrayElementEXT_adr := GetFuncAdr('glArrayElementEXT');
public z_ArrayElementEXT_ovr_0 := GetFuncOrNil&<procedure(i: Int32)>(z_ArrayElementEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ArrayElementEXT(i: Int32);
begin
z_ArrayElementEXT_ovr_0(i);
end;
public z_ColorPointerEXT_adr := GetFuncAdr('glColorPointerEXT');
public z_ColorPointerEXT_ovr_0 := GetFuncOrNil&<procedure(size: Int32; &type: ColorPointerType; stride: Int32; count: Int32; pointer: IntPtr)>(z_ColorPointerEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorPointerEXT(size: Int32; &type: ColorPointerType; stride: Int32; count: Int32; pointer: IntPtr);
begin
z_ColorPointerEXT_ovr_0(size, &type, stride, count, pointer);
end;
public z_DrawArraysEXT_adr := GetFuncAdr('glDrawArraysEXT');
public z_DrawArraysEXT_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; first: Int32; count: Int32)>(z_DrawArraysEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawArraysEXT(mode: PrimitiveType; first: Int32; count: Int32);
begin
z_DrawArraysEXT_ovr_0(mode, first, count);
end;
public z_EdgeFlagPointerEXT_adr := GetFuncAdr('glEdgeFlagPointerEXT');
public z_EdgeFlagPointerEXT_ovr_0 := GetFuncOrNil&<procedure(stride: Int32; count: Int32; var pointer: boolean)>(z_EdgeFlagPointerEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EdgeFlagPointerEXT(stride: Int32; count: Int32; pointer: array of boolean);
begin
z_EdgeFlagPointerEXT_ovr_0(stride, count, pointer[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EdgeFlagPointerEXT(stride: Int32; count: Int32; var pointer: boolean);
begin
z_EdgeFlagPointerEXT_ovr_0(stride, count, pointer);
end;
public z_EdgeFlagPointerEXT_ovr_2 := GetFuncOrNil&<procedure(stride: Int32; count: Int32; pointer: IntPtr)>(z_EdgeFlagPointerEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EdgeFlagPointerEXT(stride: Int32; count: Int32; pointer: IntPtr);
begin
z_EdgeFlagPointerEXT_ovr_2(stride, count, pointer);
end;
public z_GetPointervEXT_adr := GetFuncAdr('glGetPointervEXT');
public z_GetPointervEXT_ovr_0 := GetFuncOrNil&<procedure(pname: GetPointervPName; var ¶ms: IntPtr)>(z_GetPointervEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPointervEXT(pname: GetPointervPName; ¶ms: array of IntPtr);
begin
z_GetPointervEXT_ovr_0(pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPointervEXT(pname: GetPointervPName; var ¶ms: IntPtr);
begin
z_GetPointervEXT_ovr_0(pname, ¶ms);
end;
public z_GetPointervEXT_ovr_2 := GetFuncOrNil&<procedure(pname: GetPointervPName; ¶ms: pointer)>(z_GetPointervEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPointervEXT(pname: GetPointervPName; ¶ms: pointer);
begin
z_GetPointervEXT_ovr_2(pname, ¶ms);
end;
public z_IndexPointerEXT_adr := GetFuncAdr('glIndexPointerEXT');
public z_IndexPointerEXT_ovr_0 := GetFuncOrNil&<procedure(&type: IndexPointerType; stride: Int32; count: Int32; pointer: IntPtr)>(z_IndexPointerEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IndexPointerEXT(&type: IndexPointerType; stride: Int32; count: Int32; pointer: IntPtr);
begin
z_IndexPointerEXT_ovr_0(&type, stride, count, pointer);
end;
public z_NormalPointerEXT_adr := GetFuncAdr('glNormalPointerEXT');
public z_NormalPointerEXT_ovr_0 := GetFuncOrNil&<procedure(&type: NormalPointerType; stride: Int32; count: Int32; pointer: IntPtr)>(z_NormalPointerEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalPointerEXT(&type: NormalPointerType; stride: Int32; count: Int32; pointer: IntPtr);
begin
z_NormalPointerEXT_ovr_0(&type, stride, count, pointer);
end;
public z_TexCoordPointerEXT_adr := GetFuncAdr('glTexCoordPointerEXT');
public z_TexCoordPointerEXT_ovr_0 := GetFuncOrNil&<procedure(size: Int32; &type: TexCoordPointerType; stride: Int32; count: Int32; pointer: IntPtr)>(z_TexCoordPointerEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordPointerEXT(size: Int32; &type: TexCoordPointerType; stride: Int32; count: Int32; pointer: IntPtr);
begin
z_TexCoordPointerEXT_ovr_0(size, &type, stride, count, pointer);
end;
public z_VertexPointerEXT_adr := GetFuncAdr('glVertexPointerEXT');
public z_VertexPointerEXT_ovr_0 := GetFuncOrNil&<procedure(size: Int32; &type: VertexPointerType; stride: Int32; count: Int32; pointer: IntPtr)>(z_VertexPointerEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexPointerEXT(size: Int32; &type: VertexPointerType; stride: Int32; count: Int32; pointer: IntPtr);
begin
z_VertexPointerEXT_ovr_0(size, &type, stride, count, pointer);
end;
end;
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);
public z_VertexAttribL1dEXT_adr := GetFuncAdr('glVertexAttribL1dEXT');
public z_VertexAttribL1dEXT_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: real)>(z_VertexAttribL1dEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1dEXT(index: UInt32; x: real);
begin
z_VertexAttribL1dEXT_ovr_0(index, x);
end;
public z_VertexAttribL2dEXT_adr := GetFuncAdr('glVertexAttribL2dEXT');
public z_VertexAttribL2dEXT_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: real; y: real)>(z_VertexAttribL2dEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2dEXT(index: UInt32; x: real; y: real);
begin
z_VertexAttribL2dEXT_ovr_0(index, x, y);
end;
public z_VertexAttribL3dEXT_adr := GetFuncAdr('glVertexAttribL3dEXT');
public z_VertexAttribL3dEXT_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: real; y: real; z: real)>(z_VertexAttribL3dEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3dEXT(index: UInt32; x: real; y: real; z: real);
begin
z_VertexAttribL3dEXT_ovr_0(index, x, y, z);
end;
public z_VertexAttribL4dEXT_adr := GetFuncAdr('glVertexAttribL4dEXT');
public z_VertexAttribL4dEXT_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: real; y: real; z: real; w: real)>(z_VertexAttribL4dEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4dEXT(index: UInt32; x: real; y: real; z: real; w: real);
begin
z_VertexAttribL4dEXT_ovr_0(index, x, y, z, w);
end;
public z_VertexAttribL1dvEXT_adr := GetFuncAdr('glVertexAttribL1dvEXT');
public z_VertexAttribL1dvEXT_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttribL1dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1dvEXT(index: UInt32; v: array of real);
begin
z_VertexAttribL1dvEXT_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1dvEXT(index: UInt32; var v: real);
begin
z_VertexAttribL1dvEXT_ovr_0(index, v);
end;
public z_VertexAttribL1dvEXT_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribL1dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1dvEXT(index: UInt32; v: IntPtr);
begin
z_VertexAttribL1dvEXT_ovr_2(index, v);
end;
public z_VertexAttribL2dvEXT_adr := GetFuncAdr('glVertexAttribL2dvEXT');
public z_VertexAttribL2dvEXT_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttribL2dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2dvEXT(index: UInt32; v: array of real);
begin
z_VertexAttribL2dvEXT_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2dvEXT(index: UInt32; var v: real);
begin
z_VertexAttribL2dvEXT_ovr_0(index, v);
end;
public z_VertexAttribL2dvEXT_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribL2dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2dvEXT(index: UInt32; v: IntPtr);
begin
z_VertexAttribL2dvEXT_ovr_2(index, v);
end;
public z_VertexAttribL3dvEXT_adr := GetFuncAdr('glVertexAttribL3dvEXT');
public z_VertexAttribL3dvEXT_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttribL3dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3dvEXT(index: UInt32; v: array of real);
begin
z_VertexAttribL3dvEXT_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3dvEXT(index: UInt32; var v: real);
begin
z_VertexAttribL3dvEXT_ovr_0(index, v);
end;
public z_VertexAttribL3dvEXT_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribL3dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3dvEXT(index: UInt32; v: IntPtr);
begin
z_VertexAttribL3dvEXT_ovr_2(index, v);
end;
public z_VertexAttribL4dvEXT_adr := GetFuncAdr('glVertexAttribL4dvEXT');
public z_VertexAttribL4dvEXT_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttribL4dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4dvEXT(index: UInt32; v: array of real);
begin
z_VertexAttribL4dvEXT_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4dvEXT(index: UInt32; var v: real);
begin
z_VertexAttribL4dvEXT_ovr_0(index, v);
end;
public z_VertexAttribL4dvEXT_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribL4dvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4dvEXT(index: UInt32; v: IntPtr);
begin
z_VertexAttribL4dvEXT_ovr_2(index, v);
end;
public z_VertexAttribLPointerEXT_adr := GetFuncAdr('glVertexAttribLPointerEXT');
public z_VertexAttribLPointerEXT_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; size: Int32; &type: VertexAttribPointerType; stride: Int32; pointer: IntPtr)>(z_VertexAttribLPointerEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribLPointerEXT(index: UInt32; size: Int32; &type: VertexAttribPointerType; stride: Int32; pointer: IntPtr);
begin
z_VertexAttribLPointerEXT_ovr_0(index, size, &type, stride, pointer);
end;
public z_GetVertexAttribLdvEXT_adr := GetFuncAdr('glGetVertexAttribLdvEXT');
public z_GetVertexAttribLdvEXT_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnum; var ¶ms: real)>(z_GetVertexAttribLdvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLdvEXT(index: UInt32; pname: VertexAttribEnum; ¶ms: array of real);
begin
z_GetVertexAttribLdvEXT_ovr_0(index, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLdvEXT(index: UInt32; pname: VertexAttribEnum; var ¶ms: real);
begin
z_GetVertexAttribLdvEXT_ovr_0(index, pname, ¶ms);
end;
public z_GetVertexAttribLdvEXT_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr)>(z_GetVertexAttribLdvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLdvEXT(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr);
begin
z_GetVertexAttribLdvEXT_ovr_2(index, pname, ¶ms);
end;
end;
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);
public z_BeginVertexShaderEXT_adr := GetFuncAdr('glBeginVertexShaderEXT');
public z_BeginVertexShaderEXT_ovr_0 := GetFuncOrNil&<procedure>(z_BeginVertexShaderEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginVertexShaderEXT;
begin
z_BeginVertexShaderEXT_ovr_0;
end;
public z_EndVertexShaderEXT_adr := GetFuncAdr('glEndVertexShaderEXT');
public z_EndVertexShaderEXT_ovr_0 := GetFuncOrNil&<procedure>(z_EndVertexShaderEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndVertexShaderEXT;
begin
z_EndVertexShaderEXT_ovr_0;
end;
public z_BindVertexShaderEXT_adr := GetFuncAdr('glBindVertexShaderEXT');
public z_BindVertexShaderEXT_ovr_0 := GetFuncOrNil&<procedure(id: UInt32)>(z_BindVertexShaderEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVertexShaderEXT(id: UInt32);
begin
z_BindVertexShaderEXT_ovr_0(id);
end;
public z_GenVertexShadersEXT_adr := GetFuncAdr('glGenVertexShadersEXT');
public z_GenVertexShadersEXT_ovr_0 := GetFuncOrNil&<function(range: UInt32): UInt32>(z_GenVertexShadersEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GenVertexShadersEXT(range: UInt32): UInt32;
begin
Result := z_GenVertexShadersEXT_ovr_0(range);
end;
public z_DeleteVertexShaderEXT_adr := GetFuncAdr('glDeleteVertexShaderEXT');
public z_DeleteVertexShaderEXT_ovr_0 := GetFuncOrNil&<procedure(id: UInt32)>(z_DeleteVertexShaderEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteVertexShaderEXT(id: UInt32);
begin
z_DeleteVertexShaderEXT_ovr_0(id);
end;
public z_ShaderOp1EXT_adr := GetFuncAdr('glShaderOp1EXT');
public z_ShaderOp1EXT_ovr_0 := GetFuncOrNil&<procedure(op: VertexShaderOpEXT; res: UInt32; arg1: UInt32)>(z_ShaderOp1EXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderOp1EXT(op: VertexShaderOpEXT; res: UInt32; arg1: UInt32);
begin
z_ShaderOp1EXT_ovr_0(op, res, arg1);
end;
public z_ShaderOp2EXT_adr := GetFuncAdr('glShaderOp2EXT');
public z_ShaderOp2EXT_ovr_0 := GetFuncOrNil&<procedure(op: VertexShaderOpEXT; res: UInt32; arg1: UInt32; arg2: UInt32)>(z_ShaderOp2EXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderOp2EXT(op: VertexShaderOpEXT; res: UInt32; arg1: UInt32; arg2: UInt32);
begin
z_ShaderOp2EXT_ovr_0(op, res, arg1, arg2);
end;
public z_ShaderOp3EXT_adr := GetFuncAdr('glShaderOp3EXT');
public z_ShaderOp3EXT_ovr_0 := GetFuncOrNil&<procedure(op: VertexShaderOpEXT; res: UInt32; arg1: UInt32; arg2: UInt32; arg3: UInt32)>(z_ShaderOp3EXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShaderOp3EXT(op: VertexShaderOpEXT; res: UInt32; arg1: UInt32; arg2: UInt32; arg3: UInt32);
begin
z_ShaderOp3EXT_ovr_0(op, res, arg1, arg2, arg3);
end;
public z_SwizzleEXT_adr := GetFuncAdr('glSwizzleEXT');
public z_SwizzleEXT_ovr_0 := GetFuncOrNil&<procedure(res: UInt32; &in: UInt32; outX: VertexShaderCoordOutEXT; outY: VertexShaderCoordOutEXT; outZ: VertexShaderCoordOutEXT; outW: VertexShaderCoordOutEXT)>(z_SwizzleEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SwizzleEXT(res: UInt32; &in: UInt32; outX: VertexShaderCoordOutEXT; outY: VertexShaderCoordOutEXT; outZ: VertexShaderCoordOutEXT; outW: VertexShaderCoordOutEXT);
begin
z_SwizzleEXT_ovr_0(res, &in, outX, outY, outZ, outW);
end;
public z_WriteMaskEXT_adr := GetFuncAdr('glWriteMaskEXT');
public z_WriteMaskEXT_ovr_0 := GetFuncOrNil&<procedure(res: UInt32; &in: UInt32; outX: VertexShaderWriteMaskEXT; outY: VertexShaderWriteMaskEXT; outZ: VertexShaderWriteMaskEXT; outW: VertexShaderWriteMaskEXT)>(z_WriteMaskEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WriteMaskEXT(res: UInt32; &in: UInt32; outX: VertexShaderWriteMaskEXT; outY: VertexShaderWriteMaskEXT; outZ: VertexShaderWriteMaskEXT; outW: VertexShaderWriteMaskEXT);
begin
z_WriteMaskEXT_ovr_0(res, &in, outX, outY, outZ, outW);
end;
public z_InsertComponentEXT_adr := GetFuncAdr('glInsertComponentEXT');
public z_InsertComponentEXT_ovr_0 := GetFuncOrNil&<procedure(res: UInt32; src: UInt32; num: UInt32)>(z_InsertComponentEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InsertComponentEXT(res: UInt32; src: UInt32; num: UInt32);
begin
z_InsertComponentEXT_ovr_0(res, src, num);
end;
public z_ExtractComponentEXT_adr := GetFuncAdr('glExtractComponentEXT');
public z_ExtractComponentEXT_ovr_0 := GetFuncOrNil&<procedure(res: UInt32; src: UInt32; num: UInt32)>(z_ExtractComponentEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ExtractComponentEXT(res: UInt32; src: UInt32; num: UInt32);
begin
z_ExtractComponentEXT_ovr_0(res, src, num);
end;
public z_GenSymbolsEXT_adr := GetFuncAdr('glGenSymbolsEXT');
public z_GenSymbolsEXT_ovr_0 := GetFuncOrNil&<function(datatype: DataTypeEXT; storagetype: VertexShaderStorageTypeEXT; range: ParameterRangeEXT; components: UInt32): UInt32>(z_GenSymbolsEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GenSymbolsEXT(datatype: DataTypeEXT; storagetype: VertexShaderStorageTypeEXT; range: ParameterRangeEXT; components: UInt32): UInt32;
begin
Result := z_GenSymbolsEXT_ovr_0(datatype, storagetype, range, components);
end;
public z_SetInvariantEXT_adr := GetFuncAdr('glSetInvariantEXT');
public z_SetInvariantEXT_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; &type: ScalarType; addr: IntPtr)>(z_SetInvariantEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SetInvariantEXT(id: UInt32; &type: ScalarType; addr: IntPtr);
begin
z_SetInvariantEXT_ovr_0(id, &type, addr);
end;
public z_SetLocalConstantEXT_adr := GetFuncAdr('glSetLocalConstantEXT');
public z_SetLocalConstantEXT_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; &type: ScalarType; addr: IntPtr)>(z_SetLocalConstantEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SetLocalConstantEXT(id: UInt32; &type: ScalarType; addr: IntPtr);
begin
z_SetLocalConstantEXT_ovr_0(id, &type, addr);
end;
public z_VariantbvEXT_adr := GetFuncAdr('glVariantbvEXT');
public z_VariantbvEXT_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; var addr: SByte)>(z_VariantbvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantbvEXT(id: UInt32; addr: array of SByte);
begin
z_VariantbvEXT_ovr_0(id, addr[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantbvEXT(id: UInt32; var addr: SByte);
begin
z_VariantbvEXT_ovr_0(id, addr);
end;
public z_VariantbvEXT_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; addr: IntPtr)>(z_VariantbvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantbvEXT(id: UInt32; addr: IntPtr);
begin
z_VariantbvEXT_ovr_2(id, addr);
end;
public z_VariantsvEXT_adr := GetFuncAdr('glVariantsvEXT');
public z_VariantsvEXT_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; var addr: Int16)>(z_VariantsvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantsvEXT(id: UInt32; addr: array of Int16);
begin
z_VariantsvEXT_ovr_0(id, addr[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantsvEXT(id: UInt32; var addr: Int16);
begin
z_VariantsvEXT_ovr_0(id, addr);
end;
public z_VariantsvEXT_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; addr: IntPtr)>(z_VariantsvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantsvEXT(id: UInt32; addr: IntPtr);
begin
z_VariantsvEXT_ovr_2(id, addr);
end;
public z_VariantivEXT_adr := GetFuncAdr('glVariantivEXT');
public z_VariantivEXT_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; var addr: Int32)>(z_VariantivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantivEXT(id: UInt32; addr: array of Int32);
begin
z_VariantivEXT_ovr_0(id, addr[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantivEXT(id: UInt32; var addr: Int32);
begin
z_VariantivEXT_ovr_0(id, addr);
end;
public z_VariantivEXT_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; addr: IntPtr)>(z_VariantivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantivEXT(id: UInt32; addr: IntPtr);
begin
z_VariantivEXT_ovr_2(id, addr);
end;
public z_VariantfvEXT_adr := GetFuncAdr('glVariantfvEXT');
public z_VariantfvEXT_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; var addr: single)>(z_VariantfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantfvEXT(id: UInt32; addr: array of single);
begin
z_VariantfvEXT_ovr_0(id, addr[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantfvEXT(id: UInt32; var addr: single);
begin
z_VariantfvEXT_ovr_0(id, addr);
end;
public z_VariantfvEXT_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; addr: IntPtr)>(z_VariantfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantfvEXT(id: UInt32; addr: IntPtr);
begin
z_VariantfvEXT_ovr_2(id, addr);
end;
public z_VariantdvEXT_adr := GetFuncAdr('glVariantdvEXT');
public z_VariantdvEXT_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; var addr: real)>(z_VariantdvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantdvEXT(id: UInt32; addr: array of real);
begin
z_VariantdvEXT_ovr_0(id, addr[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantdvEXT(id: UInt32; var addr: real);
begin
z_VariantdvEXT_ovr_0(id, addr);
end;
public z_VariantdvEXT_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; addr: IntPtr)>(z_VariantdvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantdvEXT(id: UInt32; addr: IntPtr);
begin
z_VariantdvEXT_ovr_2(id, addr);
end;
public z_VariantubvEXT_adr := GetFuncAdr('glVariantubvEXT');
public z_VariantubvEXT_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; var addr: Byte)>(z_VariantubvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantubvEXT(id: UInt32; addr: array of Byte);
begin
z_VariantubvEXT_ovr_0(id, addr[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantubvEXT(id: UInt32; var addr: Byte);
begin
z_VariantubvEXT_ovr_0(id, addr);
end;
public z_VariantubvEXT_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; addr: IntPtr)>(z_VariantubvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantubvEXT(id: UInt32; addr: IntPtr);
begin
z_VariantubvEXT_ovr_2(id, addr);
end;
public z_VariantusvEXT_adr := GetFuncAdr('glVariantusvEXT');
public z_VariantusvEXT_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; var addr: UInt16)>(z_VariantusvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantusvEXT(id: UInt32; addr: array of UInt16);
begin
z_VariantusvEXT_ovr_0(id, addr[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantusvEXT(id: UInt32; var addr: UInt16);
begin
z_VariantusvEXT_ovr_0(id, addr);
end;
public z_VariantusvEXT_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; addr: IntPtr)>(z_VariantusvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantusvEXT(id: UInt32; addr: IntPtr);
begin
z_VariantusvEXT_ovr_2(id, addr);
end;
public z_VariantuivEXT_adr := GetFuncAdr('glVariantuivEXT');
public z_VariantuivEXT_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; var addr: UInt32)>(z_VariantuivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantuivEXT(id: UInt32; addr: array of UInt32);
begin
z_VariantuivEXT_ovr_0(id, addr[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantuivEXT(id: UInt32; var addr: UInt32);
begin
z_VariantuivEXT_ovr_0(id, addr);
end;
public z_VariantuivEXT_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; addr: IntPtr)>(z_VariantuivEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantuivEXT(id: UInt32; addr: IntPtr);
begin
z_VariantuivEXT_ovr_2(id, addr);
end;
public z_VariantPointerEXT_adr := GetFuncAdr('glVariantPointerEXT');
public z_VariantPointerEXT_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; &type: ScalarType; stride: UInt32; addr: IntPtr)>(z_VariantPointerEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VariantPointerEXT(id: UInt32; &type: ScalarType; stride: UInt32; addr: IntPtr);
begin
z_VariantPointerEXT_ovr_0(id, &type, stride, addr);
end;
public z_EnableVariantClientStateEXT_adr := GetFuncAdr('glEnableVariantClientStateEXT');
public z_EnableVariantClientStateEXT_ovr_0 := GetFuncOrNil&<procedure(id: UInt32)>(z_EnableVariantClientStateEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EnableVariantClientStateEXT(id: UInt32);
begin
z_EnableVariantClientStateEXT_ovr_0(id);
end;
public z_DisableVariantClientStateEXT_adr := GetFuncAdr('glDisableVariantClientStateEXT');
public z_DisableVariantClientStateEXT_ovr_0 := GetFuncOrNil&<procedure(id: UInt32)>(z_DisableVariantClientStateEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DisableVariantClientStateEXT(id: UInt32);
begin
z_DisableVariantClientStateEXT_ovr_0(id);
end;
public z_BindLightParameterEXT_adr := GetFuncAdr('glBindLightParameterEXT');
public z_BindLightParameterEXT_ovr_0 := GetFuncOrNil&<function(light: LightName; value: LightParameter): UInt32>(z_BindLightParameterEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function BindLightParameterEXT(light: LightName; value: LightParameter): UInt32;
begin
Result := z_BindLightParameterEXT_ovr_0(light, value);
end;
public z_BindMaterialParameterEXT_adr := GetFuncAdr('glBindMaterialParameterEXT');
public z_BindMaterialParameterEXT_ovr_0 := GetFuncOrNil&<function(face: DummyEnum; value: MaterialParameter): UInt32>(z_BindMaterialParameterEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function BindMaterialParameterEXT(face: DummyEnum; value: MaterialParameter): UInt32;
begin
Result := z_BindMaterialParameterEXT_ovr_0(face, value);
end;
public z_BindTexGenParameterEXT_adr := GetFuncAdr('glBindTexGenParameterEXT');
public z_BindTexGenParameterEXT_ovr_0 := GetFuncOrNil&<function(&unit: TextureUnit; coord: TextureCoordName; value: TextureGenParameter): UInt32>(z_BindTexGenParameterEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function BindTexGenParameterEXT(&unit: TextureUnit; coord: TextureCoordName; value: TextureGenParameter): UInt32;
begin
Result := z_BindTexGenParameterEXT_ovr_0(&unit, coord, value);
end;
public z_BindTextureUnitParameterEXT_adr := GetFuncAdr('glBindTextureUnitParameterEXT');
public z_BindTextureUnitParameterEXT_ovr_0 := GetFuncOrNil&<function(&unit: TextureUnit; value: VertexShaderTextureUnitParameter): UInt32>(z_BindTextureUnitParameterEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function BindTextureUnitParameterEXT(&unit: TextureUnit; value: VertexShaderTextureUnitParameter): UInt32;
begin
Result := z_BindTextureUnitParameterEXT_ovr_0(&unit, value);
end;
public z_BindParameterEXT_adr := GetFuncAdr('glBindParameterEXT');
public z_BindParameterEXT_ovr_0 := GetFuncOrNil&<function(value: VertexShaderParameterEXT): UInt32>(z_BindParameterEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function BindParameterEXT(value: VertexShaderParameterEXT): UInt32;
begin
Result := z_BindParameterEXT_ovr_0(value);
end;
public z_IsVariantEnabledEXT_adr := GetFuncAdr('glIsVariantEnabledEXT');
public z_IsVariantEnabledEXT_ovr_0 := GetFuncOrNil&<function(id: UInt32; cap: VariantCapEXT): boolean>(z_IsVariantEnabledEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsVariantEnabledEXT(id: UInt32; cap: VariantCapEXT): boolean;
begin
Result := z_IsVariantEnabledEXT_ovr_0(id, cap);
end;
public z_GetVariantBooleanvEXT_adr := GetFuncAdr('glGetVariantBooleanvEXT');
public z_GetVariantBooleanvEXT_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; value: GetVariantValueEXT; var data: boolean)>(z_GetVariantBooleanvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantBooleanvEXT(id: UInt32; value: GetVariantValueEXT; data: array of boolean);
begin
z_GetVariantBooleanvEXT_ovr_0(id, value, data[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantBooleanvEXT(id: UInt32; value: GetVariantValueEXT; var data: boolean);
begin
z_GetVariantBooleanvEXT_ovr_0(id, value, data);
end;
public z_GetVariantBooleanvEXT_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; value: GetVariantValueEXT; data: IntPtr)>(z_GetVariantBooleanvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantBooleanvEXT(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
begin
z_GetVariantBooleanvEXT_ovr_2(id, value, data);
end;
public z_GetVariantIntegervEXT_adr := GetFuncAdr('glGetVariantIntegervEXT');
public z_GetVariantIntegervEXT_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; value: GetVariantValueEXT; var data: Int32)>(z_GetVariantIntegervEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantIntegervEXT(id: UInt32; value: GetVariantValueEXT; data: array of Int32);
begin
z_GetVariantIntegervEXT_ovr_0(id, value, data[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantIntegervEXT(id: UInt32; value: GetVariantValueEXT; var data: Int32);
begin
z_GetVariantIntegervEXT_ovr_0(id, value, data);
end;
public z_GetVariantIntegervEXT_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; value: GetVariantValueEXT; data: IntPtr)>(z_GetVariantIntegervEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantIntegervEXT(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
begin
z_GetVariantIntegervEXT_ovr_2(id, value, data);
end;
public z_GetVariantFloatvEXT_adr := GetFuncAdr('glGetVariantFloatvEXT');
public z_GetVariantFloatvEXT_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; value: GetVariantValueEXT; var data: single)>(z_GetVariantFloatvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantFloatvEXT(id: UInt32; value: GetVariantValueEXT; data: array of single);
begin
z_GetVariantFloatvEXT_ovr_0(id, value, data[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantFloatvEXT(id: UInt32; value: GetVariantValueEXT; var data: single);
begin
z_GetVariantFloatvEXT_ovr_0(id, value, data);
end;
public z_GetVariantFloatvEXT_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; value: GetVariantValueEXT; data: IntPtr)>(z_GetVariantFloatvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantFloatvEXT(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
begin
z_GetVariantFloatvEXT_ovr_2(id, value, data);
end;
public z_GetVariantPointervEXT_adr := GetFuncAdr('glGetVariantPointervEXT');
public z_GetVariantPointervEXT_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; value: GetVariantValueEXT; var data: IntPtr)>(z_GetVariantPointervEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantPointervEXT(id: UInt32; value: GetVariantValueEXT; data: array of IntPtr);
begin
z_GetVariantPointervEXT_ovr_0(id, value, data[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantPointervEXT(id: UInt32; value: GetVariantValueEXT; var data: IntPtr);
begin
z_GetVariantPointervEXT_ovr_0(id, value, data);
end;
public z_GetVariantPointervEXT_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; value: GetVariantValueEXT; data: pointer)>(z_GetVariantPointervEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVariantPointervEXT(id: UInt32; value: GetVariantValueEXT; data: pointer);
begin
z_GetVariantPointervEXT_ovr_2(id, value, data);
end;
public z_GetInvariantBooleanvEXT_adr := GetFuncAdr('glGetInvariantBooleanvEXT');
public z_GetInvariantBooleanvEXT_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; value: GetVariantValueEXT; var data: boolean)>(z_GetInvariantBooleanvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInvariantBooleanvEXT(id: UInt32; value: GetVariantValueEXT; data: array of boolean);
begin
z_GetInvariantBooleanvEXT_ovr_0(id, value, data[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInvariantBooleanvEXT(id: UInt32; value: GetVariantValueEXT; var data: boolean);
begin
z_GetInvariantBooleanvEXT_ovr_0(id, value, data);
end;
public z_GetInvariantBooleanvEXT_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; value: GetVariantValueEXT; data: IntPtr)>(z_GetInvariantBooleanvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInvariantBooleanvEXT(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
begin
z_GetInvariantBooleanvEXT_ovr_2(id, value, data);
end;
public z_GetInvariantIntegervEXT_adr := GetFuncAdr('glGetInvariantIntegervEXT');
public z_GetInvariantIntegervEXT_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; value: GetVariantValueEXT; var data: Int32)>(z_GetInvariantIntegervEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInvariantIntegervEXT(id: UInt32; value: GetVariantValueEXT; data: array of Int32);
begin
z_GetInvariantIntegervEXT_ovr_0(id, value, data[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInvariantIntegervEXT(id: UInt32; value: GetVariantValueEXT; var data: Int32);
begin
z_GetInvariantIntegervEXT_ovr_0(id, value, data);
end;
public z_GetInvariantIntegervEXT_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; value: GetVariantValueEXT; data: IntPtr)>(z_GetInvariantIntegervEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInvariantIntegervEXT(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
begin
z_GetInvariantIntegervEXT_ovr_2(id, value, data);
end;
public z_GetInvariantFloatvEXT_adr := GetFuncAdr('glGetInvariantFloatvEXT');
public z_GetInvariantFloatvEXT_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; value: GetVariantValueEXT; var data: single)>(z_GetInvariantFloatvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInvariantFloatvEXT(id: UInt32; value: GetVariantValueEXT; data: array of single);
begin
z_GetInvariantFloatvEXT_ovr_0(id, value, data[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInvariantFloatvEXT(id: UInt32; value: GetVariantValueEXT; var data: single);
begin
z_GetInvariantFloatvEXT_ovr_0(id, value, data);
end;
public z_GetInvariantFloatvEXT_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; value: GetVariantValueEXT; data: IntPtr)>(z_GetInvariantFloatvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInvariantFloatvEXT(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
begin
z_GetInvariantFloatvEXT_ovr_2(id, value, data);
end;
public z_GetLocalConstantBooleanvEXT_adr := GetFuncAdr('glGetLocalConstantBooleanvEXT');
public z_GetLocalConstantBooleanvEXT_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; value: GetVariantValueEXT; var data: boolean)>(z_GetLocalConstantBooleanvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLocalConstantBooleanvEXT(id: UInt32; value: GetVariantValueEXT; data: array of boolean);
begin
z_GetLocalConstantBooleanvEXT_ovr_0(id, value, data[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLocalConstantBooleanvEXT(id: UInt32; value: GetVariantValueEXT; var data: boolean);
begin
z_GetLocalConstantBooleanvEXT_ovr_0(id, value, data);
end;
public z_GetLocalConstantBooleanvEXT_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; value: GetVariantValueEXT; data: IntPtr)>(z_GetLocalConstantBooleanvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLocalConstantBooleanvEXT(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
begin
z_GetLocalConstantBooleanvEXT_ovr_2(id, value, data);
end;
public z_GetLocalConstantIntegervEXT_adr := GetFuncAdr('glGetLocalConstantIntegervEXT');
public z_GetLocalConstantIntegervEXT_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; value: GetVariantValueEXT; var data: Int32)>(z_GetLocalConstantIntegervEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLocalConstantIntegervEXT(id: UInt32; value: GetVariantValueEXT; data: array of Int32);
begin
z_GetLocalConstantIntegervEXT_ovr_0(id, value, data[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLocalConstantIntegervEXT(id: UInt32; value: GetVariantValueEXT; var data: Int32);
begin
z_GetLocalConstantIntegervEXT_ovr_0(id, value, data);
end;
public z_GetLocalConstantIntegervEXT_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; value: GetVariantValueEXT; data: IntPtr)>(z_GetLocalConstantIntegervEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLocalConstantIntegervEXT(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
begin
z_GetLocalConstantIntegervEXT_ovr_2(id, value, data);
end;
public z_GetLocalConstantFloatvEXT_adr := GetFuncAdr('glGetLocalConstantFloatvEXT');
public z_GetLocalConstantFloatvEXT_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; value: GetVariantValueEXT; var data: single)>(z_GetLocalConstantFloatvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLocalConstantFloatvEXT(id: UInt32; value: GetVariantValueEXT; data: array of single);
begin
z_GetLocalConstantFloatvEXT_ovr_0(id, value, data[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLocalConstantFloatvEXT(id: UInt32; value: GetVariantValueEXT; var data: single);
begin
z_GetLocalConstantFloatvEXT_ovr_0(id, value, data);
end;
public z_GetLocalConstantFloatvEXT_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; value: GetVariantValueEXT; data: IntPtr)>(z_GetLocalConstantFloatvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLocalConstantFloatvEXT(id: UInt32; value: GetVariantValueEXT; data: IntPtr);
begin
z_GetLocalConstantFloatvEXT_ovr_2(id, value, data);
end;
end;
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);
public z_VertexWeightfEXT_adr := GetFuncAdr('glVertexWeightfEXT');
public z_VertexWeightfEXT_ovr_0 := GetFuncOrNil&<procedure(weight: single)>(z_VertexWeightfEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexWeightfEXT(weight: single);
begin
z_VertexWeightfEXT_ovr_0(weight);
end;
public z_VertexWeightfvEXT_adr := GetFuncAdr('glVertexWeightfvEXT');
public z_VertexWeightfvEXT_ovr_0 := GetFuncOrNil&<procedure(var weight: single)>(z_VertexWeightfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexWeightfvEXT(weight: array of single);
begin
z_VertexWeightfvEXT_ovr_0(weight[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexWeightfvEXT(var weight: single);
begin
z_VertexWeightfvEXT_ovr_0(weight);
end;
public z_VertexWeightfvEXT_ovr_2 := GetFuncOrNil&<procedure(weight: IntPtr)>(z_VertexWeightfvEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexWeightfvEXT(weight: IntPtr);
begin
z_VertexWeightfvEXT_ovr_2(weight);
end;
public z_VertexWeightPointerEXT_adr := GetFuncAdr('glVertexWeightPointerEXT');
public z_VertexWeightPointerEXT_ovr_0 := GetFuncOrNil&<procedure(size: Int32; &type: VertexWeightPointerTypeEXT; stride: Int32; pointer: IntPtr)>(z_VertexWeightPointerEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexWeightPointerEXT(size: Int32; &type: VertexWeightPointerTypeEXT; stride: Int32; pointer: IntPtr);
begin
z_VertexWeightPointerEXT_ovr_0(size, &type, stride, pointer);
end;
end;
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);
public z_AcquireKeyedMutexWin32EXT_adr := GetFuncAdr('glAcquireKeyedMutexWin32EXT');
public z_AcquireKeyedMutexWin32EXT_ovr_0 := GetFuncOrNil&<function(memory: UInt32; key: UInt64; timeout: UInt32): boolean>(z_AcquireKeyedMutexWin32EXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AcquireKeyedMutexWin32EXT(memory: UInt32; key: UInt64; timeout: UInt32): boolean;
begin
Result := z_AcquireKeyedMutexWin32EXT_ovr_0(memory, key, timeout);
end;
public z_ReleaseKeyedMutexWin32EXT_adr := GetFuncAdr('glReleaseKeyedMutexWin32EXT');
public z_ReleaseKeyedMutexWin32EXT_ovr_0 := GetFuncOrNil&<function(memory: UInt32; key: UInt64): boolean>(z_ReleaseKeyedMutexWin32EXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function ReleaseKeyedMutexWin32EXT(memory: UInt32; key: UInt64): boolean;
begin
Result := z_ReleaseKeyedMutexWin32EXT_ovr_0(memory, key);
end;
end;
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);
public z_WindowRectanglesEXT_adr := GetFuncAdr('glWindowRectanglesEXT');
public z_WindowRectanglesEXT_ovr_0 := GetFuncOrNil&<procedure(mode: DummyEnum; count: Int32; var box: Int32)>(z_WindowRectanglesEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowRectanglesEXT(mode: DummyEnum; count: Int32; box: array of Int32);
begin
z_WindowRectanglesEXT_ovr_0(mode, count, box[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowRectanglesEXT(mode: DummyEnum; count: Int32; var box: Int32);
begin
z_WindowRectanglesEXT_ovr_0(mode, count, box);
end;
public z_WindowRectanglesEXT_ovr_2 := GetFuncOrNil&<procedure(mode: DummyEnum; count: Int32; box: IntPtr)>(z_WindowRectanglesEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowRectanglesEXT(mode: DummyEnum; count: Int32; box: IntPtr);
begin
z_WindowRectanglesEXT_ovr_2(mode, count, box);
end;
end;
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);
public z_ImportSyncEXT_adr := GetFuncAdr('glImportSyncEXT');
public z_ImportSyncEXT_ovr_0 := GetFuncOrNil&<function(external_sync_type: DummyEnum; external_sync: IntPtr; flags: DummyFlags): GLsync>(z_ImportSyncEXT_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function ImportSyncEXT(external_sync_type: DummyEnum; external_sync: IntPtr; flags: DummyFlags): GLsync;
begin
Result := z_ImportSyncEXT_ovr_0(external_sync_type, external_sync, flags);
end;
end;
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);
public z_FrameTerminatorGREMEDY_adr := GetFuncAdr('glFrameTerminatorGREMEDY');
public z_FrameTerminatorGREMEDY_ovr_0 := GetFuncOrNil&<procedure>(z_FrameTerminatorGREMEDY_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FrameTerminatorGREMEDY;
begin
z_FrameTerminatorGREMEDY_ovr_0;
end;
end;
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);
public z_StringMarkerGREMEDY_adr := GetFuncAdr('glStringMarkerGREMEDY');
public z_StringMarkerGREMEDY_ovr_0 := GetFuncOrNil&<procedure(len: Int32; string: IntPtr)>(z_StringMarkerGREMEDY_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StringMarkerGREMEDY(len: Int32; string: IntPtr);
begin
z_StringMarkerGREMEDY_ovr_0(len, string);
end;
end;
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);
public z_ImageTransformParameteriHP_adr := GetFuncAdr('glImageTransformParameteriHP');
public z_ImageTransformParameteriHP_ovr_0 := GetFuncOrNil&<procedure(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; param: Int32)>(z_ImageTransformParameteriHP_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImageTransformParameteriHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; param: Int32);
begin
z_ImageTransformParameteriHP_ovr_0(target, pname, param);
end;
public z_ImageTransformParameterfHP_adr := GetFuncAdr('glImageTransformParameterfHP');
public z_ImageTransformParameterfHP_ovr_0 := GetFuncOrNil&<procedure(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; param: single)>(z_ImageTransformParameterfHP_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImageTransformParameterfHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; param: single);
begin
z_ImageTransformParameterfHP_ovr_0(target, pname, param);
end;
public z_ImageTransformParameterivHP_adr := GetFuncAdr('glImageTransformParameterivHP');
public z_ImageTransformParameterivHP_ovr_0 := GetFuncOrNil&<procedure(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; var ¶ms: Int32)>(z_ImageTransformParameterivHP_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImageTransformParameterivHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: array of Int32);
begin
z_ImageTransformParameterivHP_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImageTransformParameterivHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; var ¶ms: Int32);
begin
z_ImageTransformParameterivHP_ovr_0(target, pname, ¶ms);
end;
public z_ImageTransformParameterivHP_ovr_2 := GetFuncOrNil&<procedure(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: IntPtr)>(z_ImageTransformParameterivHP_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImageTransformParameterivHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: IntPtr);
begin
z_ImageTransformParameterivHP_ovr_2(target, pname, ¶ms);
end;
public z_ImageTransformParameterfvHP_adr := GetFuncAdr('glImageTransformParameterfvHP');
public z_ImageTransformParameterfvHP_ovr_0 := GetFuncOrNil&<procedure(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; var ¶ms: single)>(z_ImageTransformParameterfvHP_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImageTransformParameterfvHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: array of single);
begin
z_ImageTransformParameterfvHP_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImageTransformParameterfvHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; var ¶ms: single);
begin
z_ImageTransformParameterfvHP_ovr_0(target, pname, ¶ms);
end;
public z_ImageTransformParameterfvHP_ovr_2 := GetFuncOrNil&<procedure(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: IntPtr)>(z_ImageTransformParameterfvHP_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ImageTransformParameterfvHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: IntPtr);
begin
z_ImageTransformParameterfvHP_ovr_2(target, pname, ¶ms);
end;
public z_GetImageTransformParameterivHP_adr := GetFuncAdr('glGetImageTransformParameterivHP');
public z_GetImageTransformParameterivHP_ovr_0 := GetFuncOrNil&<procedure(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; var ¶ms: Int32)>(z_GetImageTransformParameterivHP_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetImageTransformParameterivHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: array of Int32);
begin
z_GetImageTransformParameterivHP_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetImageTransformParameterivHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; var ¶ms: Int32);
begin
z_GetImageTransformParameterivHP_ovr_0(target, pname, ¶ms);
end;
public z_GetImageTransformParameterivHP_ovr_2 := GetFuncOrNil&<procedure(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: IntPtr)>(z_GetImageTransformParameterivHP_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetImageTransformParameterivHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: IntPtr);
begin
z_GetImageTransformParameterivHP_ovr_2(target, pname, ¶ms);
end;
public z_GetImageTransformParameterfvHP_adr := GetFuncAdr('glGetImageTransformParameterfvHP');
public z_GetImageTransformParameterfvHP_ovr_0 := GetFuncOrNil&<procedure(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; var ¶ms: single)>(z_GetImageTransformParameterfvHP_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetImageTransformParameterfvHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: array of single);
begin
z_GetImageTransformParameterfvHP_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetImageTransformParameterfvHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; var ¶ms: single);
begin
z_GetImageTransformParameterfvHP_ovr_0(target, pname, ¶ms);
end;
public z_GetImageTransformParameterfvHP_ovr_2 := GetFuncOrNil&<procedure(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: IntPtr)>(z_GetImageTransformParameterfvHP_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetImageTransformParameterfvHP(target: ImageTransformTargetHP; pname: ImageTransformPNameHP; ¶ms: IntPtr);
begin
z_GetImageTransformParameterfvHP_ovr_2(target, pname, ¶ms);
end;
end;
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);
public z_MultiModeDrawArraysIBM_adr := GetFuncAdr('glMultiModeDrawArraysIBM');
public z_MultiModeDrawArraysIBM_ovr_0 := GetFuncOrNil&<procedure(var mode: PrimitiveType; var first: Int32; var count: Int32; primcount: Int32; modestride: Int32)>(z_MultiModeDrawArraysIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: array of PrimitiveType; first: array of Int32; count: array of Int32; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawArraysIBM_ovr_0(mode[0], first[0], count[0], primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: array of PrimitiveType; first: array of Int32; var count: Int32; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawArraysIBM_ovr_0(mode[0], first[0], count, primcount, modestride);
end;
public z_MultiModeDrawArraysIBM_ovr_2 := GetFuncOrNil&<procedure(var mode: PrimitiveType; var first: Int32; count: IntPtr; primcount: Int32; modestride: Int32)>(z_MultiModeDrawArraysIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: array of PrimitiveType; first: array of Int32; count: IntPtr; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawArraysIBM_ovr_2(mode[0], first[0], count, primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: array of PrimitiveType; var first: Int32; count: array of Int32; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawArraysIBM_ovr_0(mode[0], first, count[0], primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: array of PrimitiveType; var first: Int32; var count: Int32; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawArraysIBM_ovr_0(mode[0], first, count, primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: array of PrimitiveType; var first: Int32; count: IntPtr; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawArraysIBM_ovr_2(mode[0], first, count, primcount, modestride);
end;
public z_MultiModeDrawArraysIBM_ovr_6 := GetFuncOrNil&<procedure(var mode: PrimitiveType; first: IntPtr; var count: Int32; primcount: Int32; modestride: Int32)>(z_MultiModeDrawArraysIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: array of PrimitiveType; first: IntPtr; count: array of Int32; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawArraysIBM_ovr_6(mode[0], first, count[0], primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: array of PrimitiveType; first: IntPtr; var count: Int32; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawArraysIBM_ovr_6(mode[0], first, count, primcount, modestride);
end;
public z_MultiModeDrawArraysIBM_ovr_8 := GetFuncOrNil&<procedure(var mode: PrimitiveType; first: IntPtr; count: IntPtr; primcount: Int32; modestride: Int32)>(z_MultiModeDrawArraysIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: array of PrimitiveType; first: IntPtr; count: IntPtr; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawArraysIBM_ovr_8(mode[0], first, count, primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(var mode: PrimitiveType; first: array of Int32; count: array of Int32; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawArraysIBM_ovr_0(mode, first[0], count[0], primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(var mode: PrimitiveType; first: array of Int32; var count: Int32; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawArraysIBM_ovr_0(mode, first[0], count, primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(var mode: PrimitiveType; first: array of Int32; count: IntPtr; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawArraysIBM_ovr_2(mode, first[0], count, primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(var mode: PrimitiveType; var first: Int32; count: array of Int32; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawArraysIBM_ovr_0(mode, first, count[0], primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(var mode: PrimitiveType; var first: Int32; var count: Int32; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawArraysIBM_ovr_0(mode, first, count, primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(var mode: PrimitiveType; var first: Int32; count: IntPtr; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawArraysIBM_ovr_2(mode, first, count, primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(var mode: PrimitiveType; first: IntPtr; count: array of Int32; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawArraysIBM_ovr_6(mode, first, count[0], primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(var mode: PrimitiveType; first: IntPtr; var count: Int32; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawArraysIBM_ovr_6(mode, first, count, primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(var mode: PrimitiveType; first: IntPtr; count: IntPtr; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawArraysIBM_ovr_8(mode, first, count, primcount, modestride);
end;
public z_MultiModeDrawArraysIBM_ovr_18 := GetFuncOrNil&<procedure(mode: IntPtr; var first: Int32; var count: Int32; primcount: Int32; modestride: Int32)>(z_MultiModeDrawArraysIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: IntPtr; first: array of Int32; count: array of Int32; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawArraysIBM_ovr_18(mode, first[0], count[0], primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: IntPtr; first: array of Int32; var count: Int32; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawArraysIBM_ovr_18(mode, first[0], count, primcount, modestride);
end;
public z_MultiModeDrawArraysIBM_ovr_20 := GetFuncOrNil&<procedure(mode: IntPtr; var first: Int32; count: IntPtr; primcount: Int32; modestride: Int32)>(z_MultiModeDrawArraysIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: IntPtr; first: array of Int32; count: IntPtr; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawArraysIBM_ovr_20(mode, first[0], count, primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: IntPtr; var first: Int32; count: array of Int32; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawArraysIBM_ovr_18(mode, first, count[0], primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: IntPtr; var first: Int32; var count: Int32; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawArraysIBM_ovr_18(mode, first, count, primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: IntPtr; var first: Int32; count: IntPtr; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawArraysIBM_ovr_20(mode, first, count, primcount, modestride);
end;
public z_MultiModeDrawArraysIBM_ovr_24 := GetFuncOrNil&<procedure(mode: IntPtr; first: IntPtr; var count: Int32; primcount: Int32; modestride: Int32)>(z_MultiModeDrawArraysIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: IntPtr; first: IntPtr; count: array of Int32; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawArraysIBM_ovr_24(mode, first, count[0], primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: IntPtr; first: IntPtr; var count: Int32; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawArraysIBM_ovr_24(mode, first, count, primcount, modestride);
end;
public z_MultiModeDrawArraysIBM_ovr_26 := GetFuncOrNil&<procedure(mode: IntPtr; first: IntPtr; count: IntPtr; primcount: Int32; modestride: Int32)>(z_MultiModeDrawArraysIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawArraysIBM(mode: IntPtr; first: IntPtr; count: IntPtr; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawArraysIBM_ovr_26(mode, first, count, primcount, modestride);
end;
public z_MultiModeDrawElementsIBM_adr := GetFuncAdr('glMultiModeDrawElementsIBM');
public z_MultiModeDrawElementsIBM_ovr_0 := GetFuncOrNil&<procedure(var mode: PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32)>(z_MultiModeDrawElementsIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: array of PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: array of IntPtr; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawElementsIBM_ovr_0(mode[0], count[0], &type, indices[0], primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: array of PrimitiveType; count: array of Int32; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawElementsIBM_ovr_0(mode[0], count[0], &type, indices, primcount, modestride);
end;
public z_MultiModeDrawElementsIBM_ovr_2 := GetFuncOrNil&<procedure(var mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32)>(z_MultiModeDrawElementsIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: array of PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawElementsIBM_ovr_2(mode[0], count[0], &type, indices, primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: array of PrimitiveType; var count: Int32; &type: DrawElementsType; indices: array of IntPtr; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawElementsIBM_ovr_0(mode[0], count, &type, indices[0], primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: array of PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawElementsIBM_ovr_0(mode[0], count, &type, indices, primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: array of PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawElementsIBM_ovr_2(mode[0], count, &type, indices, primcount, modestride);
end;
public z_MultiModeDrawElementsIBM_ovr_6 := GetFuncOrNil&<procedure(var mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32)>(z_MultiModeDrawElementsIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: array of PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: array of IntPtr; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawElementsIBM_ovr_6(mode[0], count, &type, indices[0], primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: array of PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawElementsIBM_ovr_6(mode[0], count, &type, indices, primcount, modestride);
end;
public z_MultiModeDrawElementsIBM_ovr_8 := GetFuncOrNil&<procedure(var mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32)>(z_MultiModeDrawElementsIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: array of PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawElementsIBM_ovr_8(mode[0], count, &type, indices, primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(var mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: array of IntPtr; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawElementsIBM_ovr_0(mode, count[0], &type, indices[0], primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(var mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawElementsIBM_ovr_0(mode, count[0], &type, indices, primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(var mode: PrimitiveType; count: array of Int32; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawElementsIBM_ovr_2(mode, count[0], &type, indices, primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(var mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: array of IntPtr; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawElementsIBM_ovr_0(mode, count, &type, indices[0], primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(var mode: PrimitiveType; var count: Int32; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawElementsIBM_ovr_0(mode, count, &type, indices, primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(var mode: PrimitiveType; var count: Int32; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawElementsIBM_ovr_2(mode, count, &type, indices, primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(var mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: array of IntPtr; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawElementsIBM_ovr_6(mode, count, &type, indices[0], primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(var mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawElementsIBM_ovr_6(mode, count, &type, indices, primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(var mode: PrimitiveType; count: IntPtr; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawElementsIBM_ovr_8(mode, count, &type, indices, primcount, modestride);
end;
public z_MultiModeDrawElementsIBM_ovr_18 := GetFuncOrNil&<procedure(mode: IntPtr; var count: Int32; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32)>(z_MultiModeDrawElementsIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: IntPtr; count: array of Int32; &type: DrawElementsType; indices: array of IntPtr; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawElementsIBM_ovr_18(mode, count[0], &type, indices[0], primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: IntPtr; count: array of Int32; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawElementsIBM_ovr_18(mode, count[0], &type, indices, primcount, modestride);
end;
public z_MultiModeDrawElementsIBM_ovr_20 := GetFuncOrNil&<procedure(mode: IntPtr; var count: Int32; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32)>(z_MultiModeDrawElementsIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: IntPtr; count: array of Int32; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawElementsIBM_ovr_20(mode, count[0], &type, indices, primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: IntPtr; var count: Int32; &type: DrawElementsType; indices: array of IntPtr; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawElementsIBM_ovr_18(mode, count, &type, indices[0], primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: IntPtr; var count: Int32; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawElementsIBM_ovr_18(mode, count, &type, indices, primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: IntPtr; var count: Int32; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawElementsIBM_ovr_20(mode, count, &type, indices, primcount, modestride);
end;
public z_MultiModeDrawElementsIBM_ovr_24 := GetFuncOrNil&<procedure(mode: IntPtr; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32)>(z_MultiModeDrawElementsIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: IntPtr; count: IntPtr; &type: DrawElementsType; indices: array of IntPtr; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawElementsIBM_ovr_24(mode, count, &type, indices[0], primcount, modestride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: IntPtr; count: IntPtr; &type: DrawElementsType; var indices: IntPtr; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawElementsIBM_ovr_24(mode, count, &type, indices, primcount, modestride);
end;
public z_MultiModeDrawElementsIBM_ovr_26 := GetFuncOrNil&<procedure(mode: IntPtr; count: IntPtr; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32)>(z_MultiModeDrawElementsIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiModeDrawElementsIBM(mode: IntPtr; count: IntPtr; &type: DrawElementsType; indices: pointer; primcount: Int32; modestride: Int32);
begin
z_MultiModeDrawElementsIBM_ovr_26(mode, count, &type, indices, primcount, modestride);
end;
end;
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);
public z_FlushStaticDataIBM_adr := GetFuncAdr('glFlushStaticDataIBM');
public z_FlushStaticDataIBM_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum)>(z_FlushStaticDataIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FlushStaticDataIBM(target: DummyEnum);
begin
z_FlushStaticDataIBM_ovr_0(target);
end;
end;
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);
public z_ColorPointerListIBM_adr := GetFuncAdr('glColorPointerListIBM');
public z_ColorPointerListIBM_ovr_0 := GetFuncOrNil&<procedure(size: Int32; &type: ColorPointerType; stride: Int32; var _pointer: IntPtr; ptrstride: Int32)>(z_ColorPointerListIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorPointerListIBM(size: Int32; &type: ColorPointerType; stride: Int32; _pointer: array of IntPtr; ptrstride: Int32);
begin
z_ColorPointerListIBM_ovr_0(size, &type, stride, _pointer[0], ptrstride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorPointerListIBM(size: Int32; &type: ColorPointerType; stride: Int32; var _pointer: IntPtr; ptrstride: Int32);
begin
z_ColorPointerListIBM_ovr_0(size, &type, stride, _pointer, ptrstride);
end;
public z_ColorPointerListIBM_ovr_2 := GetFuncOrNil&<procedure(size: Int32; &type: ColorPointerType; stride: Int32; _pointer: pointer; ptrstride: Int32)>(z_ColorPointerListIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorPointerListIBM(size: Int32; &type: ColorPointerType; stride: Int32; _pointer: pointer; ptrstride: Int32);
begin
z_ColorPointerListIBM_ovr_2(size, &type, stride, _pointer, ptrstride);
end;
public z_SecondaryColorPointerListIBM_adr := GetFuncAdr('glSecondaryColorPointerListIBM');
public z_SecondaryColorPointerListIBM_ovr_0 := GetFuncOrNil&<procedure(size: Int32; &type: SecondaryColorPointerTypeIBM; stride: Int32; var _pointer: IntPtr; ptrstride: Int32)>(z_SecondaryColorPointerListIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColorPointerListIBM(size: Int32; &type: SecondaryColorPointerTypeIBM; stride: Int32; _pointer: array of IntPtr; ptrstride: Int32);
begin
z_SecondaryColorPointerListIBM_ovr_0(size, &type, stride, _pointer[0], ptrstride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColorPointerListIBM(size: Int32; &type: SecondaryColorPointerTypeIBM; stride: Int32; var _pointer: IntPtr; ptrstride: Int32);
begin
z_SecondaryColorPointerListIBM_ovr_0(size, &type, stride, _pointer, ptrstride);
end;
public z_SecondaryColorPointerListIBM_ovr_2 := GetFuncOrNil&<procedure(size: Int32; &type: SecondaryColorPointerTypeIBM; stride: Int32; _pointer: pointer; ptrstride: Int32)>(z_SecondaryColorPointerListIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColorPointerListIBM(size: Int32; &type: SecondaryColorPointerTypeIBM; stride: Int32; _pointer: pointer; ptrstride: Int32);
begin
z_SecondaryColorPointerListIBM_ovr_2(size, &type, stride, _pointer, ptrstride);
end;
public z_EdgeFlagPointerListIBM_adr := GetFuncAdr('glEdgeFlagPointerListIBM');
public z_EdgeFlagPointerListIBM_ovr_0 := GetFuncOrNil&<procedure(stride: Int32; var pointer: IntPtr; ptrstride: Int32)>(z_EdgeFlagPointerListIBM_adr);
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
var l := sizeof(Byte)*arr_el1.Length;
Result := Marshal.AllocHGlobal(l);
Marshal.Copy(arr_el1,0,Result,l);
end);
z_EdgeFlagPointerListIBM_ovr_0(stride, par_2_temp_arr1[0], ptrstride);
foreach var arr_el1 in par_2_temp_arr1 do Marshal.FreeHGlobal(arr_el1);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EdgeFlagPointerListIBM(stride: Int32; pointer: array of IntPtr; ptrstride: Int32);
begin
z_EdgeFlagPointerListIBM_ovr_0(stride, pointer[0], ptrstride);
end;
public z_EdgeFlagPointerListIBM_ovr_2 := GetFuncOrNil&<procedure(stride: Int32; pointer: IntPtr; ptrstride: Int32)>(z_EdgeFlagPointerListIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EdgeFlagPointerListIBM(stride: Int32; pointer: IntPtr; ptrstride: Int32);
begin
z_EdgeFlagPointerListIBM_ovr_2(stride, pointer, ptrstride);
end;
public z_FogCoordPointerListIBM_adr := GetFuncAdr('glFogCoordPointerListIBM');
public z_FogCoordPointerListIBM_ovr_0 := GetFuncOrNil&<procedure(&type: FogPointerTypeIBM; stride: Int32; var _pointer: IntPtr; ptrstride: Int32)>(z_FogCoordPointerListIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordPointerListIBM(&type: FogPointerTypeIBM; stride: Int32; _pointer: array of IntPtr; ptrstride: Int32);
begin
z_FogCoordPointerListIBM_ovr_0(&type, stride, _pointer[0], ptrstride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordPointerListIBM(&type: FogPointerTypeIBM; stride: Int32; var _pointer: IntPtr; ptrstride: Int32);
begin
z_FogCoordPointerListIBM_ovr_0(&type, stride, _pointer, ptrstride);
end;
public z_FogCoordPointerListIBM_ovr_2 := GetFuncOrNil&<procedure(&type: FogPointerTypeIBM; stride: Int32; _pointer: pointer; ptrstride: Int32)>(z_FogCoordPointerListIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordPointerListIBM(&type: FogPointerTypeIBM; stride: Int32; _pointer: pointer; ptrstride: Int32);
begin
z_FogCoordPointerListIBM_ovr_2(&type, stride, _pointer, ptrstride);
end;
public z_IndexPointerListIBM_adr := GetFuncAdr('glIndexPointerListIBM');
public z_IndexPointerListIBM_ovr_0 := GetFuncOrNil&<procedure(&type: IndexPointerType; stride: Int32; var _pointer: IntPtr; ptrstride: Int32)>(z_IndexPointerListIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IndexPointerListIBM(&type: IndexPointerType; stride: Int32; _pointer: array of IntPtr; ptrstride: Int32);
begin
z_IndexPointerListIBM_ovr_0(&type, stride, _pointer[0], ptrstride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IndexPointerListIBM(&type: IndexPointerType; stride: Int32; var _pointer: IntPtr; ptrstride: Int32);
begin
z_IndexPointerListIBM_ovr_0(&type, stride, _pointer, ptrstride);
end;
public z_IndexPointerListIBM_ovr_2 := GetFuncOrNil&<procedure(&type: IndexPointerType; stride: Int32; _pointer: pointer; ptrstride: Int32)>(z_IndexPointerListIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IndexPointerListIBM(&type: IndexPointerType; stride: Int32; _pointer: pointer; ptrstride: Int32);
begin
z_IndexPointerListIBM_ovr_2(&type, stride, _pointer, ptrstride);
end;
public z_NormalPointerListIBM_adr := GetFuncAdr('glNormalPointerListIBM');
public z_NormalPointerListIBM_ovr_0 := GetFuncOrNil&<procedure(&type: NormalPointerType; stride: Int32; var _pointer: IntPtr; ptrstride: Int32)>(z_NormalPointerListIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalPointerListIBM(&type: NormalPointerType; stride: Int32; _pointer: array of IntPtr; ptrstride: Int32);
begin
z_NormalPointerListIBM_ovr_0(&type, stride, _pointer[0], ptrstride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalPointerListIBM(&type: NormalPointerType; stride: Int32; var _pointer: IntPtr; ptrstride: Int32);
begin
z_NormalPointerListIBM_ovr_0(&type, stride, _pointer, ptrstride);
end;
public z_NormalPointerListIBM_ovr_2 := GetFuncOrNil&<procedure(&type: NormalPointerType; stride: Int32; _pointer: pointer; ptrstride: Int32)>(z_NormalPointerListIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalPointerListIBM(&type: NormalPointerType; stride: Int32; _pointer: pointer; ptrstride: Int32);
begin
z_NormalPointerListIBM_ovr_2(&type, stride, _pointer, ptrstride);
end;
public z_TexCoordPointerListIBM_adr := GetFuncAdr('glTexCoordPointerListIBM');
public z_TexCoordPointerListIBM_ovr_0 := GetFuncOrNil&<procedure(size: Int32; &type: TexCoordPointerType; stride: Int32; var _pointer: IntPtr; ptrstride: Int32)>(z_TexCoordPointerListIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordPointerListIBM(size: Int32; &type: TexCoordPointerType; stride: Int32; _pointer: array of IntPtr; ptrstride: Int32);
begin
z_TexCoordPointerListIBM_ovr_0(size, &type, stride, _pointer[0], ptrstride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordPointerListIBM(size: Int32; &type: TexCoordPointerType; stride: Int32; var _pointer: IntPtr; ptrstride: Int32);
begin
z_TexCoordPointerListIBM_ovr_0(size, &type, stride, _pointer, ptrstride);
end;
public z_TexCoordPointerListIBM_ovr_2 := GetFuncOrNil&<procedure(size: Int32; &type: TexCoordPointerType; stride: Int32; _pointer: pointer; ptrstride: Int32)>(z_TexCoordPointerListIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordPointerListIBM(size: Int32; &type: TexCoordPointerType; stride: Int32; _pointer: pointer; ptrstride: Int32);
begin
z_TexCoordPointerListIBM_ovr_2(size, &type, stride, _pointer, ptrstride);
end;
public z_VertexPointerListIBM_adr := GetFuncAdr('glVertexPointerListIBM');
public z_VertexPointerListIBM_ovr_0 := GetFuncOrNil&<procedure(size: Int32; &type: VertexPointerType; stride: Int32; var _pointer: IntPtr; ptrstride: Int32)>(z_VertexPointerListIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexPointerListIBM(size: Int32; &type: VertexPointerType; stride: Int32; _pointer: array of IntPtr; ptrstride: Int32);
begin
z_VertexPointerListIBM_ovr_0(size, &type, stride, _pointer[0], ptrstride);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexPointerListIBM(size: Int32; &type: VertexPointerType; stride: Int32; var _pointer: IntPtr; ptrstride: Int32);
begin
z_VertexPointerListIBM_ovr_0(size, &type, stride, _pointer, ptrstride);
end;
public z_VertexPointerListIBM_ovr_2 := GetFuncOrNil&<procedure(size: Int32; &type: VertexPointerType; stride: Int32; _pointer: pointer; ptrstride: Int32)>(z_VertexPointerListIBM_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexPointerListIBM(size: Int32; &type: VertexPointerType; stride: Int32; _pointer: pointer; ptrstride: Int32);
begin
z_VertexPointerListIBM_ovr_2(size, &type, stride, _pointer, ptrstride);
end;
end;
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);
public z_BlendFuncSeparateINGR_adr := GetFuncAdr('glBlendFuncSeparateINGR');
public z_BlendFuncSeparateINGR_ovr_0 := GetFuncOrNil&<procedure(sfactorRGB: BlendingFactor; dfactorRGB: BlendingFactor; sfactorAlpha: BlendingFactor; dfactorAlpha: BlendingFactor)>(z_BlendFuncSeparateINGR_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendFuncSeparateINGR(sfactorRGB: BlendingFactor; dfactorRGB: BlendingFactor; sfactorAlpha: BlendingFactor; dfactorAlpha: BlendingFactor);
begin
z_BlendFuncSeparateINGR_ovr_0(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
end;
end;
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);
public z_ApplyFramebufferAttachmentCMAAINTEL_adr := GetFuncAdr('glApplyFramebufferAttachmentCMAAINTEL');
public z_ApplyFramebufferAttachmentCMAAINTEL_ovr_0 := GetFuncOrNil&<procedure>(z_ApplyFramebufferAttachmentCMAAINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ApplyFramebufferAttachmentCMAAINTEL;
begin
z_ApplyFramebufferAttachmentCMAAINTEL_ovr_0;
end;
end;
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);
public z_SyncTextureINTEL_adr := GetFuncAdr('glSyncTextureINTEL');
public z_SyncTextureINTEL_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32)>(z_SyncTextureINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SyncTextureINTEL(texture: UInt32);
begin
z_SyncTextureINTEL_ovr_0(texture);
end;
public z_UnmapTexture2DINTEL_adr := GetFuncAdr('glUnmapTexture2DINTEL');
public z_UnmapTexture2DINTEL_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; level: Int32)>(z_UnmapTexture2DINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UnmapTexture2DINTEL(texture: UInt32; level: Int32);
begin
z_UnmapTexture2DINTEL_ovr_0(texture, level);
end;
public z_MapTexture2DINTEL_adr := GetFuncAdr('glMapTexture2DINTEL');
public z_MapTexture2DINTEL_ovr_0 := GetFuncOrNil&<function(texture: UInt32; level: Int32; access: DummyFlags; var stride: Int32; var layout: DummyEnum): IntPtr>(z_MapTexture2DINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapTexture2DINTEL(texture: UInt32; level: Int32; access: DummyFlags; stride: array of Int32; layout: array of DummyEnum): IntPtr;
begin
Result := z_MapTexture2DINTEL_ovr_0(texture, level, access, stride[0], layout[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapTexture2DINTEL(texture: UInt32; level: Int32; access: DummyFlags; stride: array of Int32; var layout: DummyEnum): IntPtr;
begin
Result := z_MapTexture2DINTEL_ovr_0(texture, level, access, stride[0], layout);
end;
public z_MapTexture2DINTEL_ovr_2 := GetFuncOrNil&<function(texture: UInt32; level: Int32; access: DummyFlags; var stride: Int32; layout: IntPtr): IntPtr>(z_MapTexture2DINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapTexture2DINTEL(texture: UInt32; level: Int32; access: DummyFlags; stride: array of Int32; layout: IntPtr): IntPtr;
begin
Result := z_MapTexture2DINTEL_ovr_2(texture, level, access, stride[0], layout);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapTexture2DINTEL(texture: UInt32; level: Int32; access: DummyFlags; var stride: Int32; layout: array of DummyEnum): IntPtr;
begin
Result := z_MapTexture2DINTEL_ovr_0(texture, level, access, stride, layout[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapTexture2DINTEL(texture: UInt32; level: Int32; access: DummyFlags; var stride: Int32; var layout: DummyEnum): IntPtr;
begin
Result := z_MapTexture2DINTEL_ovr_0(texture, level, access, stride, layout);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapTexture2DINTEL(texture: UInt32; level: Int32; access: DummyFlags; var stride: Int32; layout: IntPtr): IntPtr;
begin
Result := z_MapTexture2DINTEL_ovr_2(texture, level, access, stride, layout);
end;
public z_MapTexture2DINTEL_ovr_6 := GetFuncOrNil&<function(texture: UInt32; level: Int32; access: DummyFlags; stride: IntPtr; var layout: DummyEnum): IntPtr>(z_MapTexture2DINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapTexture2DINTEL(texture: UInt32; level: Int32; access: DummyFlags; stride: IntPtr; layout: array of DummyEnum): IntPtr;
begin
Result := z_MapTexture2DINTEL_ovr_6(texture, level, access, stride, layout[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapTexture2DINTEL(texture: UInt32; level: Int32; access: DummyFlags; stride: IntPtr; var layout: DummyEnum): IntPtr;
begin
Result := z_MapTexture2DINTEL_ovr_6(texture, level, access, stride, layout);
end;
public z_MapTexture2DINTEL_ovr_8 := GetFuncOrNil&<function(texture: UInt32; level: Int32; access: DummyFlags; stride: IntPtr; layout: IntPtr): IntPtr>(z_MapTexture2DINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapTexture2DINTEL(texture: UInt32; level: Int32; access: DummyFlags; stride: IntPtr; layout: IntPtr): IntPtr;
begin
Result := z_MapTexture2DINTEL_ovr_8(texture, level, access, stride, layout);
end;
end;
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);
public z_VertexPointervINTEL_adr := GetFuncAdr('glVertexPointervINTEL');
public z_VertexPointervINTEL_ovr_0 := GetFuncOrNil&<procedure(size: Int32; &type: VertexPointerType; var _pointer: IntPtr)>(z_VertexPointervINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexPointervINTEL(size: Int32; &type: VertexPointerType; _pointer: array of IntPtr);
begin
z_VertexPointervINTEL_ovr_0(size, &type, _pointer[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexPointervINTEL(size: Int32; &type: VertexPointerType; var _pointer: IntPtr);
begin
z_VertexPointervINTEL_ovr_0(size, &type, _pointer);
end;
public z_VertexPointervINTEL_ovr_2 := GetFuncOrNil&<procedure(size: Int32; &type: VertexPointerType; _pointer: pointer)>(z_VertexPointervINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexPointervINTEL(size: Int32; &type: VertexPointerType; _pointer: pointer);
begin
z_VertexPointervINTEL_ovr_2(size, &type, _pointer);
end;
public z_NormalPointervINTEL_adr := GetFuncAdr('glNormalPointervINTEL');
public z_NormalPointervINTEL_ovr_0 := GetFuncOrNil&<procedure(&type: NormalPointerType; var _pointer: IntPtr)>(z_NormalPointervINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalPointervINTEL(&type: NormalPointerType; _pointer: array of IntPtr);
begin
z_NormalPointervINTEL_ovr_0(&type, _pointer[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalPointervINTEL(&type: NormalPointerType; var _pointer: IntPtr);
begin
z_NormalPointervINTEL_ovr_0(&type, _pointer);
end;
public z_NormalPointervINTEL_ovr_2 := GetFuncOrNil&<procedure(&type: NormalPointerType; _pointer: pointer)>(z_NormalPointervINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalPointervINTEL(&type: NormalPointerType; _pointer: pointer);
begin
z_NormalPointervINTEL_ovr_2(&type, _pointer);
end;
public z_ColorPointervINTEL_adr := GetFuncAdr('glColorPointervINTEL');
public z_ColorPointervINTEL_ovr_0 := GetFuncOrNil&<procedure(size: Int32; &type: VertexPointerType; var _pointer: IntPtr)>(z_ColorPointervINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorPointervINTEL(size: Int32; &type: VertexPointerType; _pointer: array of IntPtr);
begin
z_ColorPointervINTEL_ovr_0(size, &type, _pointer[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorPointervINTEL(size: Int32; &type: VertexPointerType; var _pointer: IntPtr);
begin
z_ColorPointervINTEL_ovr_0(size, &type, _pointer);
end;
public z_ColorPointervINTEL_ovr_2 := GetFuncOrNil&<procedure(size: Int32; &type: VertexPointerType; _pointer: pointer)>(z_ColorPointervINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorPointervINTEL(size: Int32; &type: VertexPointerType; _pointer: pointer);
begin
z_ColorPointervINTEL_ovr_2(size, &type, _pointer);
end;
public z_TexCoordPointervINTEL_adr := GetFuncAdr('glTexCoordPointervINTEL');
public z_TexCoordPointervINTEL_ovr_0 := GetFuncOrNil&<procedure(size: Int32; &type: VertexPointerType; var _pointer: IntPtr)>(z_TexCoordPointervINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordPointervINTEL(size: Int32; &type: VertexPointerType; _pointer: array of IntPtr);
begin
z_TexCoordPointervINTEL_ovr_0(size, &type, _pointer[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordPointervINTEL(size: Int32; &type: VertexPointerType; var _pointer: IntPtr);
begin
z_TexCoordPointervINTEL_ovr_0(size, &type, _pointer);
end;
public z_TexCoordPointervINTEL_ovr_2 := GetFuncOrNil&<procedure(size: Int32; &type: VertexPointerType; _pointer: pointer)>(z_TexCoordPointervINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordPointervINTEL(size: Int32; &type: VertexPointerType; _pointer: pointer);
begin
z_TexCoordPointervINTEL_ovr_2(size, &type, _pointer);
end;
end;
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);
public z_BeginPerfQueryINTEL_adr := GetFuncAdr('glBeginPerfQueryINTEL');
public z_BeginPerfQueryINTEL_ovr_0 := GetFuncOrNil&<procedure(queryHandle: PerfQueryHandleINTEL)>(z_BeginPerfQueryINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginPerfQueryINTEL(queryHandle: PerfQueryHandleINTEL);
begin
z_BeginPerfQueryINTEL_ovr_0(queryHandle);
end;
public z_CreatePerfQueryINTEL_adr := GetFuncAdr('glCreatePerfQueryINTEL');
public z_CreatePerfQueryINTEL_ovr_0 := GetFuncOrNil&<procedure(queryId: PerfQueryIdINTEL; var queryHandle: PerfQueryHandleINTEL)>(z_CreatePerfQueryINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreatePerfQueryINTEL(queryId: PerfQueryIdINTEL; var queryHandle: PerfQueryHandleINTEL);
begin
z_CreatePerfQueryINTEL_ovr_0(queryId, queryHandle);
end;
public z_CreatePerfQueryINTEL_ovr_1 := GetFuncOrNil&<procedure(queryId: PerfQueryIdINTEL; queryHandle: IntPtr)>(z_CreatePerfQueryINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreatePerfQueryINTEL(queryId: PerfQueryIdINTEL; queryHandle: IntPtr);
begin
z_CreatePerfQueryINTEL_ovr_1(queryId, queryHandle);
end;
public z_DeletePerfQueryINTEL_adr := GetFuncAdr('glDeletePerfQueryINTEL');
public z_DeletePerfQueryINTEL_ovr_0 := GetFuncOrNil&<procedure(queryHandle: PerfQueryHandleINTEL)>(z_DeletePerfQueryINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeletePerfQueryINTEL(queryHandle: PerfQueryHandleINTEL);
begin
z_DeletePerfQueryINTEL_ovr_0(queryHandle);
end;
public z_EndPerfQueryINTEL_adr := GetFuncAdr('glEndPerfQueryINTEL');
public z_EndPerfQueryINTEL_ovr_0 := GetFuncOrNil&<procedure(queryHandle: PerfQueryHandleINTEL)>(z_EndPerfQueryINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndPerfQueryINTEL(queryHandle: PerfQueryHandleINTEL);
begin
z_EndPerfQueryINTEL_ovr_0(queryHandle);
end;
public z_GetFirstPerfQueryIdINTEL_adr := GetFuncAdr('glGetFirstPerfQueryIdINTEL');
public z_GetFirstPerfQueryIdINTEL_ovr_0 := GetFuncOrNil&<procedure(var queryId: PerfQueryIdINTEL)>(z_GetFirstPerfQueryIdINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFirstPerfQueryIdINTEL(var queryId: PerfQueryIdINTEL);
begin
z_GetFirstPerfQueryIdINTEL_ovr_0(queryId);
end;
public z_GetFirstPerfQueryIdINTEL_ovr_1 := GetFuncOrNil&<procedure(queryId: IntPtr)>(z_GetFirstPerfQueryIdINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFirstPerfQueryIdINTEL(queryId: IntPtr);
begin
z_GetFirstPerfQueryIdINTEL_ovr_1(queryId);
end;
public z_GetNextPerfQueryIdINTEL_adr := GetFuncAdr('glGetNextPerfQueryIdINTEL');
public z_GetNextPerfQueryIdINTEL_ovr_0 := GetFuncOrNil&<procedure(queryId: PerfQueryIdINTEL; nextQueryId: PerfQueryIdINTEL)>(z_GetNextPerfQueryIdINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNextPerfQueryIdINTEL(queryId: PerfQueryIdINTEL; nextQueryId: PerfQueryIdINTEL);
begin
z_GetNextPerfQueryIdINTEL_ovr_0(queryId, nextQueryId);
end;
public z_GetNextPerfQueryIdINTEL_ovr_1 := GetFuncOrNil&<procedure(queryId: PerfQueryIdINTEL; nextQueryId: IntPtr)>(z_GetNextPerfQueryIdINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNextPerfQueryIdINTEL(queryId: PerfQueryIdINTEL; nextQueryId: IntPtr);
begin
z_GetNextPerfQueryIdINTEL_ovr_1(queryId, nextQueryId);
end;
public z_GetPerfCounterInfoINTEL_adr := GetFuncAdr('glGetPerfCounterInfoINTEL');
public z_GetPerfCounterInfoINTEL_ovr_0 := GetFuncOrNil&<procedure(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_adr);
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);
begin
z_GetPerfCounterInfoINTEL_ovr_0(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue);
end;
public z_GetPerfCounterInfoINTEL_ovr_1 := GetFuncOrNil&<procedure(queryId: PerfQueryIdINTEL; counterId: UInt32; counterNameLength: UInt32; counterName: IntPtr; counterDescLength: UInt32; counterDesc: IntPtr; counterOffset: IntPtr; counterDataSize: IntPtr; counterTypeEnum: IntPtr; counterDataTypeEnum: IntPtr; rawCounterMaxValue: IntPtr)>(z_GetPerfCounterInfoINTEL_adr);
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);
begin
z_GetPerfCounterInfoINTEL_ovr_1(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue);
end;
public z_GetPerfQueryDataINTEL_adr := GetFuncAdr('glGetPerfQueryDataINTEL');
public z_GetPerfQueryDataINTEL_ovr_0 := GetFuncOrNil&<procedure(queryHandle: PerfQueryHandleINTEL; flags: PerfQueryDataFlagsINTEL; dataSize: Int32; data: IntPtr; var bytesWritten: UInt32)>(z_GetPerfQueryDataINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfQueryDataINTEL(queryHandle: PerfQueryHandleINTEL; flags: PerfQueryDataFlagsINTEL; dataSize: Int32; data: IntPtr; var bytesWritten: UInt32);
begin
z_GetPerfQueryDataINTEL_ovr_0(queryHandle, flags, dataSize, data, bytesWritten);
end;
public z_GetPerfQueryDataINTEL_ovr_1 := GetFuncOrNil&<procedure(queryHandle: PerfQueryHandleINTEL; flags: PerfQueryDataFlagsINTEL; dataSize: Int32; data: IntPtr; bytesWritten: IntPtr)>(z_GetPerfQueryDataINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfQueryDataINTEL(queryHandle: PerfQueryHandleINTEL; flags: PerfQueryDataFlagsINTEL; dataSize: Int32; data: IntPtr; bytesWritten: IntPtr);
begin
z_GetPerfQueryDataINTEL_ovr_1(queryHandle, flags, dataSize, data, bytesWritten);
end;
public z_GetPerfQueryIdByNameINTEL_adr := GetFuncAdr('glGetPerfQueryIdByNameINTEL');
public z_GetPerfQueryIdByNameINTEL_ovr_0 := GetFuncOrNil&<procedure(queryName: IntPtr; var queryId: PerfQueryIdINTEL)>(z_GetPerfQueryIdByNameINTEL_adr);
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;
public z_GetPerfQueryIdByNameINTEL_ovr_1 := GetFuncOrNil&<procedure(queryName: IntPtr; queryId: IntPtr)>(z_GetPerfQueryIdByNameINTEL_adr);
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);
begin
z_GetPerfQueryIdByNameINTEL_ovr_0(queryName, queryId);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfQueryIdByNameINTEL(queryName: IntPtr; queryId: IntPtr);
begin
z_GetPerfQueryIdByNameINTEL_ovr_1(queryName, queryId);
end;
public z_GetPerfQueryInfoINTEL_adr := GetFuncAdr('glGetPerfQueryInfoINTEL');
public z_GetPerfQueryInfoINTEL_ovr_0 := GetFuncOrNil&<procedure(queryId: PerfQueryIdINTEL; queryNameLength: UInt32; queryName: IntPtr; var dataSize: UInt32; var noCounters: UInt32; var noInstances: UInt32; var capsMask: PerfQueryCapFlagsINTEL)>(z_GetPerfQueryInfoINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfQueryInfoINTEL(queryId: PerfQueryIdINTEL; queryNameLength: UInt32; queryName: IntPtr; var dataSize: UInt32; var noCounters: UInt32; var noInstances: UInt32; var capsMask: PerfQueryCapFlagsINTEL);
begin
z_GetPerfQueryInfoINTEL_ovr_0(queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, capsMask);
end;
public z_GetPerfQueryInfoINTEL_ovr_1 := GetFuncOrNil&<procedure(queryId: PerfQueryIdINTEL; queryNameLength: UInt32; queryName: IntPtr; dataSize: IntPtr; noCounters: IntPtr; noInstances: IntPtr; var capsMask: PerfQueryCapFlagsINTEL)>(z_GetPerfQueryInfoINTEL_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPerfQueryInfoINTEL(queryId: PerfQueryIdINTEL; queryNameLength: UInt32; queryName: IntPtr; dataSize: IntPtr; noCounters: IntPtr; noInstances: IntPtr; var capsMask: PerfQueryCapFlagsINTEL);
begin
z_GetPerfQueryInfoINTEL_ovr_1(queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, capsMask);
end;
end;
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);
public z_BlendBarrierKHR_adr := GetFuncAdr('glBlendBarrierKHR');
public z_BlendBarrierKHR_ovr_0 := GetFuncOrNil&<procedure>(z_BlendBarrierKHR_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendBarrierKHR;
begin
z_BlendBarrierKHR_ovr_0;
end;
end;
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);
end;
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);
end;
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);
public z_MaxShaderCompilerThreadsKHR_adr := GetFuncAdr('glMaxShaderCompilerThreadsKHR');
public z_MaxShaderCompilerThreadsKHR_ovr_0 := GetFuncOrNil&<procedure(count: UInt32)>(z_MaxShaderCompilerThreadsKHR_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MaxShaderCompilerThreadsKHR(count: UInt32);
begin
z_MaxShaderCompilerThreadsKHR_ovr_0(count);
end;
end;
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);
public z_FramebufferParameteriMESA_adr := GetFuncAdr('glFramebufferParameteriMESA');
public z_FramebufferParameteriMESA_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; pname: FramebufferParameterName; param: Int32)>(z_FramebufferParameteriMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferParameteriMESA(target: FramebufferTarget; pname: FramebufferParameterName; param: Int32);
begin
z_FramebufferParameteriMESA_ovr_0(target, pname, param);
end;
public z_GetFramebufferParameterivMESA_adr := GetFuncAdr('glGetFramebufferParameterivMESA');
public z_GetFramebufferParameterivMESA_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; var ¶ms: Int32)>(z_GetFramebufferParameterivMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferParameterivMESA(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; ¶ms: array of Int32);
begin
z_GetFramebufferParameterivMESA_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferParameterivMESA(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; var ¶ms: Int32);
begin
z_GetFramebufferParameterivMESA_ovr_0(target, pname, ¶ms);
end;
public z_GetFramebufferParameterivMESA_ovr_2 := GetFuncOrNil&<procedure(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr)>(z_GetFramebufferParameterivMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFramebufferParameterivMESA(target: FramebufferTarget; pname: FramebufferAttachmentParameterName; ¶ms: IntPtr);
begin
z_GetFramebufferParameterivMESA_ovr_2(target, pname, ¶ms);
end;
end;
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);
public z_ResizeBuffersMESA_adr := GetFuncAdr('glResizeBuffersMESA');
public z_ResizeBuffersMESA_ovr_0 := GetFuncOrNil&<procedure>(z_ResizeBuffersMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ResizeBuffersMESA;
begin
z_ResizeBuffersMESA_ovr_0;
end;
end;
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);
public z_WindowPos2dMESA_adr := GetFuncAdr('glWindowPos2dMESA');
public z_WindowPos2dMESA_ovr_0 := GetFuncOrNil&<procedure(x: real; y: real)>(z_WindowPos2dMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2dMESA(x: real; y: real);
begin
z_WindowPos2dMESA_ovr_0(x, y);
end;
public z_WindowPos2dvMESA_adr := GetFuncAdr('glWindowPos2dvMESA');
public z_WindowPos2dvMESA_ovr_0 := GetFuncOrNil&<procedure(var v: real)>(z_WindowPos2dvMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2dvMESA(v: array of real);
begin
z_WindowPos2dvMESA_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2dvMESA(var v: real);
begin
z_WindowPos2dvMESA_ovr_0(v);
end;
public z_WindowPos2dvMESA_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos2dvMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2dvMESA(v: IntPtr);
begin
z_WindowPos2dvMESA_ovr_2(v);
end;
public z_WindowPos2fMESA_adr := GetFuncAdr('glWindowPos2fMESA');
public z_WindowPos2fMESA_ovr_0 := GetFuncOrNil&<procedure(x: single; y: single)>(z_WindowPos2fMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2fMESA(x: single; y: single);
begin
z_WindowPos2fMESA_ovr_0(x, y);
end;
public z_WindowPos2fvMESA_adr := GetFuncAdr('glWindowPos2fvMESA');
public z_WindowPos2fvMESA_ovr_0 := GetFuncOrNil&<procedure(var v: single)>(z_WindowPos2fvMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2fvMESA(v: array of single);
begin
z_WindowPos2fvMESA_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2fvMESA(var v: single);
begin
z_WindowPos2fvMESA_ovr_0(v);
end;
public z_WindowPos2fvMESA_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos2fvMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2fvMESA(v: IntPtr);
begin
z_WindowPos2fvMESA_ovr_2(v);
end;
public z_WindowPos2iMESA_adr := GetFuncAdr('glWindowPos2iMESA');
public z_WindowPos2iMESA_ovr_0 := GetFuncOrNil&<procedure(x: Int32; y: Int32)>(z_WindowPos2iMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2iMESA(x: Int32; y: Int32);
begin
z_WindowPos2iMESA_ovr_0(x, y);
end;
public z_WindowPos2ivMESA_adr := GetFuncAdr('glWindowPos2ivMESA');
public z_WindowPos2ivMESA_ovr_0 := GetFuncOrNil&<procedure(var v: Int32)>(z_WindowPos2ivMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2ivMESA(v: array of Int32);
begin
z_WindowPos2ivMESA_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2ivMESA(var v: Int32);
begin
z_WindowPos2ivMESA_ovr_0(v);
end;
public z_WindowPos2ivMESA_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos2ivMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2ivMESA(v: IntPtr);
begin
z_WindowPos2ivMESA_ovr_2(v);
end;
public z_WindowPos2sMESA_adr := GetFuncAdr('glWindowPos2sMESA');
public z_WindowPos2sMESA_ovr_0 := GetFuncOrNil&<procedure(x: Int16; y: Int16)>(z_WindowPos2sMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2sMESA(x: Int16; y: Int16);
begin
z_WindowPos2sMESA_ovr_0(x, y);
end;
public z_WindowPos2svMESA_adr := GetFuncAdr('glWindowPos2svMESA');
public z_WindowPos2svMESA_ovr_0 := GetFuncOrNil&<procedure(var v: Int16)>(z_WindowPos2svMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2svMESA(v: array of Int16);
begin
z_WindowPos2svMESA_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2svMESA(var v: Int16);
begin
z_WindowPos2svMESA_ovr_0(v);
end;
public z_WindowPos2svMESA_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos2svMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos2svMESA(v: IntPtr);
begin
z_WindowPos2svMESA_ovr_2(v);
end;
public z_WindowPos3dMESA_adr := GetFuncAdr('glWindowPos3dMESA');
public z_WindowPos3dMESA_ovr_0 := GetFuncOrNil&<procedure(x: real; y: real; z: real)>(z_WindowPos3dMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3dMESA(x: real; y: real; z: real);
begin
z_WindowPos3dMESA_ovr_0(x, y, z);
end;
public z_WindowPos3dvMESA_adr := GetFuncAdr('glWindowPos3dvMESA');
public z_WindowPos3dvMESA_ovr_0 := GetFuncOrNil&<procedure(var v: real)>(z_WindowPos3dvMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3dvMESA(v: array of real);
begin
z_WindowPos3dvMESA_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3dvMESA(var v: real);
begin
z_WindowPos3dvMESA_ovr_0(v);
end;
public z_WindowPos3dvMESA_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos3dvMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3dvMESA(v: IntPtr);
begin
z_WindowPos3dvMESA_ovr_2(v);
end;
public z_WindowPos3fMESA_adr := GetFuncAdr('glWindowPos3fMESA');
public z_WindowPos3fMESA_ovr_0 := GetFuncOrNil&<procedure(x: single; y: single; z: single)>(z_WindowPos3fMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3fMESA(x: single; y: single; z: single);
begin
z_WindowPos3fMESA_ovr_0(x, y, z);
end;
public z_WindowPos3fvMESA_adr := GetFuncAdr('glWindowPos3fvMESA');
public z_WindowPos3fvMESA_ovr_0 := GetFuncOrNil&<procedure(var v: single)>(z_WindowPos3fvMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3fvMESA(v: array of single);
begin
z_WindowPos3fvMESA_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3fvMESA(var v: single);
begin
z_WindowPos3fvMESA_ovr_0(v);
end;
public z_WindowPos3fvMESA_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos3fvMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3fvMESA(v: IntPtr);
begin
z_WindowPos3fvMESA_ovr_2(v);
end;
public z_WindowPos3iMESA_adr := GetFuncAdr('glWindowPos3iMESA');
public z_WindowPos3iMESA_ovr_0 := GetFuncOrNil&<procedure(x: Int32; y: Int32; z: Int32)>(z_WindowPos3iMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3iMESA(x: Int32; y: Int32; z: Int32);
begin
z_WindowPos3iMESA_ovr_0(x, y, z);
end;
public z_WindowPos3ivMESA_adr := GetFuncAdr('glWindowPos3ivMESA');
public z_WindowPos3ivMESA_ovr_0 := GetFuncOrNil&<procedure(var v: Int32)>(z_WindowPos3ivMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3ivMESA(v: array of Int32);
begin
z_WindowPos3ivMESA_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3ivMESA(var v: Int32);
begin
z_WindowPos3ivMESA_ovr_0(v);
end;
public z_WindowPos3ivMESA_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos3ivMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3ivMESA(v: IntPtr);
begin
z_WindowPos3ivMESA_ovr_2(v);
end;
public z_WindowPos3sMESA_adr := GetFuncAdr('glWindowPos3sMESA');
public z_WindowPos3sMESA_ovr_0 := GetFuncOrNil&<procedure(x: Int16; y: Int16; z: Int16)>(z_WindowPos3sMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3sMESA(x: Int16; y: Int16; z: Int16);
begin
z_WindowPos3sMESA_ovr_0(x, y, z);
end;
public z_WindowPos3svMESA_adr := GetFuncAdr('glWindowPos3svMESA');
public z_WindowPos3svMESA_ovr_0 := GetFuncOrNil&<procedure(var v: Int16)>(z_WindowPos3svMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3svMESA(v: array of Int16);
begin
z_WindowPos3svMESA_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3svMESA(var v: Int16);
begin
z_WindowPos3svMESA_ovr_0(v);
end;
public z_WindowPos3svMESA_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos3svMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos3svMESA(v: IntPtr);
begin
z_WindowPos3svMESA_ovr_2(v);
end;
public z_WindowPos4dMESA_adr := GetFuncAdr('glWindowPos4dMESA');
public z_WindowPos4dMESA_ovr_0 := GetFuncOrNil&<procedure(x: real; y: real; z: real; w: real)>(z_WindowPos4dMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4dMESA(x: real; y: real; z: real; w: real);
begin
z_WindowPos4dMESA_ovr_0(x, y, z, w);
end;
public z_WindowPos4dvMESA_adr := GetFuncAdr('glWindowPos4dvMESA');
public z_WindowPos4dvMESA_ovr_0 := GetFuncOrNil&<procedure(var v: real)>(z_WindowPos4dvMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4dvMESA(v: array of real);
begin
z_WindowPos4dvMESA_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4dvMESA(var v: real);
begin
z_WindowPos4dvMESA_ovr_0(v);
end;
public z_WindowPos4dvMESA_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos4dvMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4dvMESA(v: IntPtr);
begin
z_WindowPos4dvMESA_ovr_2(v);
end;
public z_WindowPos4fMESA_adr := GetFuncAdr('glWindowPos4fMESA');
public z_WindowPos4fMESA_ovr_0 := GetFuncOrNil&<procedure(x: single; y: single; z: single; w: single)>(z_WindowPos4fMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4fMESA(x: single; y: single; z: single; w: single);
begin
z_WindowPos4fMESA_ovr_0(x, y, z, w);
end;
public z_WindowPos4fvMESA_adr := GetFuncAdr('glWindowPos4fvMESA');
public z_WindowPos4fvMESA_ovr_0 := GetFuncOrNil&<procedure(var v: single)>(z_WindowPos4fvMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4fvMESA(v: array of single);
begin
z_WindowPos4fvMESA_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4fvMESA(var v: single);
begin
z_WindowPos4fvMESA_ovr_0(v);
end;
public z_WindowPos4fvMESA_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos4fvMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4fvMESA(v: IntPtr);
begin
z_WindowPos4fvMESA_ovr_2(v);
end;
public z_WindowPos4iMESA_adr := GetFuncAdr('glWindowPos4iMESA');
public z_WindowPos4iMESA_ovr_0 := GetFuncOrNil&<procedure(x: Int32; y: Int32; z: Int32; w: Int32)>(z_WindowPos4iMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4iMESA(x: Int32; y: Int32; z: Int32; w: Int32);
begin
z_WindowPos4iMESA_ovr_0(x, y, z, w);
end;
public z_WindowPos4ivMESA_adr := GetFuncAdr('glWindowPos4ivMESA');
public z_WindowPos4ivMESA_ovr_0 := GetFuncOrNil&<procedure(var v: Int32)>(z_WindowPos4ivMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4ivMESA(v: array of Int32);
begin
z_WindowPos4ivMESA_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4ivMESA(var v: Int32);
begin
z_WindowPos4ivMESA_ovr_0(v);
end;
public z_WindowPos4ivMESA_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos4ivMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4ivMESA(v: IntPtr);
begin
z_WindowPos4ivMESA_ovr_2(v);
end;
public z_WindowPos4sMESA_adr := GetFuncAdr('glWindowPos4sMESA');
public z_WindowPos4sMESA_ovr_0 := GetFuncOrNil&<procedure(x: Int16; y: Int16; z: Int16; w: Int16)>(z_WindowPos4sMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4sMESA(x: Int16; y: Int16; z: Int16; w: Int16);
begin
z_WindowPos4sMESA_ovr_0(x, y, z, w);
end;
public z_WindowPos4svMESA_adr := GetFuncAdr('glWindowPos4svMESA');
public z_WindowPos4svMESA_ovr_0 := GetFuncOrNil&<procedure(var v: Int16)>(z_WindowPos4svMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4svMESA(v: array of Int16);
begin
z_WindowPos4svMESA_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4svMESA(var v: Int16);
begin
z_WindowPos4svMESA_ovr_0(v);
end;
public z_WindowPos4svMESA_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_WindowPos4svMESA_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WindowPos4svMESA(v: IntPtr);
begin
z_WindowPos4svMESA_ovr_2(v);
end;
end;
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);
public z_BeginConditionalRenderNVX_adr := GetFuncAdr('glBeginConditionalRenderNVX');
public z_BeginConditionalRenderNVX_ovr_0 := GetFuncOrNil&<procedure(id: UInt32)>(z_BeginConditionalRenderNVX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginConditionalRenderNVX(id: UInt32);
begin
z_BeginConditionalRenderNVX_ovr_0(id);
end;
public z_EndConditionalRenderNVX_adr := GetFuncAdr('glEndConditionalRenderNVX');
public z_EndConditionalRenderNVX_ovr_0 := GetFuncOrNil&<procedure>(z_EndConditionalRenderNVX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndConditionalRenderNVX;
begin
z_EndConditionalRenderNVX_ovr_0;
end;
end;
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);
public z_LGPUNamedBufferSubDataNVX_adr := GetFuncAdr('glLGPUNamedBufferSubDataNVX');
public z_LGPUNamedBufferSubDataNVX_ovr_0 := GetFuncOrNil&<procedure(gpuMask: DummyFlags; buffer: UInt32; offset: IntPtr; size: IntPtr; data: IntPtr)>(z_LGPUNamedBufferSubDataNVX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LGPUNamedBufferSubDataNVX(gpuMask: DummyFlags; buffer: UInt32; offset: IntPtr; size: IntPtr; data: IntPtr);
begin
z_LGPUNamedBufferSubDataNVX_ovr_0(gpuMask, buffer, offset, size, data);
end;
public z_LGPUCopyImageSubDataNVX_adr := GetFuncAdr('glLGPUCopyImageSubDataNVX');
public z_LGPUCopyImageSubDataNVX_ovr_0 := GetFuncOrNil&<procedure(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_adr);
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);
begin
z_LGPUCopyImageSubDataNVX_ovr_0(sourceGpu, destinationGpuMask, srcName, srcTarget, srcLevel, srcX, srxY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth);
end;
public z_LGPUInterlockNVX_adr := GetFuncAdr('glLGPUInterlockNVX');
public z_LGPUInterlockNVX_ovr_0 := GetFuncOrNil&<procedure>(z_LGPUInterlockNVX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LGPUInterlockNVX;
begin
z_LGPUInterlockNVX_ovr_0;
end;
end;
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);
public z_AlphaToCoverageDitherControlNV_adr := GetFuncAdr('glAlphaToCoverageDitherControlNV');
public z_AlphaToCoverageDitherControlNV_ovr_0 := GetFuncOrNil&<procedure(mode: DummyEnum)>(z_AlphaToCoverageDitherControlNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure AlphaToCoverageDitherControlNV(mode: DummyEnum);
begin
z_AlphaToCoverageDitherControlNV_ovr_0(mode);
end;
end;
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);
public z_MultiDrawArraysIndirectBindlessNV_adr := GetFuncAdr('glMultiDrawArraysIndirectBindlessNV');
public z_MultiDrawArraysIndirectBindlessNV_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; indirect: IntPtr; drawCount: Int32; stride: Int32; vertexBufferCount: Int32)>(z_MultiDrawArraysIndirectBindlessNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysIndirectBindlessNV(mode: PrimitiveType; indirect: IntPtr; drawCount: Int32; stride: Int32; vertexBufferCount: Int32);
begin
z_MultiDrawArraysIndirectBindlessNV_ovr_0(mode, indirect, drawCount, stride, vertexBufferCount);
end;
public z_MultiDrawElementsIndirectBindlessNV_adr := GetFuncAdr('glMultiDrawElementsIndirectBindlessNV');
public z_MultiDrawElementsIndirectBindlessNV_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; &type: DrawElementsType; indirect: IntPtr; drawCount: Int32; stride: Int32; vertexBufferCount: Int32)>(z_MultiDrawElementsIndirectBindlessNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsIndirectBindlessNV(mode: PrimitiveType; &type: DrawElementsType; indirect: IntPtr; drawCount: Int32; stride: Int32; vertexBufferCount: Int32);
begin
z_MultiDrawElementsIndirectBindlessNV_ovr_0(mode, &type, indirect, drawCount, stride, vertexBufferCount);
end;
end;
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);
public z_MultiDrawArraysIndirectBindlessCountNV_adr := GetFuncAdr('glMultiDrawArraysIndirectBindlessCountNV');
public z_MultiDrawArraysIndirectBindlessCountNV_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; indirect: IntPtr; drawCount: Int32; maxDrawCount: Int32; stride: Int32; vertexBufferCount: Int32)>(z_MultiDrawArraysIndirectBindlessCountNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawArraysIndirectBindlessCountNV(mode: PrimitiveType; indirect: IntPtr; drawCount: Int32; maxDrawCount: Int32; stride: Int32; vertexBufferCount: Int32);
begin
z_MultiDrawArraysIndirectBindlessCountNV_ovr_0(mode, indirect, drawCount, maxDrawCount, stride, vertexBufferCount);
end;
public z_MultiDrawElementsIndirectBindlessCountNV_adr := GetFuncAdr('glMultiDrawElementsIndirectBindlessCountNV');
public z_MultiDrawElementsIndirectBindlessCountNV_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; &type: DrawElementsType; indirect: IntPtr; drawCount: Int32; maxDrawCount: Int32; stride: Int32; vertexBufferCount: Int32)>(z_MultiDrawElementsIndirectBindlessCountNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawElementsIndirectBindlessCountNV(mode: PrimitiveType; &type: DrawElementsType; indirect: IntPtr; drawCount: Int32; maxDrawCount: Int32; stride: Int32; vertexBufferCount: Int32);
begin
z_MultiDrawElementsIndirectBindlessCountNV_ovr_0(mode, &type, indirect, drawCount, maxDrawCount, stride, vertexBufferCount);
end;
end;
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);
public z_GetTextureHandleNV_adr := GetFuncAdr('glGetTextureHandleNV');
public z_GetTextureHandleNV_ovr_0 := GetFuncOrNil&<function(texture: UInt32): UInt64>(z_GetTextureHandleNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetTextureHandleNV(texture: UInt32): UInt64;
begin
Result := z_GetTextureHandleNV_ovr_0(texture);
end;
public z_GetTextureSamplerHandleNV_adr := GetFuncAdr('glGetTextureSamplerHandleNV');
public z_GetTextureSamplerHandleNV_ovr_0 := GetFuncOrNil&<function(texture: UInt32; sampler: UInt32): UInt64>(z_GetTextureSamplerHandleNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetTextureSamplerHandleNV(texture: UInt32; sampler: UInt32): UInt64;
begin
Result := z_GetTextureSamplerHandleNV_ovr_0(texture, sampler);
end;
public z_MakeTextureHandleResidentNV_adr := GetFuncAdr('glMakeTextureHandleResidentNV');
public z_MakeTextureHandleResidentNV_ovr_0 := GetFuncOrNil&<procedure(handle: UInt64)>(z_MakeTextureHandleResidentNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MakeTextureHandleResidentNV(handle: UInt64);
begin
z_MakeTextureHandleResidentNV_ovr_0(handle);
end;
public z_MakeTextureHandleNonResidentNV_adr := GetFuncAdr('glMakeTextureHandleNonResidentNV');
public z_MakeTextureHandleNonResidentNV_ovr_0 := GetFuncOrNil&<procedure(handle: UInt64)>(z_MakeTextureHandleNonResidentNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MakeTextureHandleNonResidentNV(handle: UInt64);
begin
z_MakeTextureHandleNonResidentNV_ovr_0(handle);
end;
public z_GetImageHandleNV_adr := GetFuncAdr('glGetImageHandleNV');
public z_GetImageHandleNV_ovr_0 := GetFuncOrNil&<function(texture: UInt32; level: Int32; layered: boolean; layer: Int32; format: PixelFormat): UInt64>(z_GetImageHandleNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetImageHandleNV(texture: UInt32; level: Int32; layered: boolean; layer: Int32; format: PixelFormat): UInt64;
begin
Result := z_GetImageHandleNV_ovr_0(texture, level, layered, layer, format);
end;
public z_MakeImageHandleResidentNV_adr := GetFuncAdr('glMakeImageHandleResidentNV');
public z_MakeImageHandleResidentNV_ovr_0 := GetFuncOrNil&<procedure(handle: UInt64; access: DummyEnum)>(z_MakeImageHandleResidentNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MakeImageHandleResidentNV(handle: UInt64; access: DummyEnum);
begin
z_MakeImageHandleResidentNV_ovr_0(handle, access);
end;
public z_MakeImageHandleNonResidentNV_adr := GetFuncAdr('glMakeImageHandleNonResidentNV');
public z_MakeImageHandleNonResidentNV_ovr_0 := GetFuncOrNil&<procedure(handle: UInt64)>(z_MakeImageHandleNonResidentNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MakeImageHandleNonResidentNV(handle: UInt64);
begin
z_MakeImageHandleNonResidentNV_ovr_0(handle);
end;
public z_UniformHandleui64NV_adr := GetFuncAdr('glUniformHandleui64NV');
public z_UniformHandleui64NV_ovr_0 := GetFuncOrNil&<procedure(location: Int32; value: UInt64)>(z_UniformHandleui64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformHandleui64NV(location: Int32; value: UInt64);
begin
z_UniformHandleui64NV_ovr_0(location, value);
end;
public z_UniformHandleui64vNV_adr := GetFuncAdr('glUniformHandleui64vNV');
public z_UniformHandleui64vNV_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: UInt64)>(z_UniformHandleui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformHandleui64vNV(location: Int32; count: Int32; value: array of UInt64);
begin
z_UniformHandleui64vNV_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformHandleui64vNV(location: Int32; count: Int32; var value: UInt64);
begin
z_UniformHandleui64vNV_ovr_0(location, count, value);
end;
public z_UniformHandleui64vNV_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_UniformHandleui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UniformHandleui64vNV(location: Int32; count: Int32; value: IntPtr);
begin
z_UniformHandleui64vNV_ovr_2(location, count, value);
end;
public z_ProgramUniformHandleui64NV_adr := GetFuncAdr('glProgramUniformHandleui64NV');
public z_ProgramUniformHandleui64NV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; value: UInt64)>(z_ProgramUniformHandleui64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformHandleui64NV(&program: UInt32; location: Int32; value: UInt64);
begin
z_ProgramUniformHandleui64NV_ovr_0(&program, location, value);
end;
public z_ProgramUniformHandleui64vNV_adr := GetFuncAdr('glProgramUniformHandleui64vNV');
public z_ProgramUniformHandleui64vNV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var values: UInt64)>(z_ProgramUniformHandleui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformHandleui64vNV(&program: UInt32; location: Int32; count: Int32; values: array of UInt64);
begin
z_ProgramUniformHandleui64vNV_ovr_0(&program, location, count, values[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformHandleui64vNV(&program: UInt32; location: Int32; count: Int32; var values: UInt64);
begin
z_ProgramUniformHandleui64vNV_ovr_0(&program, location, count, values);
end;
public z_ProgramUniformHandleui64vNV_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; values: IntPtr)>(z_ProgramUniformHandleui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformHandleui64vNV(&program: UInt32; location: Int32; count: Int32; values: IntPtr);
begin
z_ProgramUniformHandleui64vNV_ovr_2(&program, location, count, values);
end;
public z_IsTextureHandleResidentNV_adr := GetFuncAdr('glIsTextureHandleResidentNV');
public z_IsTextureHandleResidentNV_ovr_0 := GetFuncOrNil&<function(handle: UInt64): boolean>(z_IsTextureHandleResidentNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsTextureHandleResidentNV(handle: UInt64): boolean;
begin
Result := z_IsTextureHandleResidentNV_ovr_0(handle);
end;
public z_IsImageHandleResidentNV_adr := GetFuncAdr('glIsImageHandleResidentNV');
public z_IsImageHandleResidentNV_ovr_0 := GetFuncOrNil&<function(handle: UInt64): boolean>(z_IsImageHandleResidentNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsImageHandleResidentNV(handle: UInt64): boolean;
begin
Result := z_IsImageHandleResidentNV_ovr_0(handle);
end;
end;
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);
public z_BlendParameteriNV_adr := GetFuncAdr('glBlendParameteriNV');
public z_BlendParameteriNV_ovr_0 := GetFuncOrNil&<procedure(pname: DummyEnum; value: Int32)>(z_BlendParameteriNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendParameteriNV(pname: DummyEnum; value: Int32);
begin
z_BlendParameteriNV_ovr_0(pname, value);
end;
public z_BlendBarrierNV_adr := GetFuncAdr('glBlendBarrierNV');
public z_BlendBarrierNV_ovr_0 := GetFuncOrNil&<procedure>(z_BlendBarrierNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendBarrierNV;
begin
z_BlendBarrierNV_ovr_0;
end;
end;
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);
public z_ViewportPositionWScaleNV_adr := GetFuncAdr('glViewportPositionWScaleNV');
public z_ViewportPositionWScaleNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; xcoeff: single; ycoeff: single)>(z_ViewportPositionWScaleNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ViewportPositionWScaleNV(index: UInt32; xcoeff: single; ycoeff: single);
begin
z_ViewportPositionWScaleNV_ovr_0(index, xcoeff, ycoeff);
end;
end;
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);
public z_CreateStatesNV_adr := GetFuncAdr('glCreateStatesNV');
public z_CreateStatesNV_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var states: UInt32)>(z_CreateStatesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateStatesNV(n: Int32; states: array of UInt32);
begin
z_CreateStatesNV_ovr_0(n, states[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateStatesNV(n: Int32; var states: UInt32);
begin
z_CreateStatesNV_ovr_0(n, states);
end;
public z_CreateStatesNV_ovr_2 := GetFuncOrNil&<procedure(n: Int32; states: IntPtr)>(z_CreateStatesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateStatesNV(n: Int32; states: IntPtr);
begin
z_CreateStatesNV_ovr_2(n, states);
end;
public z_DeleteStatesNV_adr := GetFuncAdr('glDeleteStatesNV');
public z_DeleteStatesNV_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var states: UInt32)>(z_DeleteStatesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteStatesNV(n: Int32; states: array of UInt32);
begin
z_DeleteStatesNV_ovr_0(n, states[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteStatesNV(n: Int32; var states: UInt32);
begin
z_DeleteStatesNV_ovr_0(n, states);
end;
public z_DeleteStatesNV_ovr_2 := GetFuncOrNil&<procedure(n: Int32; states: IntPtr)>(z_DeleteStatesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteStatesNV(n: Int32; states: IntPtr);
begin
z_DeleteStatesNV_ovr_2(n, states);
end;
public z_IsStateNV_adr := GetFuncAdr('glIsStateNV');
public z_IsStateNV_ovr_0 := GetFuncOrNil&<function(state: UInt32): boolean>(z_IsStateNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsStateNV(state: UInt32): boolean;
begin
Result := z_IsStateNV_ovr_0(state);
end;
public z_StateCaptureNV_adr := GetFuncAdr('glStateCaptureNV');
public z_StateCaptureNV_ovr_0 := GetFuncOrNil&<procedure(state: UInt32; mode: DummyEnum)>(z_StateCaptureNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StateCaptureNV(state: UInt32; mode: DummyEnum);
begin
z_StateCaptureNV_ovr_0(state, mode);
end;
public z_GetCommandHeaderNV_adr := GetFuncAdr('glGetCommandHeaderNV');
public z_GetCommandHeaderNV_ovr_0 := GetFuncOrNil&<function(tokenID: DummyEnum; size: UInt32): UInt32>(z_GetCommandHeaderNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetCommandHeaderNV(tokenID: DummyEnum; size: UInt32): UInt32;
begin
Result := z_GetCommandHeaderNV_ovr_0(tokenID, size);
end;
public z_GetStageIndexNV_adr := GetFuncAdr('glGetStageIndexNV');
public z_GetStageIndexNV_ovr_0 := GetFuncOrNil&<function(_shadertype: ShaderType): UInt16>(z_GetStageIndexNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetStageIndexNV(_shadertype: ShaderType): UInt16;
begin
Result := z_GetStageIndexNV_ovr_0(_shadertype);
end;
public z_DrawCommandsNV_adr := GetFuncAdr('glDrawCommandsNV');
public z_DrawCommandsNV_ovr_0 := GetFuncOrNil&<procedure(primitiveMode: DummyEnum; buffer: UInt32; var indirects: IntPtr; var sizes: Int32; count: UInt32)>(z_DrawCommandsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsNV(primitiveMode: DummyEnum; buffer: UInt32; indirects: array of IntPtr; sizes: array of Int32; count: UInt32);
begin
z_DrawCommandsNV_ovr_0(primitiveMode, buffer, indirects[0], sizes[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsNV(primitiveMode: DummyEnum; buffer: UInt32; indirects: array of IntPtr; var sizes: Int32; count: UInt32);
begin
z_DrawCommandsNV_ovr_0(primitiveMode, buffer, indirects[0], sizes, count);
end;
public z_DrawCommandsNV_ovr_2 := GetFuncOrNil&<procedure(primitiveMode: DummyEnum; buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; count: UInt32)>(z_DrawCommandsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsNV(primitiveMode: DummyEnum; buffer: UInt32; indirects: array of IntPtr; sizes: IntPtr; count: UInt32);
begin
z_DrawCommandsNV_ovr_2(primitiveMode, buffer, indirects[0], sizes, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsNV(primitiveMode: DummyEnum; buffer: UInt32; var indirects: IntPtr; sizes: array of Int32; count: UInt32);
begin
z_DrawCommandsNV_ovr_0(primitiveMode, buffer, indirects, sizes[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsNV(primitiveMode: DummyEnum; buffer: UInt32; var indirects: IntPtr; var sizes: Int32; count: UInt32);
begin
z_DrawCommandsNV_ovr_0(primitiveMode, buffer, indirects, sizes, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsNV(primitiveMode: DummyEnum; buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; count: UInt32);
begin
z_DrawCommandsNV_ovr_2(primitiveMode, buffer, indirects, sizes, count);
end;
public z_DrawCommandsNV_ovr_6 := GetFuncOrNil&<procedure(primitiveMode: DummyEnum; buffer: UInt32; indirects: pointer; var sizes: Int32; count: UInt32)>(z_DrawCommandsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsNV(primitiveMode: DummyEnum; buffer: UInt32; indirects: pointer; sizes: array of Int32; count: UInt32);
begin
z_DrawCommandsNV_ovr_6(primitiveMode, buffer, indirects, sizes[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsNV(primitiveMode: DummyEnum; buffer: UInt32; indirects: pointer; var sizes: Int32; count: UInt32);
begin
z_DrawCommandsNV_ovr_6(primitiveMode, buffer, indirects, sizes, count);
end;
public z_DrawCommandsNV_ovr_8 := GetFuncOrNil&<procedure(primitiveMode: DummyEnum; buffer: UInt32; indirects: pointer; sizes: IntPtr; count: UInt32)>(z_DrawCommandsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsNV(primitiveMode: DummyEnum; buffer: UInt32; indirects: pointer; sizes: IntPtr; count: UInt32);
begin
z_DrawCommandsNV_ovr_8(primitiveMode, buffer, indirects, sizes, count);
end;
public z_DrawCommandsAddressNV_adr := GetFuncAdr('glDrawCommandsAddressNV');
public z_DrawCommandsAddressNV_ovr_0 := GetFuncOrNil&<procedure(primitiveMode: DummyEnum; var indirects: UInt64; var sizes: Int32; count: UInt32)>(z_DrawCommandsAddressNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsAddressNV(primitiveMode: DummyEnum; indirects: array of UInt64; sizes: array of Int32; count: UInt32);
begin
z_DrawCommandsAddressNV_ovr_0(primitiveMode, indirects[0], sizes[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsAddressNV(primitiveMode: DummyEnum; indirects: array of UInt64; var sizes: Int32; count: UInt32);
begin
z_DrawCommandsAddressNV_ovr_0(primitiveMode, indirects[0], sizes, count);
end;
public z_DrawCommandsAddressNV_ovr_2 := GetFuncOrNil&<procedure(primitiveMode: DummyEnum; var indirects: UInt64; sizes: IntPtr; count: UInt32)>(z_DrawCommandsAddressNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsAddressNV(primitiveMode: DummyEnum; indirects: array of UInt64; sizes: IntPtr; count: UInt32);
begin
z_DrawCommandsAddressNV_ovr_2(primitiveMode, indirects[0], sizes, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsAddressNV(primitiveMode: DummyEnum; var indirects: UInt64; sizes: array of Int32; count: UInt32);
begin
z_DrawCommandsAddressNV_ovr_0(primitiveMode, indirects, sizes[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsAddressNV(primitiveMode: DummyEnum; var indirects: UInt64; var sizes: Int32; count: UInt32);
begin
z_DrawCommandsAddressNV_ovr_0(primitiveMode, indirects, sizes, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsAddressNV(primitiveMode: DummyEnum; var indirects: UInt64; sizes: IntPtr; count: UInt32);
begin
z_DrawCommandsAddressNV_ovr_2(primitiveMode, indirects, sizes, count);
end;
public z_DrawCommandsAddressNV_ovr_6 := GetFuncOrNil&<procedure(primitiveMode: DummyEnum; indirects: IntPtr; var sizes: Int32; count: UInt32)>(z_DrawCommandsAddressNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsAddressNV(primitiveMode: DummyEnum; indirects: IntPtr; sizes: array of Int32; count: UInt32);
begin
z_DrawCommandsAddressNV_ovr_6(primitiveMode, indirects, sizes[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsAddressNV(primitiveMode: DummyEnum; indirects: IntPtr; var sizes: Int32; count: UInt32);
begin
z_DrawCommandsAddressNV_ovr_6(primitiveMode, indirects, sizes, count);
end;
public z_DrawCommandsAddressNV_ovr_8 := GetFuncOrNil&<procedure(primitiveMode: DummyEnum; indirects: IntPtr; sizes: IntPtr; count: UInt32)>(z_DrawCommandsAddressNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsAddressNV(primitiveMode: DummyEnum; indirects: IntPtr; sizes: IntPtr; count: UInt32);
begin
z_DrawCommandsAddressNV_ovr_8(primitiveMode, indirects, sizes, count);
end;
public z_DrawCommandsStatesNV_adr := GetFuncAdr('glDrawCommandsStatesNV');
public z_DrawCommandsStatesNV_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32)>(z_DrawCommandsStatesNV_adr);
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);
begin
z_DrawCommandsStatesNV_ovr_0(buffer, indirects[0], sizes[0], states[0], fbos[0], count);
end;
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);
begin
z_DrawCommandsStatesNV_ovr_0(buffer, indirects[0], sizes[0], states[0], fbos, count);
end;
public z_DrawCommandsStatesNV_ovr_2 := GetFuncOrNil&<procedure(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32)>(z_DrawCommandsStatesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: array of Int32; states: array of UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_2(buffer, indirects[0], sizes[0], states[0], fbos, count);
end;
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);
begin
z_DrawCommandsStatesNV_ovr_0(buffer, indirects[0], sizes[0], states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: array of Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_0(buffer, indirects[0], sizes[0], states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: array of Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_2(buffer, indirects[0], sizes[0], states, fbos, count);
end;
public z_DrawCommandsStatesNV_ovr_6 := GetFuncOrNil&<procedure(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32)>(z_DrawCommandsStatesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: array of Int32; states: IntPtr; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_6(buffer, indirects[0], sizes[0], states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: array of Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_6(buffer, indirects[0], sizes[0], states, fbos, count);
end;
public z_DrawCommandsStatesNV_ovr_8 := GetFuncOrNil&<procedure(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32)>(z_DrawCommandsStatesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: array of Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_8(buffer, indirects[0], sizes[0], states, fbos, count);
end;
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);
begin
z_DrawCommandsStatesNV_ovr_0(buffer, indirects[0], sizes, states[0], fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; var sizes: Int32; states: array of UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_0(buffer, indirects[0], sizes, states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; var sizes: Int32; states: array of UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_2(buffer, indirects[0], sizes, states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; var sizes: Int32; var states: UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_0(buffer, indirects[0], sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_0(buffer, indirects[0], sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_2(buffer, indirects[0], sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; var sizes: Int32; states: IntPtr; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_6(buffer, indirects[0], sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_6(buffer, indirects[0], sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_8(buffer, indirects[0], sizes, states, fbos, count);
end;
public z_DrawCommandsStatesNV_ovr_18 := GetFuncOrNil&<procedure(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32)>(z_DrawCommandsStatesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: IntPtr; states: array of UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_18(buffer, indirects[0], sizes, states[0], fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: IntPtr; states: array of UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_18(buffer, indirects[0], sizes, states[0], fbos, count);
end;
public z_DrawCommandsStatesNV_ovr_20 := GetFuncOrNil&<procedure(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32)>(z_DrawCommandsStatesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: IntPtr; states: array of UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_20(buffer, indirects[0], sizes, states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: IntPtr; var states: UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_18(buffer, indirects[0], sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_18(buffer, indirects[0], sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_20(buffer, indirects[0], sizes, states, fbos, count);
end;
public z_DrawCommandsStatesNV_ovr_24 := GetFuncOrNil&<procedure(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32)>(z_DrawCommandsStatesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: IntPtr; states: IntPtr; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_24(buffer, indirects[0], sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_24(buffer, indirects[0], sizes, states, fbos, count);
end;
public z_DrawCommandsStatesNV_ovr_26 := GetFuncOrNil&<procedure(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32)>(z_DrawCommandsStatesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: array of IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_26(buffer, indirects[0], sizes, states, fbos, count);
end;
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);
begin
z_DrawCommandsStatesNV_ovr_0(buffer, indirects, sizes[0], states[0], fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: array of Int32; states: array of UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_0(buffer, indirects, sizes[0], states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: array of Int32; states: array of UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_2(buffer, indirects, sizes[0], states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: array of Int32; var states: UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_0(buffer, indirects, sizes[0], states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: array of Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_0(buffer, indirects, sizes[0], states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: array of Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_2(buffer, indirects, sizes[0], states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: array of Int32; states: IntPtr; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_6(buffer, indirects, sizes[0], states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: array of Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_6(buffer, indirects, sizes[0], states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: array of Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_8(buffer, indirects, sizes[0], states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; states: array of UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_0(buffer, indirects, sizes, states[0], fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; states: array of UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_0(buffer, indirects, sizes, states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; states: array of UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_2(buffer, indirects, sizes, states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_0(buffer, indirects, sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_0(buffer, indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_2(buffer, indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_6(buffer, indirects, sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_6(buffer, indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_8(buffer, indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: array of UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_18(buffer, indirects, sizes, states[0], fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: array of UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_18(buffer, indirects, sizes, states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: array of UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_20(buffer, indirects, sizes, states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_18(buffer, indirects, sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_18(buffer, indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_20(buffer, indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_24(buffer, indirects, sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_24(buffer, indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_26(buffer, indirects, sizes, states, fbos, count);
end;
public z_DrawCommandsStatesNV_ovr_54 := GetFuncOrNil&<procedure(buffer: UInt32; indirects: pointer; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32)>(z_DrawCommandsStatesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: array of Int32; states: array of UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_54(buffer, indirects, sizes[0], states[0], fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: array of Int32; states: array of UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_54(buffer, indirects, sizes[0], states[0], fbos, count);
end;
public z_DrawCommandsStatesNV_ovr_56 := GetFuncOrNil&<procedure(buffer: UInt32; indirects: pointer; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32)>(z_DrawCommandsStatesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: array of Int32; states: array of UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_56(buffer, indirects, sizes[0], states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: array of Int32; var states: UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_54(buffer, indirects, sizes[0], states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: array of Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_54(buffer, indirects, sizes[0], states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: array of Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_56(buffer, indirects, sizes[0], states, fbos, count);
end;
public z_DrawCommandsStatesNV_ovr_60 := GetFuncOrNil&<procedure(buffer: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32)>(z_DrawCommandsStatesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: array of Int32; states: IntPtr; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_60(buffer, indirects, sizes[0], states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: array of Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_60(buffer, indirects, sizes[0], states, fbos, count);
end;
public z_DrawCommandsStatesNV_ovr_62 := GetFuncOrNil&<procedure(buffer: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32)>(z_DrawCommandsStatesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: array of Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_62(buffer, indirects, sizes[0], states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; var sizes: Int32; states: array of UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_54(buffer, indirects, sizes, states[0], fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; var sizes: Int32; states: array of UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_54(buffer, indirects, sizes, states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; var sizes: Int32; states: array of UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_56(buffer, indirects, sizes, states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; var sizes: Int32; var states: UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_54(buffer, indirects, sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_54(buffer, indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_56(buffer, indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_60(buffer, indirects, sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_60(buffer, indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_62(buffer, indirects, sizes, states, fbos, count);
end;
public z_DrawCommandsStatesNV_ovr_72 := GetFuncOrNil&<procedure(buffer: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32)>(z_DrawCommandsStatesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: array of UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_72(buffer, indirects, sizes, states[0], fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: array of UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_72(buffer, indirects, sizes, states[0], fbos, count);
end;
public z_DrawCommandsStatesNV_ovr_74 := GetFuncOrNil&<procedure(buffer: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32)>(z_DrawCommandsStatesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: array of UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_74(buffer, indirects, sizes, states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_72(buffer, indirects, sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_72(buffer, indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_74(buffer, indirects, sizes, states, fbos, count);
end;
public z_DrawCommandsStatesNV_ovr_78 := GetFuncOrNil&<procedure(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32)>(z_DrawCommandsStatesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_78(buffer, indirects, sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_78(buffer, indirects, sizes, states, fbos, count);
end;
public z_DrawCommandsStatesNV_ovr_80 := GetFuncOrNil&<procedure(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32)>(z_DrawCommandsStatesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesNV(buffer: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesNV_ovr_80(buffer, indirects, sizes, states, fbos, count);
end;
public z_DrawCommandsStatesAddressNV_adr := GetFuncAdr('glDrawCommandsStatesAddressNV');
public z_DrawCommandsStatesAddressNV_ovr_0 := GetFuncOrNil&<procedure(var indirects: UInt64; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32)>(z_DrawCommandsStatesAddressNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: array of Int32; states: array of UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_0(indirects[0], sizes[0], states[0], fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: array of Int32; states: array of UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_0(indirects[0], sizes[0], states[0], fbos, count);
end;
public z_DrawCommandsStatesAddressNV_ovr_2 := GetFuncOrNil&<procedure(var indirects: UInt64; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32)>(z_DrawCommandsStatesAddressNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: array of Int32; states: array of UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_2(indirects[0], sizes[0], states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: array of Int32; var states: UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_0(indirects[0], sizes[0], states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: array of Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_0(indirects[0], sizes[0], states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: array of Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_2(indirects[0], sizes[0], states, fbos, count);
end;
public z_DrawCommandsStatesAddressNV_ovr_6 := GetFuncOrNil&<procedure(var indirects: UInt64; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32)>(z_DrawCommandsStatesAddressNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: array of Int32; states: IntPtr; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_6(indirects[0], sizes[0], states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: array of Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_6(indirects[0], sizes[0], states, fbos, count);
end;
public z_DrawCommandsStatesAddressNV_ovr_8 := GetFuncOrNil&<procedure(var indirects: UInt64; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32)>(z_DrawCommandsStatesAddressNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: array of Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_8(indirects[0], sizes[0], states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; var sizes: Int32; states: array of UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_0(indirects[0], sizes, states[0], fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; var sizes: Int32; states: array of UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_0(indirects[0], sizes, states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; var sizes: Int32; states: array of UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_2(indirects[0], sizes, states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; var sizes: Int32; var states: UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_0(indirects[0], sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_0(indirects[0], sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_2(indirects[0], sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; var sizes: Int32; states: IntPtr; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_6(indirects[0], sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_6(indirects[0], sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_8(indirects[0], sizes, states, fbos, count);
end;
public z_DrawCommandsStatesAddressNV_ovr_18 := GetFuncOrNil&<procedure(var indirects: UInt64; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32)>(z_DrawCommandsStatesAddressNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: IntPtr; states: array of UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_18(indirects[0], sizes, states[0], fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: IntPtr; states: array of UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_18(indirects[0], sizes, states[0], fbos, count);
end;
public z_DrawCommandsStatesAddressNV_ovr_20 := GetFuncOrNil&<procedure(var indirects: UInt64; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32)>(z_DrawCommandsStatesAddressNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: IntPtr; states: array of UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_20(indirects[0], sizes, states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: IntPtr; var states: UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_18(indirects[0], sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_18(indirects[0], sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_20(indirects[0], sizes, states, fbos, count);
end;
public z_DrawCommandsStatesAddressNV_ovr_24 := GetFuncOrNil&<procedure(var indirects: UInt64; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32)>(z_DrawCommandsStatesAddressNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: IntPtr; states: IntPtr; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_24(indirects[0], sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_24(indirects[0], sizes, states, fbos, count);
end;
public z_DrawCommandsStatesAddressNV_ovr_26 := GetFuncOrNil&<procedure(var indirects: UInt64; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32)>(z_DrawCommandsStatesAddressNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: array of UInt64; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_26(indirects[0], sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: array of Int32; states: array of UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_0(indirects, sizes[0], states[0], fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: array of Int32; states: array of UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_0(indirects, sizes[0], states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: array of Int32; states: array of UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_2(indirects, sizes[0], states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: array of Int32; var states: UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_0(indirects, sizes[0], states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: array of Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_0(indirects, sizes[0], states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: array of Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_2(indirects, sizes[0], states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: array of Int32; states: IntPtr; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_6(indirects, sizes[0], states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: array of Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_6(indirects, sizes[0], states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: array of Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_8(indirects, sizes[0], states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; var sizes: Int32; states: array of UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_0(indirects, sizes, states[0], fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; var sizes: Int32; states: array of UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_0(indirects, sizes, states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; var sizes: Int32; states: array of UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_2(indirects, sizes, states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; var sizes: Int32; var states: UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_0(indirects, sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_0(indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_2(indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; var sizes: Int32; states: IntPtr; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_6(indirects, sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_6(indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_8(indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: IntPtr; states: array of UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_18(indirects, sizes, states[0], fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: IntPtr; states: array of UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_18(indirects, sizes, states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: IntPtr; states: array of UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_20(indirects, sizes, states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: IntPtr; var states: UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_18(indirects, sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_18(indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_20(indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: IntPtr; states: IntPtr; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_24(indirects, sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_24(indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(var indirects: UInt64; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_26(indirects, sizes, states, fbos, count);
end;
public z_DrawCommandsStatesAddressNV_ovr_54 := GetFuncOrNil&<procedure(indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32)>(z_DrawCommandsStatesAddressNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: array of Int32; states: array of UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_54(indirects, sizes[0], states[0], fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: array of Int32; states: array of UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_54(indirects, sizes[0], states[0], fbos, count);
end;
public z_DrawCommandsStatesAddressNV_ovr_56 := GetFuncOrNil&<procedure(indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32)>(z_DrawCommandsStatesAddressNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: array of Int32; states: array of UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_56(indirects, sizes[0], states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: array of Int32; var states: UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_54(indirects, sizes[0], states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: array of Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_54(indirects, sizes[0], states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: array of Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_56(indirects, sizes[0], states, fbos, count);
end;
public z_DrawCommandsStatesAddressNV_ovr_60 := GetFuncOrNil&<procedure(indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32)>(z_DrawCommandsStatesAddressNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: array of Int32; states: IntPtr; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_60(indirects, sizes[0], states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: array of Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_60(indirects, sizes[0], states, fbos, count);
end;
public z_DrawCommandsStatesAddressNV_ovr_62 := GetFuncOrNil&<procedure(indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32)>(z_DrawCommandsStatesAddressNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: array of Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_62(indirects, sizes[0], states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; var sizes: Int32; states: array of UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_54(indirects, sizes, states[0], fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; var sizes: Int32; states: array of UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_54(indirects, sizes, states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; var sizes: Int32; states: array of UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_56(indirects, sizes, states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_54(indirects, sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_54(indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_56(indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_60(indirects, sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_60(indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_62(indirects, sizes, states, fbos, count);
end;
public z_DrawCommandsStatesAddressNV_ovr_72 := GetFuncOrNil&<procedure(indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32)>(z_DrawCommandsStatesAddressNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: IntPtr; states: array of UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_72(indirects, sizes, states[0], fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: IntPtr; states: array of UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_72(indirects, sizes, states[0], fbos, count);
end;
public z_DrawCommandsStatesAddressNV_ovr_74 := GetFuncOrNil&<procedure(indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32)>(z_DrawCommandsStatesAddressNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: IntPtr; states: array of UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_74(indirects, sizes, states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_72(indirects, sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_72(indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_74(indirects, sizes, states, fbos, count);
end;
public z_DrawCommandsStatesAddressNV_ovr_78 := GetFuncOrNil&<procedure(indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32)>(z_DrawCommandsStatesAddressNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: array of UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_78(indirects, sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_78(indirects, sizes, states, fbos, count);
end;
public z_DrawCommandsStatesAddressNV_ovr_80 := GetFuncOrNil&<procedure(indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32)>(z_DrawCommandsStatesAddressNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawCommandsStatesAddressNV(indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
begin
z_DrawCommandsStatesAddressNV_ovr_80(indirects, sizes, states, fbos, count);
end;
public z_CreateCommandListsNV_adr := GetFuncAdr('glCreateCommandListsNV');
public z_CreateCommandListsNV_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var lists: UInt32)>(z_CreateCommandListsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateCommandListsNV(n: Int32; lists: array of UInt32);
begin
z_CreateCommandListsNV_ovr_0(n, lists[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateCommandListsNV(n: Int32; var lists: UInt32);
begin
z_CreateCommandListsNV_ovr_0(n, lists);
end;
public z_CreateCommandListsNV_ovr_2 := GetFuncOrNil&<procedure(n: Int32; lists: IntPtr)>(z_CreateCommandListsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CreateCommandListsNV(n: Int32; lists: IntPtr);
begin
z_CreateCommandListsNV_ovr_2(n, lists);
end;
public z_DeleteCommandListsNV_adr := GetFuncAdr('glDeleteCommandListsNV');
public z_DeleteCommandListsNV_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var lists: UInt32)>(z_DeleteCommandListsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteCommandListsNV(n: Int32; lists: array of UInt32);
begin
z_DeleteCommandListsNV_ovr_0(n, lists[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteCommandListsNV(n: Int32; var lists: UInt32);
begin
z_DeleteCommandListsNV_ovr_0(n, lists);
end;
public z_DeleteCommandListsNV_ovr_2 := GetFuncOrNil&<procedure(n: Int32; lists: IntPtr)>(z_DeleteCommandListsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteCommandListsNV(n: Int32; lists: IntPtr);
begin
z_DeleteCommandListsNV_ovr_2(n, lists);
end;
public z_IsCommandListNV_adr := GetFuncAdr('glIsCommandListNV');
public z_IsCommandListNV_ovr_0 := GetFuncOrNil&<function(list: UInt32): boolean>(z_IsCommandListNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsCommandListNV(list: UInt32): boolean;
begin
Result := z_IsCommandListNV_ovr_0(list);
end;
public z_ListDrawCommandsStatesClientNV_adr := GetFuncAdr('glListDrawCommandsStatesClientNV');
public z_ListDrawCommandsStatesClientNV_ovr_0 := GetFuncOrNil&<procedure(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32)>(z_ListDrawCommandsStatesClientNV_adr);
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects[0], sizes[0], states[0], fbos[0], count);
end;
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects[0], sizes[0], states[0], fbos, count);
end;
public z_ListDrawCommandsStatesClientNV_ovr_2 := GetFuncOrNil&<procedure(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32)>(z_ListDrawCommandsStatesClientNV_adr);
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_2(list, segment, indirects[0], sizes[0], states[0], fbos, count);
end;
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects[0], sizes[0], states, fbos[0], count);
end;
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects[0], sizes[0], states, fbos, count);
end;
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_2(list, segment, indirects[0], sizes[0], states, fbos, count);
end;
public z_ListDrawCommandsStatesClientNV_ovr_6 := GetFuncOrNil&<procedure(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32)>(z_ListDrawCommandsStatesClientNV_adr);
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_6(list, segment, indirects[0], sizes[0], states, fbos[0], count);
end;
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_6(list, segment, indirects[0], sizes[0], states, fbos, count);
end;
public z_ListDrawCommandsStatesClientNV_ovr_8 := GetFuncOrNil&<procedure(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32)>(z_ListDrawCommandsStatesClientNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; sizes: array of Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_8(list, segment, indirects[0], sizes[0], states, fbos, count);
end;
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects[0], sizes, states[0], fbos[0], count);
end;
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects[0], sizes, states[0], fbos, count);
end;
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_2(list, segment, indirects[0], sizes, states[0], fbos, count);
end;
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects[0], sizes, states, fbos[0], count);
end;
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects[0], sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_2(list, segment, indirects[0], sizes, states, fbos, count);
end;
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_6(list, segment, indirects[0], sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_6(list, segment, indirects[0], sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_8(list, segment, indirects[0], sizes, states, fbos, count);
end;
public z_ListDrawCommandsStatesClientNV_ovr_18 := GetFuncOrNil&<procedure(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32)>(z_ListDrawCommandsStatesClientNV_adr);
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_18(list, segment, indirects[0], sizes, states[0], fbos[0], count);
end;
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_18(list, segment, indirects[0], sizes, states[0], fbos, count);
end;
public z_ListDrawCommandsStatesClientNV_ovr_20 := GetFuncOrNil&<procedure(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32)>(z_ListDrawCommandsStatesClientNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; sizes: IntPtr; states: array of UInt32; fbos: IntPtr; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_20(list, segment, indirects[0], sizes, states[0], fbos, count);
end;
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_18(list, segment, indirects[0], sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_18(list, segment, indirects[0], sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_20(list, segment, indirects[0], sizes, states, fbos, count);
end;
public z_ListDrawCommandsStatesClientNV_ovr_24 := GetFuncOrNil&<procedure(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32)>(z_ListDrawCommandsStatesClientNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; sizes: IntPtr; states: IntPtr; fbos: array of UInt32; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_24(list, segment, indirects[0], sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_24(list, segment, indirects[0], sizes, states, fbos, count);
end;
public z_ListDrawCommandsStatesClientNV_ovr_26 := GetFuncOrNil&<procedure(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32)>(z_ListDrawCommandsStatesClientNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: array of IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_26(list, segment, indirects[0], sizes, states, fbos, count);
end;
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects, sizes[0], states[0], fbos[0], count);
end;
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects, sizes[0], states[0], fbos, count);
end;
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_2(list, segment, indirects, sizes[0], states[0], fbos, count);
end;
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects, sizes[0], states, fbos[0], count);
end;
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects, sizes[0], states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: array of Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_2(list, segment, indirects, sizes[0], states, fbos, count);
end;
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_6(list, segment, indirects, sizes[0], states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: array of Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_6(list, segment, indirects, sizes[0], states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: array of Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_8(list, segment, indirects, sizes[0], states, fbos, count);
end;
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects, sizes, states[0], fbos[0], count);
end;
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects, sizes, states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; states: array of UInt32; fbos: IntPtr; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_2(list, segment, indirects, sizes, states[0], fbos, count);
end;
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects, sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_0(list, segment, indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_2(list, segment, indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: array of UInt32; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_6(list, segment, indirects, sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_6(list, segment, indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_8(list, segment, indirects, sizes, states, fbos, count);
end;
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_18(list, segment, indirects, sizes, states[0], fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: array of UInt32; var fbos: UInt32; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_18(list, segment, indirects, sizes, states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: array of UInt32; fbos: IntPtr; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_20(list, segment, indirects, sizes, states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: array of UInt32; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_18(list, segment, indirects, sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_18(list, segment, indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_20(list, segment, indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: array of UInt32; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_24(list, segment, indirects, sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_24(list, segment, indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; var indirects: IntPtr; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_26(list, segment, indirects, sizes, states, fbos, count);
end;
public z_ListDrawCommandsStatesClientNV_ovr_54 := GetFuncOrNil&<procedure(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32)>(z_ListDrawCommandsStatesClientNV_adr);
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_54(list, segment, indirects, sizes[0], states[0], fbos[0], count);
end;
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_54(list, segment, indirects, sizes[0], states[0], fbos, count);
end;
public z_ListDrawCommandsStatesClientNV_ovr_56 := GetFuncOrNil&<procedure(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32)>(z_ListDrawCommandsStatesClientNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: array of Int32; states: array of UInt32; fbos: IntPtr; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_56(list, segment, indirects, sizes[0], states[0], fbos, count);
end;
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_54(list, segment, indirects, sizes[0], states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: array of Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_54(list, segment, indirects, sizes[0], states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: array of Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_56(list, segment, indirects, sizes[0], states, fbos, count);
end;
public z_ListDrawCommandsStatesClientNV_ovr_60 := GetFuncOrNil&<procedure(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32)>(z_ListDrawCommandsStatesClientNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: array of Int32; states: IntPtr; fbos: array of UInt32; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_60(list, segment, indirects, sizes[0], states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: array of Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_60(list, segment, indirects, sizes[0], states, fbos, count);
end;
public z_ListDrawCommandsStatesClientNV_ovr_62 := GetFuncOrNil&<procedure(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32)>(z_ListDrawCommandsStatesClientNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: array of Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_62(list, segment, indirects, sizes[0], states, fbos, count);
end;
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);
begin
z_ListDrawCommandsStatesClientNV_ovr_54(list, segment, indirects, sizes, states[0], fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; states: array of UInt32; var fbos: UInt32; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_54(list, segment, indirects, sizes, states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; states: array of UInt32; fbos: IntPtr; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_56(list, segment, indirects, sizes, states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; var states: UInt32; fbos: array of UInt32; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_54(list, segment, indirects, sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; var states: UInt32; var fbos: UInt32; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_54(list, segment, indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; var states: UInt32; fbos: IntPtr; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_56(list, segment, indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; fbos: array of UInt32; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_60(list, segment, indirects, sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; var fbos: UInt32; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_60(list, segment, indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; var sizes: Int32; states: IntPtr; fbos: IntPtr; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_62(list, segment, indirects, sizes, states, fbos, count);
end;
public z_ListDrawCommandsStatesClientNV_ovr_72 := GetFuncOrNil&<procedure(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32)>(z_ListDrawCommandsStatesClientNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: array of UInt32; fbos: array of UInt32; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_72(list, segment, indirects, sizes, states[0], fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: array of UInt32; var fbos: UInt32; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_72(list, segment, indirects, sizes, states[0], fbos, count);
end;
public z_ListDrawCommandsStatesClientNV_ovr_74 := GetFuncOrNil&<procedure(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32)>(z_ListDrawCommandsStatesClientNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: array of UInt32; fbos: IntPtr; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_74(list, segment, indirects, sizes, states[0], fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; fbos: array of UInt32; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_72(list, segment, indirects, sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; var fbos: UInt32; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_72(list, segment, indirects, sizes, states, fbos, count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; var states: UInt32; fbos: IntPtr; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_74(list, segment, indirects, sizes, states, fbos, count);
end;
public z_ListDrawCommandsStatesClientNV_ovr_78 := GetFuncOrNil&<procedure(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32)>(z_ListDrawCommandsStatesClientNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; fbos: array of UInt32; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_78(list, segment, indirects, sizes, states, fbos[0], count);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; var fbos: UInt32; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_78(list, segment, indirects, sizes, states, fbos, count);
end;
public z_ListDrawCommandsStatesClientNV_ovr_80 := GetFuncOrNil&<procedure(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32)>(z_ListDrawCommandsStatesClientNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListDrawCommandsStatesClientNV(list: UInt32; segment: UInt32; indirects: pointer; sizes: IntPtr; states: IntPtr; fbos: IntPtr; count: UInt32);
begin
z_ListDrawCommandsStatesClientNV_ovr_80(list, segment, indirects, sizes, states, fbos, count);
end;
public z_CommandListSegmentsNV_adr := GetFuncAdr('glCommandListSegmentsNV');
public z_CommandListSegmentsNV_ovr_0 := GetFuncOrNil&<procedure(list: UInt32; segments: UInt32)>(z_CommandListSegmentsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CommandListSegmentsNV(list: UInt32; segments: UInt32);
begin
z_CommandListSegmentsNV_ovr_0(list, segments);
end;
public z_CompileCommandListNV_adr := GetFuncAdr('glCompileCommandListNV');
public z_CompileCommandListNV_ovr_0 := GetFuncOrNil&<procedure(list: UInt32)>(z_CompileCommandListNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CompileCommandListNV(list: UInt32);
begin
z_CompileCommandListNV_ovr_0(list);
end;
public z_CallCommandListNV_adr := GetFuncAdr('glCallCommandListNV');
public z_CallCommandListNV_ovr_0 := GetFuncOrNil&<procedure(list: UInt32)>(z_CallCommandListNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CallCommandListNV(list: UInt32);
begin
z_CallCommandListNV_ovr_0(list);
end;
end;
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);
public z_BeginConditionalRenderNV_adr := GetFuncAdr('glBeginConditionalRenderNV');
public z_BeginConditionalRenderNV_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; mode: ConditionalRenderMode)>(z_BeginConditionalRenderNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginConditionalRenderNV(id: UInt32; mode: ConditionalRenderMode);
begin
z_BeginConditionalRenderNV_ovr_0(id, mode);
end;
public z_EndConditionalRenderNV_adr := GetFuncAdr('glEndConditionalRenderNV');
public z_EndConditionalRenderNV_ovr_0 := GetFuncOrNil&<procedure>(z_EndConditionalRenderNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndConditionalRenderNV;
begin
z_EndConditionalRenderNV_ovr_0;
end;
end;
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);
public z_SubpixelPrecisionBiasNV_adr := GetFuncAdr('glSubpixelPrecisionBiasNV');
public z_SubpixelPrecisionBiasNV_ovr_0 := GetFuncOrNil&<procedure(xbits: UInt32; ybits: UInt32)>(z_SubpixelPrecisionBiasNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SubpixelPrecisionBiasNV(xbits: UInt32; ybits: UInt32);
begin
z_SubpixelPrecisionBiasNV_ovr_0(xbits, ybits);
end;
end;
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);
public z_ConservativeRasterParameterfNV_adr := GetFuncAdr('glConservativeRasterParameterfNV');
public z_ConservativeRasterParameterfNV_ovr_0 := GetFuncOrNil&<procedure(pname: DummyEnum; value: single)>(z_ConservativeRasterParameterfNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConservativeRasterParameterfNV(pname: DummyEnum; value: single);
begin
z_ConservativeRasterParameterfNV_ovr_0(pname, value);
end;
end;
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);
public z_ConservativeRasterParameteriNV_adr := GetFuncAdr('glConservativeRasterParameteriNV');
public z_ConservativeRasterParameteriNV_ovr_0 := GetFuncOrNil&<procedure(pname: DummyEnum; param: Int32)>(z_ConservativeRasterParameteriNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConservativeRasterParameteriNV(pname: DummyEnum; param: Int32);
begin
z_ConservativeRasterParameteriNV_ovr_0(pname, param);
end;
end;
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);
public z_CopyImageSubDataNV_adr := GetFuncAdr('glCopyImageSubDataNV');
public z_CopyImageSubDataNV_ovr_0 := GetFuncOrNil&<procedure(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_adr);
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);
begin
z_CopyImageSubDataNV_ovr_0(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth);
end;
end;
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);
public z_DepthRangedNV_adr := GetFuncAdr('glDepthRangedNV');
public z_DepthRangedNV_ovr_0 := GetFuncOrNil&<procedure(zNear: real; zFar: real)>(z_DepthRangedNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthRangedNV(zNear: real; zFar: real);
begin
z_DepthRangedNV_ovr_0(zNear, zFar);
end;
public z_ClearDepthdNV_adr := GetFuncAdr('glClearDepthdNV');
public z_ClearDepthdNV_ovr_0 := GetFuncOrNil&<procedure(depth: real)>(z_ClearDepthdNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearDepthdNV(depth: real);
begin
z_ClearDepthdNV_ovr_0(depth);
end;
public z_DepthBoundsdNV_adr := GetFuncAdr('glDepthBoundsdNV');
public z_DepthBoundsdNV_ovr_0 := GetFuncOrNil&<procedure(zmin: real; zmax: real)>(z_DepthBoundsdNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthBoundsdNV(zmin: real; zmax: real);
begin
z_DepthBoundsdNV_ovr_0(zmin, zmax);
end;
end;
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);
public z_DrawTextureNV_adr := GetFuncAdr('glDrawTextureNV');
public z_DrawTextureNV_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; sampler: UInt32; x0: single; y0: single; x1: single; y1: single; z: single; s0: single; t0: single; s1: single; t1: single)>(z_DrawTextureNV_adr);
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);
begin
z_DrawTextureNV_ovr_0(texture, sampler, x0, y0, x1, y1, z, s0, t0, s1, t1);
end;
end;
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);
public z_DrawVkImageNV_adr := GetFuncAdr('glDrawVkImageNV');
public z_DrawVkImageNV_ovr_0 := GetFuncOrNil&<procedure(vkImage: UInt64; sampler: UInt32; x0: single; y0: single; x1: single; y1: single; z: single; s0: single; t0: single; s1: single; t1: single)>(z_DrawVkImageNV_adr);
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);
begin
z_DrawVkImageNV_ovr_0(vkImage, sampler, x0, y0, x1, y1, z, s0, t0, s1, t1);
end;
public z_GetVkProcAddrNV_adr := GetFuncAdr('glGetVkProcAddrNV');
public z_GetVkProcAddrNV_ovr_0 := GetFuncOrNil&<function(name: IntPtr): GLVULKANPROCNV>(z_GetVkProcAddrNV_adr);
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;
begin
Result := z_GetVkProcAddrNV_ovr_0(name);
end;
public z_WaitVkSemaphoreNV_adr := GetFuncAdr('glWaitVkSemaphoreNV');
public z_WaitVkSemaphoreNV_ovr_0 := GetFuncOrNil&<procedure(vkSemaphore: UInt64)>(z_WaitVkSemaphoreNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitVkSemaphoreNV(vkSemaphore: UInt64);
begin
z_WaitVkSemaphoreNV_ovr_0(vkSemaphore);
end;
public z_SignalVkSemaphoreNV_adr := GetFuncAdr('glSignalVkSemaphoreNV');
public z_SignalVkSemaphoreNV_ovr_0 := GetFuncOrNil&<procedure(vkSemaphore: UInt64)>(z_SignalVkSemaphoreNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalVkSemaphoreNV(vkSemaphore: UInt64);
begin
z_SignalVkSemaphoreNV_ovr_0(vkSemaphore);
end;
public z_SignalVkFenceNV_adr := GetFuncAdr('glSignalVkFenceNV');
public z_SignalVkFenceNV_ovr_0 := GetFuncOrNil&<procedure(vkFence: UInt64)>(z_SignalVkFenceNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalVkFenceNV(vkFence: UInt64);
begin
z_SignalVkFenceNV_ovr_0(vkFence);
end;
end;
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);
public z_MapControlPointsNV_adr := GetFuncAdr('glMapControlPointsNV');
public z_MapControlPointsNV_ovr_0 := GetFuncOrNil&<procedure(target: EvalTargetNV; index: UInt32; &type: MapTypeNV; ustride: Int32; vstride: Int32; uorder: Int32; vorder: Int32; &packed: boolean; points: IntPtr)>(z_MapControlPointsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapControlPointsNV(target: EvalTargetNV; index: UInt32; &type: MapTypeNV; ustride: Int32; vstride: Int32; uorder: Int32; vorder: Int32; &packed: boolean; points: IntPtr);
begin
z_MapControlPointsNV_ovr_0(target, index, &type, ustride, vstride, uorder, vorder, &packed, points);
end;
public z_MapParameterivNV_adr := GetFuncAdr('glMapParameterivNV');
public z_MapParameterivNV_ovr_0 := GetFuncOrNil&<procedure(target: EvalTargetNV; pname: MapParameterNV; var ¶ms: Int32)>(z_MapParameterivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapParameterivNV(target: EvalTargetNV; pname: MapParameterNV; ¶ms: array of Int32);
begin
z_MapParameterivNV_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapParameterivNV(target: EvalTargetNV; pname: MapParameterNV; var ¶ms: Int32);
begin
z_MapParameterivNV_ovr_0(target, pname, ¶ms);
end;
public z_MapParameterivNV_ovr_2 := GetFuncOrNil&<procedure(target: EvalTargetNV; pname: MapParameterNV; ¶ms: IntPtr)>(z_MapParameterivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapParameterivNV(target: EvalTargetNV; pname: MapParameterNV; ¶ms: IntPtr);
begin
z_MapParameterivNV_ovr_2(target, pname, ¶ms);
end;
public z_MapParameterfvNV_adr := GetFuncAdr('glMapParameterfvNV');
public z_MapParameterfvNV_ovr_0 := GetFuncOrNil&<procedure(target: EvalTargetNV; pname: MapParameterNV; var ¶ms: single)>(z_MapParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapParameterfvNV(target: EvalTargetNV; pname: MapParameterNV; ¶ms: array of single);
begin
z_MapParameterfvNV_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapParameterfvNV(target: EvalTargetNV; pname: MapParameterNV; var ¶ms: single);
begin
z_MapParameterfvNV_ovr_0(target, pname, ¶ms);
end;
public z_MapParameterfvNV_ovr_2 := GetFuncOrNil&<procedure(target: EvalTargetNV; pname: MapParameterNV; ¶ms: IntPtr)>(z_MapParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapParameterfvNV(target: EvalTargetNV; pname: MapParameterNV; ¶ms: IntPtr);
begin
z_MapParameterfvNV_ovr_2(target, pname, ¶ms);
end;
public z_GetMapControlPointsNV_adr := GetFuncAdr('glGetMapControlPointsNV');
public z_GetMapControlPointsNV_ovr_0 := GetFuncOrNil&<procedure(target: EvalTargetNV; index: UInt32; &type: MapTypeNV; ustride: Int32; vstride: Int32; &packed: boolean; points: IntPtr)>(z_GetMapControlPointsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapControlPointsNV(target: EvalTargetNV; index: UInt32; &type: MapTypeNV; ustride: Int32; vstride: Int32; &packed: boolean; points: IntPtr);
begin
z_GetMapControlPointsNV_ovr_0(target, index, &type, ustride, vstride, &packed, points);
end;
public z_GetMapParameterivNV_adr := GetFuncAdr('glGetMapParameterivNV');
public z_GetMapParameterivNV_ovr_0 := GetFuncOrNil&<procedure(target: EvalTargetNV; pname: MapParameterNV; var ¶ms: Int32)>(z_GetMapParameterivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapParameterivNV(target: EvalTargetNV; pname: MapParameterNV; ¶ms: array of Int32);
begin
z_GetMapParameterivNV_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapParameterivNV(target: EvalTargetNV; pname: MapParameterNV; var ¶ms: Int32);
begin
z_GetMapParameterivNV_ovr_0(target, pname, ¶ms);
end;
public z_GetMapParameterivNV_ovr_2 := GetFuncOrNil&<procedure(target: EvalTargetNV; pname: MapParameterNV; ¶ms: IntPtr)>(z_GetMapParameterivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapParameterivNV(target: EvalTargetNV; pname: MapParameterNV; ¶ms: IntPtr);
begin
z_GetMapParameterivNV_ovr_2(target, pname, ¶ms);
end;
public z_GetMapParameterfvNV_adr := GetFuncAdr('glGetMapParameterfvNV');
public z_GetMapParameterfvNV_ovr_0 := GetFuncOrNil&<procedure(target: EvalTargetNV; pname: MapParameterNV; var ¶ms: single)>(z_GetMapParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapParameterfvNV(target: EvalTargetNV; pname: MapParameterNV; ¶ms: array of single);
begin
z_GetMapParameterfvNV_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapParameterfvNV(target: EvalTargetNV; pname: MapParameterNV; var ¶ms: single);
begin
z_GetMapParameterfvNV_ovr_0(target, pname, ¶ms);
end;
public z_GetMapParameterfvNV_ovr_2 := GetFuncOrNil&<procedure(target: EvalTargetNV; pname: MapParameterNV; ¶ms: IntPtr)>(z_GetMapParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapParameterfvNV(target: EvalTargetNV; pname: MapParameterNV; ¶ms: IntPtr);
begin
z_GetMapParameterfvNV_ovr_2(target, pname, ¶ms);
end;
public z_GetMapAttribParameterivNV_adr := GetFuncAdr('glGetMapAttribParameterivNV');
public z_GetMapAttribParameterivNV_ovr_0 := GetFuncOrNil&<procedure(target: EvalTargetNV; index: UInt32; pname: MapAttribParameterNV; var ¶ms: Int32)>(z_GetMapAttribParameterivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapAttribParameterivNV(target: EvalTargetNV; index: UInt32; pname: MapAttribParameterNV; ¶ms: array of Int32);
begin
z_GetMapAttribParameterivNV_ovr_0(target, index, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapAttribParameterivNV(target: EvalTargetNV; index: UInt32; pname: MapAttribParameterNV; var ¶ms: Int32);
begin
z_GetMapAttribParameterivNV_ovr_0(target, index, pname, ¶ms);
end;
public z_GetMapAttribParameterivNV_ovr_2 := GetFuncOrNil&<procedure(target: EvalTargetNV; index: UInt32; pname: MapAttribParameterNV; ¶ms: IntPtr)>(z_GetMapAttribParameterivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapAttribParameterivNV(target: EvalTargetNV; index: UInt32; pname: MapAttribParameterNV; ¶ms: IntPtr);
begin
z_GetMapAttribParameterivNV_ovr_2(target, index, pname, ¶ms);
end;
public z_GetMapAttribParameterfvNV_adr := GetFuncAdr('glGetMapAttribParameterfvNV');
public z_GetMapAttribParameterfvNV_ovr_0 := GetFuncOrNil&<procedure(target: EvalTargetNV; index: UInt32; pname: MapAttribParameterNV; var ¶ms: single)>(z_GetMapAttribParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapAttribParameterfvNV(target: EvalTargetNV; index: UInt32; pname: MapAttribParameterNV; ¶ms: array of single);
begin
z_GetMapAttribParameterfvNV_ovr_0(target, index, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapAttribParameterfvNV(target: EvalTargetNV; index: UInt32; pname: MapAttribParameterNV; var ¶ms: single);
begin
z_GetMapAttribParameterfvNV_ovr_0(target, index, pname, ¶ms);
end;
public z_GetMapAttribParameterfvNV_ovr_2 := GetFuncOrNil&<procedure(target: EvalTargetNV; index: UInt32; pname: MapAttribParameterNV; ¶ms: IntPtr)>(z_GetMapAttribParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapAttribParameterfvNV(target: EvalTargetNV; index: UInt32; pname: MapAttribParameterNV; ¶ms: IntPtr);
begin
z_GetMapAttribParameterfvNV_ovr_2(target, index, pname, ¶ms);
end;
public z_EvalMapsNV_adr := GetFuncAdr('glEvalMapsNV');
public z_EvalMapsNV_ovr_0 := GetFuncOrNil&<procedure(target: EvalTargetNV; mode: EvalMapsModeNV)>(z_EvalMapsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalMapsNV(target: EvalTargetNV; mode: EvalMapsModeNV);
begin
z_EvalMapsNV_ovr_0(target, mode);
end;
end;
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);
public z_GetMultisamplefvNV_adr := GetFuncAdr('glGetMultisamplefvNV');
public z_GetMultisamplefvNV_ovr_0 := GetFuncOrNil&<procedure(pname: GetMultisamplePNameNV; index: UInt32; var val: single)>(z_GetMultisamplefvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultisamplefvNV(pname: GetMultisamplePNameNV; index: UInt32; val: array of single);
begin
z_GetMultisamplefvNV_ovr_0(pname, index, val[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultisamplefvNV(pname: GetMultisamplePNameNV; index: UInt32; var val: single);
begin
z_GetMultisamplefvNV_ovr_0(pname, index, val);
end;
public z_GetMultisamplefvNV_ovr_2 := GetFuncOrNil&<procedure(pname: GetMultisamplePNameNV; index: UInt32; val: IntPtr)>(z_GetMultisamplefvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMultisamplefvNV(pname: GetMultisamplePNameNV; index: UInt32; val: IntPtr);
begin
z_GetMultisamplefvNV_ovr_2(pname, index, val);
end;
public z_SampleMaskIndexedNV_adr := GetFuncAdr('glSampleMaskIndexedNV');
public z_SampleMaskIndexedNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; mask: DummyFlags)>(z_SampleMaskIndexedNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SampleMaskIndexedNV(index: UInt32; mask: DummyFlags);
begin
z_SampleMaskIndexedNV_ovr_0(index, mask);
end;
public z_TexRenderbufferNV_adr := GetFuncAdr('glTexRenderbufferNV');
public z_TexRenderbufferNV_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; renderbuffer: UInt32)>(z_TexRenderbufferNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexRenderbufferNV(target: TextureTarget; renderbuffer: UInt32);
begin
z_TexRenderbufferNV_ovr_0(target, renderbuffer);
end;
end;
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);
public z_DeleteFencesNV_adr := GetFuncAdr('glDeleteFencesNV');
public z_DeleteFencesNV_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var fences: UInt32)>(z_DeleteFencesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFencesNV(n: Int32; fences: array of UInt32);
begin
z_DeleteFencesNV_ovr_0(n, fences[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFencesNV(n: Int32; var fences: UInt32);
begin
z_DeleteFencesNV_ovr_0(n, fences);
end;
public z_DeleteFencesNV_ovr_2 := GetFuncOrNil&<procedure(n: Int32; fences: IntPtr)>(z_DeleteFencesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteFencesNV(n: Int32; fences: IntPtr);
begin
z_DeleteFencesNV_ovr_2(n, fences);
end;
public z_GenFencesNV_adr := GetFuncAdr('glGenFencesNV');
public z_GenFencesNV_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var fences: UInt32)>(z_GenFencesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenFencesNV(n: Int32; fences: array of UInt32);
begin
z_GenFencesNV_ovr_0(n, fences[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenFencesNV(n: Int32; var fences: UInt32);
begin
z_GenFencesNV_ovr_0(n, fences);
end;
public z_GenFencesNV_ovr_2 := GetFuncOrNil&<procedure(n: Int32; fences: IntPtr)>(z_GenFencesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenFencesNV(n: Int32; fences: IntPtr);
begin
z_GenFencesNV_ovr_2(n, fences);
end;
public z_IsFenceNV_adr := GetFuncAdr('glIsFenceNV');
public z_IsFenceNV_ovr_0 := GetFuncOrNil&<function(fence: UInt32): boolean>(z_IsFenceNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsFenceNV(fence: UInt32): boolean;
begin
Result := z_IsFenceNV_ovr_0(fence);
end;
public z_TestFenceNV_adr := GetFuncAdr('glTestFenceNV');
public z_TestFenceNV_ovr_0 := GetFuncOrNil&<function(fence: UInt32): boolean>(z_TestFenceNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function TestFenceNV(fence: UInt32): boolean;
begin
Result := z_TestFenceNV_ovr_0(fence);
end;
public z_GetFenceivNV_adr := GetFuncAdr('glGetFenceivNV');
public z_GetFenceivNV_ovr_0 := GetFuncOrNil&<procedure(fence: UInt32; pname: FenceParameterNameNV; var ¶ms: Int32)>(z_GetFenceivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFenceivNV(fence: UInt32; pname: FenceParameterNameNV; ¶ms: array of Int32);
begin
z_GetFenceivNV_ovr_0(fence, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFenceivNV(fence: UInt32; pname: FenceParameterNameNV; var ¶ms: Int32);
begin
z_GetFenceivNV_ovr_0(fence, pname, ¶ms);
end;
public z_GetFenceivNV_ovr_2 := GetFuncOrNil&<procedure(fence: UInt32; pname: FenceParameterNameNV; ¶ms: IntPtr)>(z_GetFenceivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFenceivNV(fence: UInt32; pname: FenceParameterNameNV; ¶ms: IntPtr);
begin
z_GetFenceivNV_ovr_2(fence, pname, ¶ms);
end;
public z_FinishFenceNV_adr := GetFuncAdr('glFinishFenceNV');
public z_FinishFenceNV_ovr_0 := GetFuncOrNil&<procedure(fence: UInt32)>(z_FinishFenceNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FinishFenceNV(fence: UInt32);
begin
z_FinishFenceNV_ovr_0(fence);
end;
public z_SetFenceNV_adr := GetFuncAdr('glSetFenceNV');
public z_SetFenceNV_ovr_0 := GetFuncOrNil&<procedure(fence: UInt32; condition: FenceConditionNV)>(z_SetFenceNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SetFenceNV(fence: UInt32; condition: FenceConditionNV);
begin
z_SetFenceNV_ovr_0(fence, condition);
end;
end;
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);
public z_FragmentCoverageColorNV_adr := GetFuncAdr('glFragmentCoverageColorNV');
public z_FragmentCoverageColorNV_ovr_0 := GetFuncOrNil&<procedure(color: UInt32)>(z_FragmentCoverageColorNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentCoverageColorNV(color: UInt32);
begin
z_FragmentCoverageColorNV_ovr_0(color);
end;
end;
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);
public z_ProgramNamedParameter4fNV_adr := GetFuncAdr('glProgramNamedParameter4fNV');
public z_ProgramNamedParameter4fNV_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; len: Int32; var name: Byte; x: single; y: single; z: single; w: single)>(z_ProgramNamedParameter4fNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4fNV(id: UInt32; len: Int32; name: array of Byte; x: single; y: single; z: single; w: single);
begin
z_ProgramNamedParameter4fNV_ovr_0(id, len, name[0], x, y, z, w);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4fNV(id: UInt32; len: Int32; var name: Byte; x: single; y: single; z: single; w: single);
begin
z_ProgramNamedParameter4fNV_ovr_0(id, len, name, x, y, z, w);
end;
public z_ProgramNamedParameter4fNV_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; len: Int32; name: IntPtr; x: single; y: single; z: single; w: single)>(z_ProgramNamedParameter4fNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4fNV(id: UInt32; len: Int32; name: IntPtr; x: single; y: single; z: single; w: single);
begin
z_ProgramNamedParameter4fNV_ovr_2(id, len, name, x, y, z, w);
end;
public z_ProgramNamedParameter4fvNV_adr := GetFuncAdr('glProgramNamedParameter4fvNV');
public z_ProgramNamedParameter4fvNV_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; len: Int32; var name: Byte; var v: single)>(z_ProgramNamedParameter4fvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4fvNV(id: UInt32; len: Int32; name: array of Byte; v: array of single);
begin
z_ProgramNamedParameter4fvNV_ovr_0(id, len, name[0], v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4fvNV(id: UInt32; len: Int32; name: array of Byte; var v: single);
begin
z_ProgramNamedParameter4fvNV_ovr_0(id, len, name[0], v);
end;
public z_ProgramNamedParameter4fvNV_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; len: Int32; var name: Byte; v: IntPtr)>(z_ProgramNamedParameter4fvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4fvNV(id: UInt32; len: Int32; name: array of Byte; v: IntPtr);
begin
z_ProgramNamedParameter4fvNV_ovr_2(id, len, name[0], v);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4fvNV(id: UInt32; len: Int32; var name: Byte; v: array of single);
begin
z_ProgramNamedParameter4fvNV_ovr_0(id, len, name, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4fvNV(id: UInt32; len: Int32; var name: Byte; var v: single);
begin
z_ProgramNamedParameter4fvNV_ovr_0(id, len, name, v);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4fvNV(id: UInt32; len: Int32; var name: Byte; v: IntPtr);
begin
z_ProgramNamedParameter4fvNV_ovr_2(id, len, name, v);
end;
public z_ProgramNamedParameter4fvNV_ovr_6 := GetFuncOrNil&<procedure(id: UInt32; len: Int32; name: IntPtr; var v: single)>(z_ProgramNamedParameter4fvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4fvNV(id: UInt32; len: Int32; name: IntPtr; v: array of single);
begin
z_ProgramNamedParameter4fvNV_ovr_6(id, len, name, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4fvNV(id: UInt32; len: Int32; name: IntPtr; var v: single);
begin
z_ProgramNamedParameter4fvNV_ovr_6(id, len, name, v);
end;
public z_ProgramNamedParameter4fvNV_ovr_8 := GetFuncOrNil&<procedure(id: UInt32; len: Int32; name: IntPtr; v: IntPtr)>(z_ProgramNamedParameter4fvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4fvNV(id: UInt32; len: Int32; name: IntPtr; v: IntPtr);
begin
z_ProgramNamedParameter4fvNV_ovr_8(id, len, name, v);
end;
public z_ProgramNamedParameter4dNV_adr := GetFuncAdr('glProgramNamedParameter4dNV');
public z_ProgramNamedParameter4dNV_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; len: Int32; var name: Byte; x: real; y: real; z: real; w: real)>(z_ProgramNamedParameter4dNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4dNV(id: UInt32; len: Int32; name: array of Byte; x: real; y: real; z: real; w: real);
begin
z_ProgramNamedParameter4dNV_ovr_0(id, len, name[0], x, y, z, w);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4dNV(id: UInt32; len: Int32; var name: Byte; x: real; y: real; z: real; w: real);
begin
z_ProgramNamedParameter4dNV_ovr_0(id, len, name, x, y, z, w);
end;
public z_ProgramNamedParameter4dNV_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; len: Int32; name: IntPtr; x: real; y: real; z: real; w: real)>(z_ProgramNamedParameter4dNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4dNV(id: UInt32; len: Int32; name: IntPtr; x: real; y: real; z: real; w: real);
begin
z_ProgramNamedParameter4dNV_ovr_2(id, len, name, x, y, z, w);
end;
public z_ProgramNamedParameter4dvNV_adr := GetFuncAdr('glProgramNamedParameter4dvNV');
public z_ProgramNamedParameter4dvNV_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; len: Int32; var name: Byte; var v: real)>(z_ProgramNamedParameter4dvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4dvNV(id: UInt32; len: Int32; name: array of Byte; v: array of real);
begin
z_ProgramNamedParameter4dvNV_ovr_0(id, len, name[0], v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4dvNV(id: UInt32; len: Int32; name: array of Byte; var v: real);
begin
z_ProgramNamedParameter4dvNV_ovr_0(id, len, name[0], v);
end;
public z_ProgramNamedParameter4dvNV_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; len: Int32; var name: Byte; v: IntPtr)>(z_ProgramNamedParameter4dvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4dvNV(id: UInt32; len: Int32; name: array of Byte; v: IntPtr);
begin
z_ProgramNamedParameter4dvNV_ovr_2(id, len, name[0], v);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4dvNV(id: UInt32; len: Int32; var name: Byte; v: array of real);
begin
z_ProgramNamedParameter4dvNV_ovr_0(id, len, name, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4dvNV(id: UInt32; len: Int32; var name: Byte; var v: real);
begin
z_ProgramNamedParameter4dvNV_ovr_0(id, len, name, v);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4dvNV(id: UInt32; len: Int32; var name: Byte; v: IntPtr);
begin
z_ProgramNamedParameter4dvNV_ovr_2(id, len, name, v);
end;
public z_ProgramNamedParameter4dvNV_ovr_6 := GetFuncOrNil&<procedure(id: UInt32; len: Int32; name: IntPtr; var v: real)>(z_ProgramNamedParameter4dvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4dvNV(id: UInt32; len: Int32; name: IntPtr; v: array of real);
begin
z_ProgramNamedParameter4dvNV_ovr_6(id, len, name, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4dvNV(id: UInt32; len: Int32; name: IntPtr; var v: real);
begin
z_ProgramNamedParameter4dvNV_ovr_6(id, len, name, v);
end;
public z_ProgramNamedParameter4dvNV_ovr_8 := GetFuncOrNil&<procedure(id: UInt32; len: Int32; name: IntPtr; v: IntPtr)>(z_ProgramNamedParameter4dvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramNamedParameter4dvNV(id: UInt32; len: Int32; name: IntPtr; v: IntPtr);
begin
z_ProgramNamedParameter4dvNV_ovr_8(id, len, name, v);
end;
public z_GetProgramNamedParameterfvNV_adr := GetFuncAdr('glGetProgramNamedParameterfvNV');
public z_GetProgramNamedParameterfvNV_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; len: Int32; var name: Byte; var ¶ms: single)>(z_GetProgramNamedParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterfvNV(id: UInt32; len: Int32; name: array of Byte; ¶ms: array of single);
begin
z_GetProgramNamedParameterfvNV_ovr_0(id, len, name[0], ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterfvNV(id: UInt32; len: Int32; name: array of Byte; var ¶ms: single);
begin
z_GetProgramNamedParameterfvNV_ovr_0(id, len, name[0], ¶ms);
end;
public z_GetProgramNamedParameterfvNV_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; len: Int32; var name: Byte; ¶ms: IntPtr)>(z_GetProgramNamedParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterfvNV(id: UInt32; len: Int32; name: array of Byte; ¶ms: IntPtr);
begin
z_GetProgramNamedParameterfvNV_ovr_2(id, len, name[0], ¶ms);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterfvNV(id: UInt32; len: Int32; var name: Byte; ¶ms: array of single);
begin
z_GetProgramNamedParameterfvNV_ovr_0(id, len, name, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterfvNV(id: UInt32; len: Int32; var name: Byte; var ¶ms: single);
begin
z_GetProgramNamedParameterfvNV_ovr_0(id, len, name, ¶ms);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterfvNV(id: UInt32; len: Int32; var name: Byte; ¶ms: IntPtr);
begin
z_GetProgramNamedParameterfvNV_ovr_2(id, len, name, ¶ms);
end;
public z_GetProgramNamedParameterfvNV_ovr_6 := GetFuncOrNil&<procedure(id: UInt32; len: Int32; name: IntPtr; var ¶ms: single)>(z_GetProgramNamedParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterfvNV(id: UInt32; len: Int32; name: IntPtr; ¶ms: array of single);
begin
z_GetProgramNamedParameterfvNV_ovr_6(id, len, name, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterfvNV(id: UInt32; len: Int32; name: IntPtr; var ¶ms: single);
begin
z_GetProgramNamedParameterfvNV_ovr_6(id, len, name, ¶ms);
end;
public z_GetProgramNamedParameterfvNV_ovr_8 := GetFuncOrNil&<procedure(id: UInt32; len: Int32; name: IntPtr; ¶ms: IntPtr)>(z_GetProgramNamedParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterfvNV(id: UInt32; len: Int32; name: IntPtr; ¶ms: IntPtr);
begin
z_GetProgramNamedParameterfvNV_ovr_8(id, len, name, ¶ms);
end;
public z_GetProgramNamedParameterdvNV_adr := GetFuncAdr('glGetProgramNamedParameterdvNV');
public z_GetProgramNamedParameterdvNV_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; len: Int32; var name: Byte; var ¶ms: real)>(z_GetProgramNamedParameterdvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterdvNV(id: UInt32; len: Int32; name: array of Byte; ¶ms: array of real);
begin
z_GetProgramNamedParameterdvNV_ovr_0(id, len, name[0], ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterdvNV(id: UInt32; len: Int32; name: array of Byte; var ¶ms: real);
begin
z_GetProgramNamedParameterdvNV_ovr_0(id, len, name[0], ¶ms);
end;
public z_GetProgramNamedParameterdvNV_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; len: Int32; var name: Byte; ¶ms: IntPtr)>(z_GetProgramNamedParameterdvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterdvNV(id: UInt32; len: Int32; name: array of Byte; ¶ms: IntPtr);
begin
z_GetProgramNamedParameterdvNV_ovr_2(id, len, name[0], ¶ms);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterdvNV(id: UInt32; len: Int32; var name: Byte; ¶ms: array of real);
begin
z_GetProgramNamedParameterdvNV_ovr_0(id, len, name, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterdvNV(id: UInt32; len: Int32; var name: Byte; var ¶ms: real);
begin
z_GetProgramNamedParameterdvNV_ovr_0(id, len, name, ¶ms);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterdvNV(id: UInt32; len: Int32; var name: Byte; ¶ms: IntPtr);
begin
z_GetProgramNamedParameterdvNV_ovr_2(id, len, name, ¶ms);
end;
public z_GetProgramNamedParameterdvNV_ovr_6 := GetFuncOrNil&<procedure(id: UInt32; len: Int32; name: IntPtr; var ¶ms: real)>(z_GetProgramNamedParameterdvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterdvNV(id: UInt32; len: Int32; name: IntPtr; ¶ms: array of real);
begin
z_GetProgramNamedParameterdvNV_ovr_6(id, len, name, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterdvNV(id: UInt32; len: Int32; name: IntPtr; var ¶ms: real);
begin
z_GetProgramNamedParameterdvNV_ovr_6(id, len, name, ¶ms);
end;
public z_GetProgramNamedParameterdvNV_ovr_8 := GetFuncOrNil&<procedure(id: UInt32; len: Int32; name: IntPtr; ¶ms: IntPtr)>(z_GetProgramNamedParameterdvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramNamedParameterdvNV(id: UInt32; len: Int32; name: IntPtr; ¶ms: IntPtr);
begin
z_GetProgramNamedParameterdvNV_ovr_8(id, len, name, ¶ms);
end;
end;
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);
public z_CoverageModulationTableNV_adr := GetFuncAdr('glCoverageModulationTableNV');
public z_CoverageModulationTableNV_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var v: single)>(z_CoverageModulationTableNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CoverageModulationTableNV(n: Int32; v: array of single);
begin
z_CoverageModulationTableNV_ovr_0(n, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CoverageModulationTableNV(n: Int32; var v: single);
begin
z_CoverageModulationTableNV_ovr_0(n, v);
end;
public z_CoverageModulationTableNV_ovr_2 := GetFuncOrNil&<procedure(n: Int32; v: IntPtr)>(z_CoverageModulationTableNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CoverageModulationTableNV(n: Int32; v: IntPtr);
begin
z_CoverageModulationTableNV_ovr_2(n, v);
end;
public z_GetCoverageModulationTableNV_adr := GetFuncAdr('glGetCoverageModulationTableNV');
public z_GetCoverageModulationTableNV_ovr_0 := GetFuncOrNil&<procedure(bufSize: Int32; var v: single)>(z_GetCoverageModulationTableNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCoverageModulationTableNV(bufSize: Int32; v: array of single);
begin
z_GetCoverageModulationTableNV_ovr_0(bufSize, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCoverageModulationTableNV(bufSize: Int32; var v: single);
begin
z_GetCoverageModulationTableNV_ovr_0(bufSize, v);
end;
public z_GetCoverageModulationTableNV_ovr_2 := GetFuncOrNil&<procedure(bufSize: Int32; v: IntPtr)>(z_GetCoverageModulationTableNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCoverageModulationTableNV(bufSize: Int32; v: IntPtr);
begin
z_GetCoverageModulationTableNV_ovr_2(bufSize, v);
end;
public z_CoverageModulationNV_adr := GetFuncAdr('glCoverageModulationNV');
public z_CoverageModulationNV_ovr_0 := GetFuncOrNil&<procedure(components: DummyEnum)>(z_CoverageModulationNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CoverageModulationNV(components: DummyEnum);
begin
z_CoverageModulationNV_ovr_0(components);
end;
end;
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);
public z_RenderbufferStorageMultisampleCoverageNV_adr := GetFuncAdr('glRenderbufferStorageMultisampleCoverageNV');
public z_RenderbufferStorageMultisampleCoverageNV_ovr_0 := GetFuncOrNil&<procedure(target: RenderbufferTarget; coverageSamples: Int32; colorSamples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32)>(z_RenderbufferStorageMultisampleCoverageNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RenderbufferStorageMultisampleCoverageNV(target: RenderbufferTarget; coverageSamples: Int32; colorSamples: Int32; _internalformat: InternalFormat; width: Int32; height: Int32);
begin
z_RenderbufferStorageMultisampleCoverageNV_ovr_0(target, coverageSamples, colorSamples, _internalformat, width, height);
end;
end;
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);
public z_ProgramVertexLimitNV_adr := GetFuncAdr('glProgramVertexLimitNV');
public z_ProgramVertexLimitNV_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; limit: Int32)>(z_ProgramVertexLimitNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramVertexLimitNV(target: ProgramTarget; limit: Int32);
begin
z_ProgramVertexLimitNV_ovr_0(target, limit);
end;
end;
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);
public z_ProgramLocalParameterI4iNV_adr := GetFuncAdr('glProgramLocalParameterI4iNV');
public z_ProgramLocalParameterI4iNV_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; x: Int32; y: Int32; z: Int32; w: Int32)>(z_ProgramLocalParameterI4iNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameterI4iNV(target: ProgramTarget; index: UInt32; x: Int32; y: Int32; z: Int32; w: Int32);
begin
z_ProgramLocalParameterI4iNV_ovr_0(target, index, x, y, z, w);
end;
public z_ProgramLocalParameterI4ivNV_adr := GetFuncAdr('glProgramLocalParameterI4ivNV');
public z_ProgramLocalParameterI4ivNV_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; var ¶ms: Int32)>(z_ProgramLocalParameterI4ivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameterI4ivNV(target: ProgramTarget; index: UInt32; ¶ms: array of Int32);
begin
z_ProgramLocalParameterI4ivNV_ovr_0(target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameterI4ivNV(target: ProgramTarget; index: UInt32; var ¶ms: Int32);
begin
z_ProgramLocalParameterI4ivNV_ovr_0(target, index, ¶ms);
end;
public z_ProgramLocalParameterI4ivNV_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_ProgramLocalParameterI4ivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameterI4ivNV(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_ProgramLocalParameterI4ivNV_ovr_2(target, index, ¶ms);
end;
public z_ProgramLocalParametersI4ivNV_adr := GetFuncAdr('glProgramLocalParametersI4ivNV');
public z_ProgramLocalParametersI4ivNV_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: Int32)>(z_ProgramLocalParametersI4ivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParametersI4ivNV(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: array of Int32);
begin
z_ProgramLocalParametersI4ivNV_ovr_0(target, index, count, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParametersI4ivNV(target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: Int32);
begin
z_ProgramLocalParametersI4ivNV_ovr_0(target, index, count, ¶ms);
end;
public z_ProgramLocalParametersI4ivNV_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr)>(z_ProgramLocalParametersI4ivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParametersI4ivNV(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr);
begin
z_ProgramLocalParametersI4ivNV_ovr_2(target, index, count, ¶ms);
end;
public z_ProgramLocalParameterI4uiNV_adr := GetFuncAdr('glProgramLocalParameterI4uiNV');
public z_ProgramLocalParameterI4uiNV_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; x: UInt32; y: UInt32; z: UInt32; w: UInt32)>(z_ProgramLocalParameterI4uiNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameterI4uiNV(target: ProgramTarget; index: UInt32; x: UInt32; y: UInt32; z: UInt32; w: UInt32);
begin
z_ProgramLocalParameterI4uiNV_ovr_0(target, index, x, y, z, w);
end;
public z_ProgramLocalParameterI4uivNV_adr := GetFuncAdr('glProgramLocalParameterI4uivNV');
public z_ProgramLocalParameterI4uivNV_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; var ¶ms: UInt32)>(z_ProgramLocalParameterI4uivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameterI4uivNV(target: ProgramTarget; index: UInt32; ¶ms: array of UInt32);
begin
z_ProgramLocalParameterI4uivNV_ovr_0(target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameterI4uivNV(target: ProgramTarget; index: UInt32; var ¶ms: UInt32);
begin
z_ProgramLocalParameterI4uivNV_ovr_0(target, index, ¶ms);
end;
public z_ProgramLocalParameterI4uivNV_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_ProgramLocalParameterI4uivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParameterI4uivNV(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_ProgramLocalParameterI4uivNV_ovr_2(target, index, ¶ms);
end;
public z_ProgramLocalParametersI4uivNV_adr := GetFuncAdr('glProgramLocalParametersI4uivNV');
public z_ProgramLocalParametersI4uivNV_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: UInt32)>(z_ProgramLocalParametersI4uivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParametersI4uivNV(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: array of UInt32);
begin
z_ProgramLocalParametersI4uivNV_ovr_0(target, index, count, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParametersI4uivNV(target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: UInt32);
begin
z_ProgramLocalParametersI4uivNV_ovr_0(target, index, count, ¶ms);
end;
public z_ProgramLocalParametersI4uivNV_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr)>(z_ProgramLocalParametersI4uivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramLocalParametersI4uivNV(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr);
begin
z_ProgramLocalParametersI4uivNV_ovr_2(target, index, count, ¶ms);
end;
public z_ProgramEnvParameterI4iNV_adr := GetFuncAdr('glProgramEnvParameterI4iNV');
public z_ProgramEnvParameterI4iNV_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; x: Int32; y: Int32; z: Int32; w: Int32)>(z_ProgramEnvParameterI4iNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameterI4iNV(target: ProgramTarget; index: UInt32; x: Int32; y: Int32; z: Int32; w: Int32);
begin
z_ProgramEnvParameterI4iNV_ovr_0(target, index, x, y, z, w);
end;
public z_ProgramEnvParameterI4ivNV_adr := GetFuncAdr('glProgramEnvParameterI4ivNV');
public z_ProgramEnvParameterI4ivNV_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; var ¶ms: Int32)>(z_ProgramEnvParameterI4ivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameterI4ivNV(target: ProgramTarget; index: UInt32; ¶ms: array of Int32);
begin
z_ProgramEnvParameterI4ivNV_ovr_0(target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameterI4ivNV(target: ProgramTarget; index: UInt32; var ¶ms: Int32);
begin
z_ProgramEnvParameterI4ivNV_ovr_0(target, index, ¶ms);
end;
public z_ProgramEnvParameterI4ivNV_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_ProgramEnvParameterI4ivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameterI4ivNV(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_ProgramEnvParameterI4ivNV_ovr_2(target, index, ¶ms);
end;
public z_ProgramEnvParametersI4ivNV_adr := GetFuncAdr('glProgramEnvParametersI4ivNV');
public z_ProgramEnvParametersI4ivNV_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: Int32)>(z_ProgramEnvParametersI4ivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParametersI4ivNV(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: array of Int32);
begin
z_ProgramEnvParametersI4ivNV_ovr_0(target, index, count, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParametersI4ivNV(target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: Int32);
begin
z_ProgramEnvParametersI4ivNV_ovr_0(target, index, count, ¶ms);
end;
public z_ProgramEnvParametersI4ivNV_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr)>(z_ProgramEnvParametersI4ivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParametersI4ivNV(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr);
begin
z_ProgramEnvParametersI4ivNV_ovr_2(target, index, count, ¶ms);
end;
public z_ProgramEnvParameterI4uiNV_adr := GetFuncAdr('glProgramEnvParameterI4uiNV');
public z_ProgramEnvParameterI4uiNV_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; x: UInt32; y: UInt32; z: UInt32; w: UInt32)>(z_ProgramEnvParameterI4uiNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameterI4uiNV(target: ProgramTarget; index: UInt32; x: UInt32; y: UInt32; z: UInt32; w: UInt32);
begin
z_ProgramEnvParameterI4uiNV_ovr_0(target, index, x, y, z, w);
end;
public z_ProgramEnvParameterI4uivNV_adr := GetFuncAdr('glProgramEnvParameterI4uivNV');
public z_ProgramEnvParameterI4uivNV_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; var ¶ms: UInt32)>(z_ProgramEnvParameterI4uivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameterI4uivNV(target: ProgramTarget; index: UInt32; ¶ms: array of UInt32);
begin
z_ProgramEnvParameterI4uivNV_ovr_0(target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameterI4uivNV(target: ProgramTarget; index: UInt32; var ¶ms: UInt32);
begin
z_ProgramEnvParameterI4uivNV_ovr_0(target, index, ¶ms);
end;
public z_ProgramEnvParameterI4uivNV_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_ProgramEnvParameterI4uivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParameterI4uivNV(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_ProgramEnvParameterI4uivNV_ovr_2(target, index, ¶ms);
end;
public z_ProgramEnvParametersI4uivNV_adr := GetFuncAdr('glProgramEnvParametersI4uivNV');
public z_ProgramEnvParametersI4uivNV_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: UInt32)>(z_ProgramEnvParametersI4uivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParametersI4uivNV(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: array of UInt32);
begin
z_ProgramEnvParametersI4uivNV_ovr_0(target, index, count, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParametersI4uivNV(target: ProgramTarget; index: UInt32; count: Int32; var ¶ms: UInt32);
begin
z_ProgramEnvParametersI4uivNV_ovr_0(target, index, count, ¶ms);
end;
public z_ProgramEnvParametersI4uivNV_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr)>(z_ProgramEnvParametersI4uivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramEnvParametersI4uivNV(target: ProgramTarget; index: UInt32; count: Int32; ¶ms: IntPtr);
begin
z_ProgramEnvParametersI4uivNV_ovr_2(target, index, count, ¶ms);
end;
public z_GetProgramLocalParameterIivNV_adr := GetFuncAdr('glGetProgramLocalParameterIivNV');
public z_GetProgramLocalParameterIivNV_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; var ¶ms: Int32)>(z_GetProgramLocalParameterIivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterIivNV(target: ProgramTarget; index: UInt32; ¶ms: array of Int32);
begin
z_GetProgramLocalParameterIivNV_ovr_0(target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterIivNV(target: ProgramTarget; index: UInt32; var ¶ms: Int32);
begin
z_GetProgramLocalParameterIivNV_ovr_0(target, index, ¶ms);
end;
public z_GetProgramLocalParameterIivNV_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_GetProgramLocalParameterIivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterIivNV(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_GetProgramLocalParameterIivNV_ovr_2(target, index, ¶ms);
end;
public z_GetProgramLocalParameterIuivNV_adr := GetFuncAdr('glGetProgramLocalParameterIuivNV');
public z_GetProgramLocalParameterIuivNV_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; var ¶ms: UInt32)>(z_GetProgramLocalParameterIuivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterIuivNV(target: ProgramTarget; index: UInt32; ¶ms: array of UInt32);
begin
z_GetProgramLocalParameterIuivNV_ovr_0(target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterIuivNV(target: ProgramTarget; index: UInt32; var ¶ms: UInt32);
begin
z_GetProgramLocalParameterIuivNV_ovr_0(target, index, ¶ms);
end;
public z_GetProgramLocalParameterIuivNV_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_GetProgramLocalParameterIuivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramLocalParameterIuivNV(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_GetProgramLocalParameterIuivNV_ovr_2(target, index, ¶ms);
end;
public z_GetProgramEnvParameterIivNV_adr := GetFuncAdr('glGetProgramEnvParameterIivNV');
public z_GetProgramEnvParameterIivNV_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; var ¶ms: Int32)>(z_GetProgramEnvParameterIivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterIivNV(target: ProgramTarget; index: UInt32; ¶ms: array of Int32);
begin
z_GetProgramEnvParameterIivNV_ovr_0(target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterIivNV(target: ProgramTarget; index: UInt32; var ¶ms: Int32);
begin
z_GetProgramEnvParameterIivNV_ovr_0(target, index, ¶ms);
end;
public z_GetProgramEnvParameterIivNV_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_GetProgramEnvParameterIivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterIivNV(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_GetProgramEnvParameterIivNV_ovr_2(target, index, ¶ms);
end;
public z_GetProgramEnvParameterIuivNV_adr := GetFuncAdr('glGetProgramEnvParameterIuivNV');
public z_GetProgramEnvParameterIuivNV_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; var ¶ms: UInt32)>(z_GetProgramEnvParameterIuivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterIuivNV(target: ProgramTarget; index: UInt32; ¶ms: array of UInt32);
begin
z_GetProgramEnvParameterIuivNV_ovr_0(target, index, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterIuivNV(target: ProgramTarget; index: UInt32; var ¶ms: UInt32);
begin
z_GetProgramEnvParameterIuivNV_ovr_0(target, index, ¶ms);
end;
public z_GetProgramEnvParameterIuivNV_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; index: UInt32; ¶ms: IntPtr)>(z_GetProgramEnvParameterIuivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramEnvParameterIuivNV(target: ProgramTarget; index: UInt32; ¶ms: IntPtr);
begin
z_GetProgramEnvParameterIuivNV_ovr_2(target, index, ¶ms);
end;
end;
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);
public z_ProgramSubroutineParametersuivNV_adr := GetFuncAdr('glProgramSubroutineParametersuivNV');
public z_ProgramSubroutineParametersuivNV_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; count: Int32; var ¶ms: UInt32)>(z_ProgramSubroutineParametersuivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramSubroutineParametersuivNV(target: DummyEnum; count: Int32; ¶ms: array of UInt32);
begin
z_ProgramSubroutineParametersuivNV_ovr_0(target, count, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramSubroutineParametersuivNV(target: DummyEnum; count: Int32; var ¶ms: UInt32);
begin
z_ProgramSubroutineParametersuivNV_ovr_0(target, count, ¶ms);
end;
public z_ProgramSubroutineParametersuivNV_ovr_2 := GetFuncOrNil&<procedure(target: DummyEnum; count: Int32; ¶ms: IntPtr)>(z_ProgramSubroutineParametersuivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramSubroutineParametersuivNV(target: DummyEnum; count: Int32; ¶ms: IntPtr);
begin
z_ProgramSubroutineParametersuivNV_ovr_2(target, count, ¶ms);
end;
public z_GetProgramSubroutineParameteruivNV_adr := GetFuncAdr('glGetProgramSubroutineParameteruivNV');
public z_GetProgramSubroutineParameteruivNV_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; var param: UInt32)>(z_GetProgramSubroutineParameteruivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramSubroutineParameteruivNV(target: DummyEnum; index: UInt32; param: array of UInt32);
begin
z_GetProgramSubroutineParameteruivNV_ovr_0(target, index, param[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramSubroutineParameteruivNV(target: DummyEnum; index: UInt32; var param: UInt32);
begin
z_GetProgramSubroutineParameteruivNV_ovr_0(target, index, param);
end;
public z_GetProgramSubroutineParameteruivNV_ovr_2 := GetFuncOrNil&<procedure(target: DummyEnum; index: UInt32; param: IntPtr)>(z_GetProgramSubroutineParameteruivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramSubroutineParameteruivNV(target: DummyEnum; index: UInt32; param: IntPtr);
begin
z_GetProgramSubroutineParameteruivNV_ovr_2(target, index, param);
end;
end;
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);
public z_Uniform1i64NV_adr := GetFuncAdr('glUniform1i64NV');
public z_Uniform1i64NV_ovr_0 := GetFuncOrNil&<procedure(location: Int32; x: Int64)>(z_Uniform1i64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1i64NV(location: Int32; x: Int64);
begin
z_Uniform1i64NV_ovr_0(location, x);
end;
public z_Uniform2i64NV_adr := GetFuncAdr('glUniform2i64NV');
public z_Uniform2i64NV_ovr_0 := GetFuncOrNil&<procedure(location: Int32; x: Int64; y: Int64)>(z_Uniform2i64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2i64NV(location: Int32; x: Int64; y: Int64);
begin
z_Uniform2i64NV_ovr_0(location, x, y);
end;
public z_Uniform3i64NV_adr := GetFuncAdr('glUniform3i64NV');
public z_Uniform3i64NV_ovr_0 := GetFuncOrNil&<procedure(location: Int32; x: Int64; y: Int64; z: Int64)>(z_Uniform3i64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3i64NV(location: Int32; x: Int64; y: Int64; z: Int64);
begin
z_Uniform3i64NV_ovr_0(location, x, y, z);
end;
public z_Uniform4i64NV_adr := GetFuncAdr('glUniform4i64NV');
public z_Uniform4i64NV_ovr_0 := GetFuncOrNil&<procedure(location: Int32; x: Int64; y: Int64; z: Int64; w: Int64)>(z_Uniform4i64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4i64NV(location: Int32; x: Int64; y: Int64; z: Int64; w: Int64);
begin
z_Uniform4i64NV_ovr_0(location, x, y, z, w);
end;
public z_Uniform1i64vNV_adr := GetFuncAdr('glUniform1i64vNV');
public z_Uniform1i64vNV_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Int64)>(z_Uniform1i64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1i64vNV(location: Int32; count: Int32; value: array of Int64);
begin
z_Uniform1i64vNV_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1i64vNV(location: Int32; count: Int32; var value: Int64);
begin
z_Uniform1i64vNV_ovr_0(location, count, value);
end;
public z_Uniform1i64vNV_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform1i64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1i64vNV(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform1i64vNV_ovr_2(location, count, value);
end;
public z_Uniform2i64vNV_adr := GetFuncAdr('glUniform2i64vNV');
public z_Uniform2i64vNV_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Int64)>(z_Uniform2i64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2i64vNV(location: Int32; count: Int32; value: array of Int64);
begin
z_Uniform2i64vNV_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2i64vNV(location: Int32; count: Int32; var value: Int64);
begin
z_Uniform2i64vNV_ovr_0(location, count, value);
end;
public z_Uniform2i64vNV_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform2i64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2i64vNV(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform2i64vNV_ovr_2(location, count, value);
end;
public z_Uniform3i64vNV_adr := GetFuncAdr('glUniform3i64vNV');
public z_Uniform3i64vNV_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Int64)>(z_Uniform3i64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3i64vNV(location: Int32; count: Int32; value: array of Int64);
begin
z_Uniform3i64vNV_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3i64vNV(location: Int32; count: Int32; var value: Int64);
begin
z_Uniform3i64vNV_ovr_0(location, count, value);
end;
public z_Uniform3i64vNV_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform3i64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3i64vNV(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform3i64vNV_ovr_2(location, count, value);
end;
public z_Uniform4i64vNV_adr := GetFuncAdr('glUniform4i64vNV');
public z_Uniform4i64vNV_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Int64)>(z_Uniform4i64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4i64vNV(location: Int32; count: Int32; value: array of Int64);
begin
z_Uniform4i64vNV_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4i64vNV(location: Int32; count: Int32; var value: Int64);
begin
z_Uniform4i64vNV_ovr_0(location, count, value);
end;
public z_Uniform4i64vNV_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform4i64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4i64vNV(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform4i64vNV_ovr_2(location, count, value);
end;
public z_Uniform1ui64NV_adr := GetFuncAdr('glUniform1ui64NV');
public z_Uniform1ui64NV_ovr_0 := GetFuncOrNil&<procedure(location: Int32; x: UInt64)>(z_Uniform1ui64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ui64NV(location: Int32; x: UInt64);
begin
z_Uniform1ui64NV_ovr_0(location, x);
end;
public z_Uniform2ui64NV_adr := GetFuncAdr('glUniform2ui64NV');
public z_Uniform2ui64NV_ovr_0 := GetFuncOrNil&<procedure(location: Int32; x: UInt64; y: UInt64)>(z_Uniform2ui64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2ui64NV(location: Int32; x: UInt64; y: UInt64);
begin
z_Uniform2ui64NV_ovr_0(location, x, y);
end;
public z_Uniform3ui64NV_adr := GetFuncAdr('glUniform3ui64NV');
public z_Uniform3ui64NV_ovr_0 := GetFuncOrNil&<procedure(location: Int32; x: UInt64; y: UInt64; z: UInt64)>(z_Uniform3ui64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3ui64NV(location: Int32; x: UInt64; y: UInt64; z: UInt64);
begin
z_Uniform3ui64NV_ovr_0(location, x, y, z);
end;
public z_Uniform4ui64NV_adr := GetFuncAdr('glUniform4ui64NV');
public z_Uniform4ui64NV_ovr_0 := GetFuncOrNil&<procedure(location: Int32; x: UInt64; y: UInt64; z: UInt64; w: UInt64)>(z_Uniform4ui64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4ui64NV(location: Int32; x: UInt64; y: UInt64; z: UInt64; w: UInt64);
begin
z_Uniform4ui64NV_ovr_0(location, x, y, z, w);
end;
public z_Uniform1ui64vNV_adr := GetFuncAdr('glUniform1ui64vNV');
public z_Uniform1ui64vNV_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: UInt64)>(z_Uniform1ui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ui64vNV(location: Int32; count: Int32; value: array of UInt64);
begin
z_Uniform1ui64vNV_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ui64vNV(location: Int32; count: Int32; var value: UInt64);
begin
z_Uniform1ui64vNV_ovr_0(location, count, value);
end;
public z_Uniform1ui64vNV_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform1ui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1ui64vNV(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform1ui64vNV_ovr_2(location, count, value);
end;
public z_Uniform2ui64vNV_adr := GetFuncAdr('glUniform2ui64vNV');
public z_Uniform2ui64vNV_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: UInt64)>(z_Uniform2ui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2ui64vNV(location: Int32; count: Int32; value: array of UInt64);
begin
z_Uniform2ui64vNV_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2ui64vNV(location: Int32; count: Int32; var value: UInt64);
begin
z_Uniform2ui64vNV_ovr_0(location, count, value);
end;
public z_Uniform2ui64vNV_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform2ui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2ui64vNV(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform2ui64vNV_ovr_2(location, count, value);
end;
public z_Uniform3ui64vNV_adr := GetFuncAdr('glUniform3ui64vNV');
public z_Uniform3ui64vNV_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: UInt64)>(z_Uniform3ui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3ui64vNV(location: Int32; count: Int32; value: array of UInt64);
begin
z_Uniform3ui64vNV_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3ui64vNV(location: Int32; count: Int32; var value: UInt64);
begin
z_Uniform3ui64vNV_ovr_0(location, count, value);
end;
public z_Uniform3ui64vNV_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform3ui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3ui64vNV(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform3ui64vNV_ovr_2(location, count, value);
end;
public z_Uniform4ui64vNV_adr := GetFuncAdr('glUniform4ui64vNV');
public z_Uniform4ui64vNV_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: UInt64)>(z_Uniform4ui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4ui64vNV(location: Int32; count: Int32; value: array of UInt64);
begin
z_Uniform4ui64vNV_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4ui64vNV(location: Int32; count: Int32; var value: UInt64);
begin
z_Uniform4ui64vNV_ovr_0(location, count, value);
end;
public z_Uniform4ui64vNV_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform4ui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4ui64vNV(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniform4ui64vNV_ovr_2(location, count, value);
end;
public z_GetUniformi64vNV_adr := GetFuncAdr('glGetUniformi64vNV');
public z_GetUniformi64vNV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; var ¶ms: Int64)>(z_GetUniformi64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformi64vNV(&program: UInt32; location: Int32; ¶ms: array of Int64);
begin
z_GetUniformi64vNV_ovr_0(&program, location, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformi64vNV(&program: UInt32; location: Int32; var ¶ms: Int64);
begin
z_GetUniformi64vNV_ovr_0(&program, location, ¶ms);
end;
public z_GetUniformi64vNV_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; ¶ms: IntPtr)>(z_GetUniformi64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformi64vNV(&program: UInt32; location: Int32; ¶ms: IntPtr);
begin
z_GetUniformi64vNV_ovr_2(&program, location, ¶ms);
end;
public z_ProgramUniform1i64NV_adr := GetFuncAdr('glProgramUniform1i64NV');
public z_ProgramUniform1i64NV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; x: Int64)>(z_ProgramUniform1i64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1i64NV(&program: UInt32; location: Int32; x: Int64);
begin
z_ProgramUniform1i64NV_ovr_0(&program, location, x);
end;
public z_ProgramUniform2i64NV_adr := GetFuncAdr('glProgramUniform2i64NV');
public z_ProgramUniform2i64NV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; x: Int64; y: Int64)>(z_ProgramUniform2i64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2i64NV(&program: UInt32; location: Int32; x: Int64; y: Int64);
begin
z_ProgramUniform2i64NV_ovr_0(&program, location, x, y);
end;
public z_ProgramUniform3i64NV_adr := GetFuncAdr('glProgramUniform3i64NV');
public z_ProgramUniform3i64NV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; x: Int64; y: Int64; z: Int64)>(z_ProgramUniform3i64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3i64NV(&program: UInt32; location: Int32; x: Int64; y: Int64; z: Int64);
begin
z_ProgramUniform3i64NV_ovr_0(&program, location, x, y, z);
end;
public z_ProgramUniform4i64NV_adr := GetFuncAdr('glProgramUniform4i64NV');
public z_ProgramUniform4i64NV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; x: Int64; y: Int64; z: Int64; w: Int64)>(z_ProgramUniform4i64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4i64NV(&program: UInt32; location: Int32; x: Int64; y: Int64; z: Int64; w: Int64);
begin
z_ProgramUniform4i64NV_ovr_0(&program, location, x, y, z, w);
end;
public z_ProgramUniform1i64vNV_adr := GetFuncAdr('glProgramUniform1i64vNV');
public z_ProgramUniform1i64vNV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: Int64)>(z_ProgramUniform1i64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1i64vNV(&program: UInt32; location: Int32; count: Int32; value: array of Int64);
begin
z_ProgramUniform1i64vNV_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1i64vNV(&program: UInt32; location: Int32; count: Int32; var value: Int64);
begin
z_ProgramUniform1i64vNV_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform1i64vNV_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform1i64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1i64vNV(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform1i64vNV_ovr_2(&program, location, count, value);
end;
public z_ProgramUniform2i64vNV_adr := GetFuncAdr('glProgramUniform2i64vNV');
public z_ProgramUniform2i64vNV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: Int64)>(z_ProgramUniform2i64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2i64vNV(&program: UInt32; location: Int32; count: Int32; value: array of Int64);
begin
z_ProgramUniform2i64vNV_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2i64vNV(&program: UInt32; location: Int32; count: Int32; var value: Int64);
begin
z_ProgramUniform2i64vNV_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform2i64vNV_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform2i64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2i64vNV(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform2i64vNV_ovr_2(&program, location, count, value);
end;
public z_ProgramUniform3i64vNV_adr := GetFuncAdr('glProgramUniform3i64vNV');
public z_ProgramUniform3i64vNV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: Int64)>(z_ProgramUniform3i64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3i64vNV(&program: UInt32; location: Int32; count: Int32; value: array of Int64);
begin
z_ProgramUniform3i64vNV_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3i64vNV(&program: UInt32; location: Int32; count: Int32; var value: Int64);
begin
z_ProgramUniform3i64vNV_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform3i64vNV_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform3i64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3i64vNV(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform3i64vNV_ovr_2(&program, location, count, value);
end;
public z_ProgramUniform4i64vNV_adr := GetFuncAdr('glProgramUniform4i64vNV');
public z_ProgramUniform4i64vNV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: Int64)>(z_ProgramUniform4i64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4i64vNV(&program: UInt32; location: Int32; count: Int32; value: array of Int64);
begin
z_ProgramUniform4i64vNV_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4i64vNV(&program: UInt32; location: Int32; count: Int32; var value: Int64);
begin
z_ProgramUniform4i64vNV_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform4i64vNV_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform4i64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4i64vNV(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform4i64vNV_ovr_2(&program, location, count, value);
end;
public z_ProgramUniform1ui64NV_adr := GetFuncAdr('glProgramUniform1ui64NV');
public z_ProgramUniform1ui64NV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; x: UInt64)>(z_ProgramUniform1ui64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ui64NV(&program: UInt32; location: Int32; x: UInt64);
begin
z_ProgramUniform1ui64NV_ovr_0(&program, location, x);
end;
public z_ProgramUniform2ui64NV_adr := GetFuncAdr('glProgramUniform2ui64NV');
public z_ProgramUniform2ui64NV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; x: UInt64; y: UInt64)>(z_ProgramUniform2ui64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ui64NV(&program: UInt32; location: Int32; x: UInt64; y: UInt64);
begin
z_ProgramUniform2ui64NV_ovr_0(&program, location, x, y);
end;
public z_ProgramUniform3ui64NV_adr := GetFuncAdr('glProgramUniform3ui64NV');
public z_ProgramUniform3ui64NV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; x: UInt64; y: UInt64; z: UInt64)>(z_ProgramUniform3ui64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ui64NV(&program: UInt32; location: Int32; x: UInt64; y: UInt64; z: UInt64);
begin
z_ProgramUniform3ui64NV_ovr_0(&program, location, x, y, z);
end;
public z_ProgramUniform4ui64NV_adr := GetFuncAdr('glProgramUniform4ui64NV');
public z_ProgramUniform4ui64NV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; x: UInt64; y: UInt64; z: UInt64; w: UInt64)>(z_ProgramUniform4ui64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ui64NV(&program: UInt32; location: Int32; x: UInt64; y: UInt64; z: UInt64; w: UInt64);
begin
z_ProgramUniform4ui64NV_ovr_0(&program, location, x, y, z, w);
end;
public z_ProgramUniform1ui64vNV_adr := GetFuncAdr('glProgramUniform1ui64vNV');
public z_ProgramUniform1ui64vNV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: UInt64)>(z_ProgramUniform1ui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ui64vNV(&program: UInt32; location: Int32; count: Int32; value: array of UInt64);
begin
z_ProgramUniform1ui64vNV_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ui64vNV(&program: UInt32; location: Int32; count: Int32; var value: UInt64);
begin
z_ProgramUniform1ui64vNV_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform1ui64vNV_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform1ui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform1ui64vNV(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform1ui64vNV_ovr_2(&program, location, count, value);
end;
public z_ProgramUniform2ui64vNV_adr := GetFuncAdr('glProgramUniform2ui64vNV');
public z_ProgramUniform2ui64vNV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: UInt64)>(z_ProgramUniform2ui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ui64vNV(&program: UInt32; location: Int32; count: Int32; value: array of UInt64);
begin
z_ProgramUniform2ui64vNV_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ui64vNV(&program: UInt32; location: Int32; count: Int32; var value: UInt64);
begin
z_ProgramUniform2ui64vNV_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform2ui64vNV_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform2ui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform2ui64vNV(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform2ui64vNV_ovr_2(&program, location, count, value);
end;
public z_ProgramUniform3ui64vNV_adr := GetFuncAdr('glProgramUniform3ui64vNV');
public z_ProgramUniform3ui64vNV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: UInt64)>(z_ProgramUniform3ui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ui64vNV(&program: UInt32; location: Int32; count: Int32; value: array of UInt64);
begin
z_ProgramUniform3ui64vNV_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ui64vNV(&program: UInt32; location: Int32; count: Int32; var value: UInt64);
begin
z_ProgramUniform3ui64vNV_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform3ui64vNV_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform3ui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform3ui64vNV(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform3ui64vNV_ovr_2(&program, location, count, value);
end;
public z_ProgramUniform4ui64vNV_adr := GetFuncAdr('glProgramUniform4ui64vNV');
public z_ProgramUniform4ui64vNV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: UInt64)>(z_ProgramUniform4ui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ui64vNV(&program: UInt32; location: Int32; count: Int32; value: array of UInt64);
begin
z_ProgramUniform4ui64vNV_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ui64vNV(&program: UInt32; location: Int32; count: Int32; var value: UInt64);
begin
z_ProgramUniform4ui64vNV_ovr_0(&program, location, count, value);
end;
public z_ProgramUniform4ui64vNV_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniform4ui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniform4ui64vNV(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniform4ui64vNV_ovr_2(&program, location, count, value);
end;
end;
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);
public z_Vertex2hNV_adr := GetFuncAdr('glVertex2hNV');
public z_Vertex2hNV_ovr_0 := GetFuncOrNil&<procedure(x: Half; y: Half)>(z_Vertex2hNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2hNV(x: Half; y: Half);
begin
z_Vertex2hNV_ovr_0(x, y);
end;
public z_Vertex2hvNV_adr := GetFuncAdr('glVertex2hvNV');
public z_Vertex2hvNV_ovr_0 := GetFuncOrNil&<procedure(var v: Half)>(z_Vertex2hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2hvNV(v: array of Half);
begin
z_Vertex2hvNV_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2hvNV(var v: Half);
begin
z_Vertex2hvNV_ovr_0(v);
end;
public z_Vertex2hvNV_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_Vertex2hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2hvNV(v: IntPtr);
begin
z_Vertex2hvNV_ovr_2(v);
end;
public z_Vertex3hNV_adr := GetFuncAdr('glVertex3hNV');
public z_Vertex3hNV_ovr_0 := GetFuncOrNil&<procedure(x: Half; y: Half; z: Half)>(z_Vertex3hNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3hNV(x: Half; y: Half; z: Half);
begin
z_Vertex3hNV_ovr_0(x, y, z);
end;
public z_Vertex3hvNV_adr := GetFuncAdr('glVertex3hvNV');
public z_Vertex3hvNV_ovr_0 := GetFuncOrNil&<procedure(var v: Half)>(z_Vertex3hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3hvNV(v: array of Half);
begin
z_Vertex3hvNV_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3hvNV(var v: Half);
begin
z_Vertex3hvNV_ovr_0(v);
end;
public z_Vertex3hvNV_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_Vertex3hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3hvNV(v: IntPtr);
begin
z_Vertex3hvNV_ovr_2(v);
end;
public z_Vertex4hNV_adr := GetFuncAdr('glVertex4hNV');
public z_Vertex4hNV_ovr_0 := GetFuncOrNil&<procedure(x: Half; y: Half; z: Half; w: Half)>(z_Vertex4hNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4hNV(x: Half; y: Half; z: Half; w: Half);
begin
z_Vertex4hNV_ovr_0(x, y, z, w);
end;
public z_Vertex4hvNV_adr := GetFuncAdr('glVertex4hvNV');
public z_Vertex4hvNV_ovr_0 := GetFuncOrNil&<procedure(var v: Half)>(z_Vertex4hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4hvNV(v: array of Half);
begin
z_Vertex4hvNV_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4hvNV(var v: Half);
begin
z_Vertex4hvNV_ovr_0(v);
end;
public z_Vertex4hvNV_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_Vertex4hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4hvNV(v: IntPtr);
begin
z_Vertex4hvNV_ovr_2(v);
end;
public z_Normal3hNV_adr := GetFuncAdr('glNormal3hNV');
public z_Normal3hNV_ovr_0 := GetFuncOrNil&<procedure(nx: Half; ny: Half; nz: Half)>(z_Normal3hNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3hNV(nx: Half; ny: Half; nz: Half);
begin
z_Normal3hNV_ovr_0(nx, ny, nz);
end;
public z_Normal3hvNV_adr := GetFuncAdr('glNormal3hvNV');
public z_Normal3hvNV_ovr_0 := GetFuncOrNil&<procedure(var v: Half)>(z_Normal3hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3hvNV(v: array of Half);
begin
z_Normal3hvNV_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3hvNV(var v: Half);
begin
z_Normal3hvNV_ovr_0(v);
end;
public z_Normal3hvNV_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_Normal3hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3hvNV(v: IntPtr);
begin
z_Normal3hvNV_ovr_2(v);
end;
public z_Color3hNV_adr := GetFuncAdr('glColor3hNV');
public z_Color3hNV_ovr_0 := GetFuncOrNil&<procedure(red: Half; green: Half; blue: Half)>(z_Color3hNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3hNV(red: Half; green: Half; blue: Half);
begin
z_Color3hNV_ovr_0(red, green, blue);
end;
public z_Color3hvNV_adr := GetFuncAdr('glColor3hvNV');
public z_Color3hvNV_ovr_0 := GetFuncOrNil&<procedure(var v: Half)>(z_Color3hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3hvNV(v: array of Half);
begin
z_Color3hvNV_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3hvNV(var v: Half);
begin
z_Color3hvNV_ovr_0(v);
end;
public z_Color3hvNV_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_Color3hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3hvNV(v: IntPtr);
begin
z_Color3hvNV_ovr_2(v);
end;
public z_Color4hNV_adr := GetFuncAdr('glColor4hNV');
public z_Color4hNV_ovr_0 := GetFuncOrNil&<procedure(red: Half; green: Half; blue: Half; alpha: Half)>(z_Color4hNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4hNV(red: Half; green: Half; blue: Half; alpha: Half);
begin
z_Color4hNV_ovr_0(red, green, blue, alpha);
end;
public z_Color4hvNV_adr := GetFuncAdr('glColor4hvNV');
public z_Color4hvNV_ovr_0 := GetFuncOrNil&<procedure(var v: Half)>(z_Color4hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4hvNV(v: array of Half);
begin
z_Color4hvNV_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4hvNV(var v: Half);
begin
z_Color4hvNV_ovr_0(v);
end;
public z_Color4hvNV_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_Color4hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4hvNV(v: IntPtr);
begin
z_Color4hvNV_ovr_2(v);
end;
public z_TexCoord1hNV_adr := GetFuncAdr('glTexCoord1hNV');
public z_TexCoord1hNV_ovr_0 := GetFuncOrNil&<procedure(s: Half)>(z_TexCoord1hNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1hNV(s: Half);
begin
z_TexCoord1hNV_ovr_0(s);
end;
public z_TexCoord1hvNV_adr := GetFuncAdr('glTexCoord1hvNV');
public z_TexCoord1hvNV_ovr_0 := GetFuncOrNil&<procedure(var v: Half)>(z_TexCoord1hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1hvNV(v: array of Half);
begin
z_TexCoord1hvNV_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1hvNV(var v: Half);
begin
z_TexCoord1hvNV_ovr_0(v);
end;
public z_TexCoord1hvNV_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_TexCoord1hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1hvNV(v: IntPtr);
begin
z_TexCoord1hvNV_ovr_2(v);
end;
public z_TexCoord2hNV_adr := GetFuncAdr('glTexCoord2hNV');
public z_TexCoord2hNV_ovr_0 := GetFuncOrNil&<procedure(s: Half; t: Half)>(z_TexCoord2hNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2hNV(s: Half; t: Half);
begin
z_TexCoord2hNV_ovr_0(s, t);
end;
public z_TexCoord2hvNV_adr := GetFuncAdr('glTexCoord2hvNV');
public z_TexCoord2hvNV_ovr_0 := GetFuncOrNil&<procedure(var v: Half)>(z_TexCoord2hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2hvNV(v: array of Half);
begin
z_TexCoord2hvNV_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2hvNV(var v: Half);
begin
z_TexCoord2hvNV_ovr_0(v);
end;
public z_TexCoord2hvNV_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_TexCoord2hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2hvNV(v: IntPtr);
begin
z_TexCoord2hvNV_ovr_2(v);
end;
public z_TexCoord3hNV_adr := GetFuncAdr('glTexCoord3hNV');
public z_TexCoord3hNV_ovr_0 := GetFuncOrNil&<procedure(s: Half; t: Half; r: Half)>(z_TexCoord3hNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3hNV(s: Half; t: Half; r: Half);
begin
z_TexCoord3hNV_ovr_0(s, t, r);
end;
public z_TexCoord3hvNV_adr := GetFuncAdr('glTexCoord3hvNV');
public z_TexCoord3hvNV_ovr_0 := GetFuncOrNil&<procedure(var v: Half)>(z_TexCoord3hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3hvNV(v: array of Half);
begin
z_TexCoord3hvNV_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3hvNV(var v: Half);
begin
z_TexCoord3hvNV_ovr_0(v);
end;
public z_TexCoord3hvNV_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_TexCoord3hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3hvNV(v: IntPtr);
begin
z_TexCoord3hvNV_ovr_2(v);
end;
public z_TexCoord4hNV_adr := GetFuncAdr('glTexCoord4hNV');
public z_TexCoord4hNV_ovr_0 := GetFuncOrNil&<procedure(s: Half; t: Half; r: Half; q: Half)>(z_TexCoord4hNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4hNV(s: Half; t: Half; r: Half; q: Half);
begin
z_TexCoord4hNV_ovr_0(s, t, r, q);
end;
public z_TexCoord4hvNV_adr := GetFuncAdr('glTexCoord4hvNV');
public z_TexCoord4hvNV_ovr_0 := GetFuncOrNil&<procedure(var v: Half)>(z_TexCoord4hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4hvNV(v: array of Half);
begin
z_TexCoord4hvNV_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4hvNV(var v: Half);
begin
z_TexCoord4hvNV_ovr_0(v);
end;
public z_TexCoord4hvNV_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_TexCoord4hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4hvNV(v: IntPtr);
begin
z_TexCoord4hvNV_ovr_2(v);
end;
public z_MultiTexCoord1hNV_adr := GetFuncAdr('glMultiTexCoord1hNV');
public z_MultiTexCoord1hNV_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: Half)>(z_MultiTexCoord1hNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1hNV(target: TextureUnit; s: Half);
begin
z_MultiTexCoord1hNV_ovr_0(target, s);
end;
public z_MultiTexCoord1hvNV_adr := GetFuncAdr('glMultiTexCoord1hvNV');
public z_MultiTexCoord1hvNV_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Half)>(z_MultiTexCoord1hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1hvNV(target: TextureUnit; v: array of Half);
begin
z_MultiTexCoord1hvNV_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1hvNV(target: TextureUnit; var v: Half);
begin
z_MultiTexCoord1hvNV_ovr_0(target, v);
end;
public z_MultiTexCoord1hvNV_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord1hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1hvNV(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord1hvNV_ovr_2(target, v);
end;
public z_MultiTexCoord2hNV_adr := GetFuncAdr('glMultiTexCoord2hNV');
public z_MultiTexCoord2hNV_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: Half; t: Half)>(z_MultiTexCoord2hNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2hNV(target: TextureUnit; s: Half; t: Half);
begin
z_MultiTexCoord2hNV_ovr_0(target, s, t);
end;
public z_MultiTexCoord2hvNV_adr := GetFuncAdr('glMultiTexCoord2hvNV');
public z_MultiTexCoord2hvNV_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Half)>(z_MultiTexCoord2hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2hvNV(target: TextureUnit; v: array of Half);
begin
z_MultiTexCoord2hvNV_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2hvNV(target: TextureUnit; var v: Half);
begin
z_MultiTexCoord2hvNV_ovr_0(target, v);
end;
public z_MultiTexCoord2hvNV_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord2hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2hvNV(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord2hvNV_ovr_2(target, v);
end;
public z_MultiTexCoord3hNV_adr := GetFuncAdr('glMultiTexCoord3hNV');
public z_MultiTexCoord3hNV_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: Half; t: Half; r: Half)>(z_MultiTexCoord3hNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3hNV(target: TextureUnit; s: Half; t: Half; r: Half);
begin
z_MultiTexCoord3hNV_ovr_0(target, s, t, r);
end;
public z_MultiTexCoord3hvNV_adr := GetFuncAdr('glMultiTexCoord3hvNV');
public z_MultiTexCoord3hvNV_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Half)>(z_MultiTexCoord3hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3hvNV(target: TextureUnit; v: array of Half);
begin
z_MultiTexCoord3hvNV_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3hvNV(target: TextureUnit; var v: Half);
begin
z_MultiTexCoord3hvNV_ovr_0(target, v);
end;
public z_MultiTexCoord3hvNV_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord3hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3hvNV(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord3hvNV_ovr_2(target, v);
end;
public z_MultiTexCoord4hNV_adr := GetFuncAdr('glMultiTexCoord4hNV');
public z_MultiTexCoord4hNV_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; s: Half; t: Half; r: Half; q: Half)>(z_MultiTexCoord4hNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4hNV(target: TextureUnit; s: Half; t: Half; r: Half; q: Half);
begin
z_MultiTexCoord4hNV_ovr_0(target, s, t, r, q);
end;
public z_MultiTexCoord4hvNV_adr := GetFuncAdr('glMultiTexCoord4hvNV');
public z_MultiTexCoord4hvNV_ovr_0 := GetFuncOrNil&<procedure(target: TextureUnit; var v: Half)>(z_MultiTexCoord4hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4hvNV(target: TextureUnit; v: array of Half);
begin
z_MultiTexCoord4hvNV_ovr_0(target, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4hvNV(target: TextureUnit; var v: Half);
begin
z_MultiTexCoord4hvNV_ovr_0(target, v);
end;
public z_MultiTexCoord4hvNV_ovr_2 := GetFuncOrNil&<procedure(target: TextureUnit; v: IntPtr)>(z_MultiTexCoord4hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4hvNV(target: TextureUnit; v: IntPtr);
begin
z_MultiTexCoord4hvNV_ovr_2(target, v);
end;
public z_FogCoordhNV_adr := GetFuncAdr('glFogCoordhNV');
public z_FogCoordhNV_ovr_0 := GetFuncOrNil&<procedure(fog: Half)>(z_FogCoordhNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordhNV(fog: Half);
begin
z_FogCoordhNV_ovr_0(fog);
end;
public z_FogCoordhvNV_adr := GetFuncAdr('glFogCoordhvNV');
public z_FogCoordhvNV_ovr_0 := GetFuncOrNil&<procedure(var fog: Half)>(z_FogCoordhvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordhvNV(fog: array of Half);
begin
z_FogCoordhvNV_ovr_0(fog[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordhvNV(var fog: Half);
begin
z_FogCoordhvNV_ovr_0(fog);
end;
public z_FogCoordhvNV_ovr_2 := GetFuncOrNil&<procedure(fog: IntPtr)>(z_FogCoordhvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordhvNV(fog: IntPtr);
begin
z_FogCoordhvNV_ovr_2(fog);
end;
public z_SecondaryColor3hNV_adr := GetFuncAdr('glSecondaryColor3hNV');
public z_SecondaryColor3hNV_ovr_0 := GetFuncOrNil&<procedure(red: Half; green: Half; blue: Half)>(z_SecondaryColor3hNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3hNV(red: Half; green: Half; blue: Half);
begin
z_SecondaryColor3hNV_ovr_0(red, green, blue);
end;
public z_SecondaryColor3hvNV_adr := GetFuncAdr('glSecondaryColor3hvNV');
public z_SecondaryColor3hvNV_ovr_0 := GetFuncOrNil&<procedure(var v: Half)>(z_SecondaryColor3hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3hvNV(v: array of Half);
begin
z_SecondaryColor3hvNV_ovr_0(v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3hvNV(var v: Half);
begin
z_SecondaryColor3hvNV_ovr_0(v);
end;
public z_SecondaryColor3hvNV_ovr_2 := GetFuncOrNil&<procedure(v: IntPtr)>(z_SecondaryColor3hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColor3hvNV(v: IntPtr);
begin
z_SecondaryColor3hvNV_ovr_2(v);
end;
public z_VertexWeighthNV_adr := GetFuncAdr('glVertexWeighthNV');
public z_VertexWeighthNV_ovr_0 := GetFuncOrNil&<procedure(weight: Half)>(z_VertexWeighthNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexWeighthNV(weight: Half);
begin
z_VertexWeighthNV_ovr_0(weight);
end;
public z_VertexWeighthvNV_adr := GetFuncAdr('glVertexWeighthvNV');
public z_VertexWeighthvNV_ovr_0 := GetFuncOrNil&<procedure(var weight: Half)>(z_VertexWeighthvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexWeighthvNV(weight: array of Half);
begin
z_VertexWeighthvNV_ovr_0(weight[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexWeighthvNV(var weight: Half);
begin
z_VertexWeighthvNV_ovr_0(weight);
end;
public z_VertexWeighthvNV_ovr_2 := GetFuncOrNil&<procedure(weight: IntPtr)>(z_VertexWeighthvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexWeighthvNV(weight: IntPtr);
begin
z_VertexWeighthvNV_ovr_2(weight);
end;
public z_VertexAttrib1hNV_adr := GetFuncAdr('glVertexAttrib1hNV');
public z_VertexAttrib1hNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Half)>(z_VertexAttrib1hNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1hNV(index: UInt32; x: Half);
begin
z_VertexAttrib1hNV_ovr_0(index, x);
end;
public z_VertexAttrib1hvNV_adr := GetFuncAdr('glVertexAttrib1hvNV');
public z_VertexAttrib1hvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Half)>(z_VertexAttrib1hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1hvNV(index: UInt32; v: array of Half);
begin
z_VertexAttrib1hvNV_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1hvNV(index: UInt32; var v: Half);
begin
z_VertexAttrib1hvNV_ovr_0(index, v);
end;
public z_VertexAttrib1hvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib1hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1hvNV(index: UInt32; v: IntPtr);
begin
z_VertexAttrib1hvNV_ovr_2(index, v);
end;
public z_VertexAttrib2hNV_adr := GetFuncAdr('glVertexAttrib2hNV');
public z_VertexAttrib2hNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Half; y: Half)>(z_VertexAttrib2hNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2hNV(index: UInt32; x: Half; y: Half);
begin
z_VertexAttrib2hNV_ovr_0(index, x, y);
end;
public z_VertexAttrib2hvNV_adr := GetFuncAdr('glVertexAttrib2hvNV');
public z_VertexAttrib2hvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Half)>(z_VertexAttrib2hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2hvNV(index: UInt32; v: array of Half);
begin
z_VertexAttrib2hvNV_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2hvNV(index: UInt32; var v: Half);
begin
z_VertexAttrib2hvNV_ovr_0(index, v);
end;
public z_VertexAttrib2hvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib2hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2hvNV(index: UInt32; v: IntPtr);
begin
z_VertexAttrib2hvNV_ovr_2(index, v);
end;
public z_VertexAttrib3hNV_adr := GetFuncAdr('glVertexAttrib3hNV');
public z_VertexAttrib3hNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Half; y: Half; z: Half)>(z_VertexAttrib3hNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3hNV(index: UInt32; x: Half; y: Half; z: Half);
begin
z_VertexAttrib3hNV_ovr_0(index, x, y, z);
end;
public z_VertexAttrib3hvNV_adr := GetFuncAdr('glVertexAttrib3hvNV');
public z_VertexAttrib3hvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Half)>(z_VertexAttrib3hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3hvNV(index: UInt32; v: array of Half);
begin
z_VertexAttrib3hvNV_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3hvNV(index: UInt32; var v: Half);
begin
z_VertexAttrib3hvNV_ovr_0(index, v);
end;
public z_VertexAttrib3hvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib3hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3hvNV(index: UInt32; v: IntPtr);
begin
z_VertexAttrib3hvNV_ovr_2(index, v);
end;
public z_VertexAttrib4hNV_adr := GetFuncAdr('glVertexAttrib4hNV');
public z_VertexAttrib4hNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Half; y: Half; z: Half; w: Half)>(z_VertexAttrib4hNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4hNV(index: UInt32; x: Half; y: Half; z: Half; w: Half);
begin
z_VertexAttrib4hNV_ovr_0(index, x, y, z, w);
end;
public z_VertexAttrib4hvNV_adr := GetFuncAdr('glVertexAttrib4hvNV');
public z_VertexAttrib4hvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Half)>(z_VertexAttrib4hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4hvNV(index: UInt32; v: array of Half);
begin
z_VertexAttrib4hvNV_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4hvNV(index: UInt32; var v: Half);
begin
z_VertexAttrib4hvNV_ovr_0(index, v);
end;
public z_VertexAttrib4hvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4hvNV(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4hvNV_ovr_2(index, v);
end;
public z_VertexAttribs1hvNV_adr := GetFuncAdr('glVertexAttribs1hvNV');
public z_VertexAttribs1hvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; n: Int32; var v: Half)>(z_VertexAttribs1hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs1hvNV(index: UInt32; n: Int32; v: array of Half);
begin
z_VertexAttribs1hvNV_ovr_0(index, n, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs1hvNV(index: UInt32; n: Int32; var v: Half);
begin
z_VertexAttribs1hvNV_ovr_0(index, n, v);
end;
public z_VertexAttribs1hvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; n: Int32; v: IntPtr)>(z_VertexAttribs1hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs1hvNV(index: UInt32; n: Int32; v: IntPtr);
begin
z_VertexAttribs1hvNV_ovr_2(index, n, v);
end;
public z_VertexAttribs2hvNV_adr := GetFuncAdr('glVertexAttribs2hvNV');
public z_VertexAttribs2hvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; n: Int32; var v: Half)>(z_VertexAttribs2hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs2hvNV(index: UInt32; n: Int32; v: array of Half);
begin
z_VertexAttribs2hvNV_ovr_0(index, n, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs2hvNV(index: UInt32; n: Int32; var v: Half);
begin
z_VertexAttribs2hvNV_ovr_0(index, n, v);
end;
public z_VertexAttribs2hvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; n: Int32; v: IntPtr)>(z_VertexAttribs2hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs2hvNV(index: UInt32; n: Int32; v: IntPtr);
begin
z_VertexAttribs2hvNV_ovr_2(index, n, v);
end;
public z_VertexAttribs3hvNV_adr := GetFuncAdr('glVertexAttribs3hvNV');
public z_VertexAttribs3hvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; n: Int32; var v: Half)>(z_VertexAttribs3hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs3hvNV(index: UInt32; n: Int32; v: array of Half);
begin
z_VertexAttribs3hvNV_ovr_0(index, n, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs3hvNV(index: UInt32; n: Int32; var v: Half);
begin
z_VertexAttribs3hvNV_ovr_0(index, n, v);
end;
public z_VertexAttribs3hvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; n: Int32; v: IntPtr)>(z_VertexAttribs3hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs3hvNV(index: UInt32; n: Int32; v: IntPtr);
begin
z_VertexAttribs3hvNV_ovr_2(index, n, v);
end;
public z_VertexAttribs4hvNV_adr := GetFuncAdr('glVertexAttribs4hvNV');
public z_VertexAttribs4hvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; n: Int32; var v: Half)>(z_VertexAttribs4hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4hvNV(index: UInt32; n: Int32; v: array of Half);
begin
z_VertexAttribs4hvNV_ovr_0(index, n, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4hvNV(index: UInt32; n: Int32; var v: Half);
begin
z_VertexAttribs4hvNV_ovr_0(index, n, v);
end;
public z_VertexAttribs4hvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; n: Int32; v: IntPtr)>(z_VertexAttribs4hvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4hvNV(index: UInt32; n: Int32; v: IntPtr);
begin
z_VertexAttribs4hvNV_ovr_2(index, n, v);
end;
end;
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);
public z_GetInternalformatSampleivNV_adr := GetFuncAdr('glGetInternalformatSampleivNV');
public z_GetInternalformatSampleivNV_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; _internalformat: InternalFormat; samples: Int32; pname: InternalFormatPName; count: Int32; var ¶ms: Int32)>(z_GetInternalformatSampleivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInternalformatSampleivNV(target: TextureTarget; _internalformat: InternalFormat; samples: Int32; pname: InternalFormatPName; count: Int32; ¶ms: array of Int32);
begin
z_GetInternalformatSampleivNV_ovr_0(target, _internalformat, samples, pname, count, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInternalformatSampleivNV(target: TextureTarget; _internalformat: InternalFormat; samples: Int32; pname: InternalFormatPName; count: Int32; var ¶ms: Int32);
begin
z_GetInternalformatSampleivNV_ovr_0(target, _internalformat, samples, pname, count, ¶ms);
end;
public z_GetInternalformatSampleivNV_ovr_2 := GetFuncOrNil&<procedure(target: TextureTarget; _internalformat: InternalFormat; samples: Int32; pname: InternalFormatPName; count: Int32; ¶ms: IntPtr)>(z_GetInternalformatSampleivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetInternalformatSampleivNV(target: TextureTarget; _internalformat: InternalFormat; samples: Int32; pname: InternalFormatPName; count: Int32; ¶ms: IntPtr);
begin
z_GetInternalformatSampleivNV_ovr_2(target, _internalformat, samples, pname, count, ¶ms);
end;
end;
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);
public z_RenderGpuMaskNV_adr := GetFuncAdr('glRenderGpuMaskNV');
public z_RenderGpuMaskNV_ovr_0 := GetFuncOrNil&<procedure(mask: DummyFlags)>(z_RenderGpuMaskNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RenderGpuMaskNV(mask: DummyFlags);
begin
z_RenderGpuMaskNV_ovr_0(mask);
end;
public z_MulticastBufferSubDataNV_adr := GetFuncAdr('glMulticastBufferSubDataNV');
public z_MulticastBufferSubDataNV_ovr_0 := GetFuncOrNil&<procedure(gpuMask: DummyFlags; buffer: UInt32; offset: IntPtr; size: IntPtr; data: IntPtr)>(z_MulticastBufferSubDataNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastBufferSubDataNV(gpuMask: DummyFlags; buffer: UInt32; offset: IntPtr; size: IntPtr; data: IntPtr);
begin
z_MulticastBufferSubDataNV_ovr_0(gpuMask, buffer, offset, size, data);
end;
public z_MulticastCopyBufferSubDataNV_adr := GetFuncAdr('glMulticastCopyBufferSubDataNV');
public z_MulticastCopyBufferSubDataNV_ovr_0 := GetFuncOrNil&<procedure(readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr)>(z_MulticastCopyBufferSubDataNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastCopyBufferSubDataNV(readGpu: UInt32; writeGpuMask: DummyFlags; readBuffer: UInt32; writeBuffer: UInt32; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr);
begin
z_MulticastCopyBufferSubDataNV_ovr_0(readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size);
end;
public z_MulticastCopyImageSubDataNV_adr := GetFuncAdr('glMulticastCopyImageSubDataNV');
public z_MulticastCopyImageSubDataNV_ovr_0 := GetFuncOrNil&<procedure(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_adr);
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);
begin
z_MulticastCopyImageSubDataNV_ovr_0(srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
end;
public z_MulticastBlitFramebufferNV_adr := GetFuncAdr('glMulticastBlitFramebufferNV');
public z_MulticastBlitFramebufferNV_ovr_0 := GetFuncOrNil&<procedure(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_adr);
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);
begin
z_MulticastBlitFramebufferNV_ovr_0(srcGpu, dstGpu, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
end;
public z_MulticastFramebufferSampleLocationsfvNV_adr := GetFuncAdr('glMulticastFramebufferSampleLocationsfvNV');
public z_MulticastFramebufferSampleLocationsfvNV_ovr_0 := GetFuncOrNil&<procedure(gpu: UInt32; framebuffer: UInt32; start: UInt32; count: Int32; var v: single)>(z_MulticastFramebufferSampleLocationsfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastFramebufferSampleLocationsfvNV(gpu: UInt32; framebuffer: UInt32; start: UInt32; count: Int32; v: array of single);
begin
z_MulticastFramebufferSampleLocationsfvNV_ovr_0(gpu, framebuffer, start, count, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastFramebufferSampleLocationsfvNV(gpu: UInt32; framebuffer: UInt32; start: UInt32; count: Int32; var v: single);
begin
z_MulticastFramebufferSampleLocationsfvNV_ovr_0(gpu, framebuffer, start, count, v);
end;
public z_MulticastFramebufferSampleLocationsfvNV_ovr_2 := GetFuncOrNil&<procedure(gpu: UInt32; framebuffer: UInt32; start: UInt32; count: Int32; v: IntPtr)>(z_MulticastFramebufferSampleLocationsfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastFramebufferSampleLocationsfvNV(gpu: UInt32; framebuffer: UInt32; start: UInt32; count: Int32; v: IntPtr);
begin
z_MulticastFramebufferSampleLocationsfvNV_ovr_2(gpu, framebuffer, start, count, v);
end;
public z_MulticastBarrierNV_adr := GetFuncAdr('glMulticastBarrierNV');
public z_MulticastBarrierNV_ovr_0 := GetFuncOrNil&<procedure>(z_MulticastBarrierNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastBarrierNV;
begin
z_MulticastBarrierNV_ovr_0;
end;
public z_MulticastWaitSyncNV_adr := GetFuncAdr('glMulticastWaitSyncNV');
public z_MulticastWaitSyncNV_ovr_0 := GetFuncOrNil&<procedure(signalGpu: UInt32; waitGpuMask: DummyFlags)>(z_MulticastWaitSyncNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastWaitSyncNV(signalGpu: UInt32; waitGpuMask: DummyFlags);
begin
z_MulticastWaitSyncNV_ovr_0(signalGpu, waitGpuMask);
end;
public z_MulticastGetQueryObjectivNV_adr := GetFuncAdr('glMulticastGetQueryObjectivNV');
public z_MulticastGetQueryObjectivNV_ovr_0 := GetFuncOrNil&<procedure(gpu: UInt32; id: UInt32; pname: DummyEnum; var ¶ms: Int32)>(z_MulticastGetQueryObjectivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastGetQueryObjectivNV(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: array of Int32);
begin
z_MulticastGetQueryObjectivNV_ovr_0(gpu, id, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastGetQueryObjectivNV(gpu: UInt32; id: UInt32; pname: DummyEnum; var ¶ms: Int32);
begin
z_MulticastGetQueryObjectivNV_ovr_0(gpu, id, pname, ¶ms);
end;
public z_MulticastGetQueryObjectivNV_ovr_2 := GetFuncOrNil&<procedure(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: IntPtr)>(z_MulticastGetQueryObjectivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastGetQueryObjectivNV(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: IntPtr);
begin
z_MulticastGetQueryObjectivNV_ovr_2(gpu, id, pname, ¶ms);
end;
public z_MulticastGetQueryObjectuivNV_adr := GetFuncAdr('glMulticastGetQueryObjectuivNV');
public z_MulticastGetQueryObjectuivNV_ovr_0 := GetFuncOrNil&<procedure(gpu: UInt32; id: UInt32; pname: DummyEnum; var ¶ms: UInt32)>(z_MulticastGetQueryObjectuivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastGetQueryObjectuivNV(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: array of UInt32);
begin
z_MulticastGetQueryObjectuivNV_ovr_0(gpu, id, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastGetQueryObjectuivNV(gpu: UInt32; id: UInt32; pname: DummyEnum; var ¶ms: UInt32);
begin
z_MulticastGetQueryObjectuivNV_ovr_0(gpu, id, pname, ¶ms);
end;
public z_MulticastGetQueryObjectuivNV_ovr_2 := GetFuncOrNil&<procedure(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: IntPtr)>(z_MulticastGetQueryObjectuivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastGetQueryObjectuivNV(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: IntPtr);
begin
z_MulticastGetQueryObjectuivNV_ovr_2(gpu, id, pname, ¶ms);
end;
public z_MulticastGetQueryObjecti64vNV_adr := GetFuncAdr('glMulticastGetQueryObjecti64vNV');
public z_MulticastGetQueryObjecti64vNV_ovr_0 := GetFuncOrNil&<procedure(gpu: UInt32; id: UInt32; pname: DummyEnum; var ¶ms: Int64)>(z_MulticastGetQueryObjecti64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastGetQueryObjecti64vNV(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: array of Int64);
begin
z_MulticastGetQueryObjecti64vNV_ovr_0(gpu, id, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastGetQueryObjecti64vNV(gpu: UInt32; id: UInt32; pname: DummyEnum; var ¶ms: Int64);
begin
z_MulticastGetQueryObjecti64vNV_ovr_0(gpu, id, pname, ¶ms);
end;
public z_MulticastGetQueryObjecti64vNV_ovr_2 := GetFuncOrNil&<procedure(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: IntPtr)>(z_MulticastGetQueryObjecti64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastGetQueryObjecti64vNV(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: IntPtr);
begin
z_MulticastGetQueryObjecti64vNV_ovr_2(gpu, id, pname, ¶ms);
end;
public z_MulticastGetQueryObjectui64vNV_adr := GetFuncAdr('glMulticastGetQueryObjectui64vNV');
public z_MulticastGetQueryObjectui64vNV_ovr_0 := GetFuncOrNil&<procedure(gpu: UInt32; id: UInt32; pname: DummyEnum; var ¶ms: UInt64)>(z_MulticastGetQueryObjectui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastGetQueryObjectui64vNV(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: array of UInt64);
begin
z_MulticastGetQueryObjectui64vNV_ovr_0(gpu, id, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastGetQueryObjectui64vNV(gpu: UInt32; id: UInt32; pname: DummyEnum; var ¶ms: UInt64);
begin
z_MulticastGetQueryObjectui64vNV_ovr_0(gpu, id, pname, ¶ms);
end;
public z_MulticastGetQueryObjectui64vNV_ovr_2 := GetFuncOrNil&<procedure(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: IntPtr)>(z_MulticastGetQueryObjectui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastGetQueryObjectui64vNV(gpu: UInt32; id: UInt32; pname: DummyEnum; ¶ms: IntPtr);
begin
z_MulticastGetQueryObjectui64vNV_ovr_2(gpu, id, pname, ¶ms);
end;
end;
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);
public z_UploadGpuMaskNVX_adr := GetFuncAdr('glUploadGpuMaskNVX');
public z_UploadGpuMaskNVX_ovr_0 := GetFuncOrNil&<procedure(mask: DummyFlags)>(z_UploadGpuMaskNVX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure UploadGpuMaskNVX(mask: DummyFlags);
begin
z_UploadGpuMaskNVX_ovr_0(mask);
end;
public z_MulticastViewportArrayvNVX_adr := GetFuncAdr('glMulticastViewportArrayvNVX');
public z_MulticastViewportArrayvNVX_ovr_0 := GetFuncOrNil&<procedure(gpu: UInt32; first: UInt32; count: Int32; var v: single)>(z_MulticastViewportArrayvNVX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastViewportArrayvNVX(gpu: UInt32; first: UInt32; count: Int32; v: array of single);
begin
z_MulticastViewportArrayvNVX_ovr_0(gpu, first, count, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastViewportArrayvNVX(gpu: UInt32; first: UInt32; count: Int32; var v: single);
begin
z_MulticastViewportArrayvNVX_ovr_0(gpu, first, count, v);
end;
public z_MulticastViewportArrayvNVX_ovr_2 := GetFuncOrNil&<procedure(gpu: UInt32; first: UInt32; count: Int32; v: IntPtr)>(z_MulticastViewportArrayvNVX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastViewportArrayvNVX(gpu: UInt32; first: UInt32; count: Int32; v: IntPtr);
begin
z_MulticastViewportArrayvNVX_ovr_2(gpu, first, count, v);
end;
public z_MulticastViewportPositionWScaleNVX_adr := GetFuncAdr('glMulticastViewportPositionWScaleNVX');
public z_MulticastViewportPositionWScaleNVX_ovr_0 := GetFuncOrNil&<procedure(gpu: UInt32; index: UInt32; xcoeff: single; ycoeff: single)>(z_MulticastViewportPositionWScaleNVX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastViewportPositionWScaleNVX(gpu: UInt32; index: UInt32; xcoeff: single; ycoeff: single);
begin
z_MulticastViewportPositionWScaleNVX_ovr_0(gpu, index, xcoeff, ycoeff);
end;
public z_MulticastScissorArrayvNVX_adr := GetFuncAdr('glMulticastScissorArrayvNVX');
public z_MulticastScissorArrayvNVX_ovr_0 := GetFuncOrNil&<procedure(gpu: UInt32; first: UInt32; count: Int32; var v: Int32)>(z_MulticastScissorArrayvNVX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastScissorArrayvNVX(gpu: UInt32; first: UInt32; count: Int32; v: array of Int32);
begin
z_MulticastScissorArrayvNVX_ovr_0(gpu, first, count, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastScissorArrayvNVX(gpu: UInt32; first: UInt32; count: Int32; var v: Int32);
begin
z_MulticastScissorArrayvNVX_ovr_0(gpu, first, count, v);
end;
public z_MulticastScissorArrayvNVX_ovr_2 := GetFuncOrNil&<procedure(gpu: UInt32; first: UInt32; count: Int32; v: IntPtr)>(z_MulticastScissorArrayvNVX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MulticastScissorArrayvNVX(gpu: UInt32; first: UInt32; count: Int32; v: IntPtr);
begin
z_MulticastScissorArrayvNVX_ovr_2(gpu, first, count, v);
end;
public z_AsyncCopyBufferSubDataNVX_adr := GetFuncAdr('glAsyncCopyBufferSubDataNVX');
public z_AsyncCopyBufferSubDataNVX_ovr_0 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray);
end;
public z_AsyncCopyBufferSubDataNVX_ovr_2 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_2(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_2(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
public z_AsyncCopyBufferSubDataNVX_ovr_6 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_6(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_6(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
public z_AsyncCopyBufferSubDataNVX_ovr_8 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_8(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_2(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_2(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_6(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_6(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_8(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
public z_AsyncCopyBufferSubDataNVX_ovr_18 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_18(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_18(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray);
end;
public z_AsyncCopyBufferSubDataNVX_ovr_20 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_20(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_18(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_18(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_20(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
public z_AsyncCopyBufferSubDataNVX_ovr_24 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_24(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_24(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
public z_AsyncCopyBufferSubDataNVX_ovr_26 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_26(waitSemaphoreCount, waitSemaphoreArray[0], fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_2(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_2(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_6(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_6(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_8(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_2(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_0(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_2(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_6(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_6(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_8(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_18(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_18(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_20(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_18(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_18(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_20(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_24(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_24(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_26(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
public z_AsyncCopyBufferSubDataNVX_ovr_54 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_54(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_54(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray);
end;
public z_AsyncCopyBufferSubDataNVX_ovr_56 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_56(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_54(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_54(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_56(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
public z_AsyncCopyBufferSubDataNVX_ovr_60 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_60(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_60(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
public z_AsyncCopyBufferSubDataNVX_ovr_62 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_62(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray[0], readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_54(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_54(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_56(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_54(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_54(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_56(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_60(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_60(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_62(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
public z_AsyncCopyBufferSubDataNVX_ovr_72 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_72(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray[0]);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_72(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray);
end;
public z_AsyncCopyBufferSubDataNVX_ovr_74 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_74(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray[0], signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_72(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_72(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_74(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
public z_AsyncCopyBufferSubDataNVX_ovr_78 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_78(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray[0]);
end;
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_78(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
public z_AsyncCopyBufferSubDataNVX_ovr_80 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := z_AsyncCopyBufferSubDataNVX_ovr_80(waitSemaphoreCount, waitSemaphoreArray, fenceValueArray, readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size, signalSemaphoreCount, signalSemaphoreArray, signalValueArray);
end;
public z_AsyncCopyImageSubDataNVX_adr := GetFuncAdr('glAsyncCopyImageSubDataNVX');
public z_AsyncCopyImageSubDataNVX_ovr_0 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := 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]);
end;
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;
begin
Result := 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);
end;
public z_AsyncCopyImageSubDataNVX_ovr_2 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := 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);
end;
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;
begin
Result := 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]);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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);
end;
public z_AsyncCopyImageSubDataNVX_ovr_6 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := 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]);
end;
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;
begin
Result := 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);
end;
public z_AsyncCopyImageSubDataNVX_ovr_8 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := 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);
end;
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;
begin
Result := 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]);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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]);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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]);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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);
end;
public z_AsyncCopyImageSubDataNVX_ovr_18 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := 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]);
end;
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;
begin
Result := 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);
end;
public z_AsyncCopyImageSubDataNVX_ovr_20 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := 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);
end;
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;
begin
Result := 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]);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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);
end;
public z_AsyncCopyImageSubDataNVX_ovr_24 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := 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]);
end;
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;
begin
Result := 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);
end;
public z_AsyncCopyImageSubDataNVX_ovr_26 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := 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);
end;
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;
begin
Result := 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]);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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]);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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]);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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]);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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]);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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]);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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]);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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]);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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]);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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);
end;
public z_AsyncCopyImageSubDataNVX_ovr_54 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := 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]);
end;
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;
begin
Result := 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);
end;
public z_AsyncCopyImageSubDataNVX_ovr_56 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := 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);
end;
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;
begin
Result := 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]);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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);
end;
public z_AsyncCopyImageSubDataNVX_ovr_60 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := 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]);
end;
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;
begin
Result := 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);
end;
public z_AsyncCopyImageSubDataNVX_ovr_62 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := 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);
end;
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;
begin
Result := 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]);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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]);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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]);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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);
end;
public z_AsyncCopyImageSubDataNVX_ovr_72 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := 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]);
end;
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;
begin
Result := 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);
end;
public z_AsyncCopyImageSubDataNVX_ovr_74 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := 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);
end;
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;
begin
Result := 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]);
end;
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;
begin
Result := 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);
end;
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;
begin
Result := 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);
end;
public z_AsyncCopyImageSubDataNVX_ovr_78 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := 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]);
end;
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;
begin
Result := 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);
end;
public z_AsyncCopyImageSubDataNVX_ovr_80 := GetFuncOrNil&<function(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_adr);
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;
begin
Result := 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;
end;
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);
public z_CreateProgressFenceNVX_adr := GetFuncAdr('glCreateProgressFenceNVX');
public z_CreateProgressFenceNVX_ovr_0 := GetFuncOrNil&<function: UInt32>(z_CreateProgressFenceNVX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function CreateProgressFenceNVX: UInt32;
begin
Result := z_CreateProgressFenceNVX_ovr_0;
end;
public z_SignalSemaphoreui64NVX_adr := GetFuncAdr('glSignalSemaphoreui64NVX');
public z_SignalSemaphoreui64NVX_ovr_0 := GetFuncOrNil&<procedure(signalGpu: UInt32; fenceObjectCount: Int32; var semaphoreArray: UInt32; var fenceValueArray: UInt64)>(z_SignalSemaphoreui64NVX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreui64NVX(signalGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: array of UInt32; fenceValueArray: array of UInt64);
begin
z_SignalSemaphoreui64NVX_ovr_0(signalGpu, fenceObjectCount, semaphoreArray[0], fenceValueArray[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreui64NVX(signalGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: array of UInt32; var fenceValueArray: UInt64);
begin
z_SignalSemaphoreui64NVX_ovr_0(signalGpu, fenceObjectCount, semaphoreArray[0], fenceValueArray);
end;
public z_SignalSemaphoreui64NVX_ovr_2 := GetFuncOrNil&<procedure(signalGpu: UInt32; fenceObjectCount: Int32; var semaphoreArray: UInt32; fenceValueArray: IntPtr)>(z_SignalSemaphoreui64NVX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreui64NVX(signalGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: array of UInt32; fenceValueArray: IntPtr);
begin
z_SignalSemaphoreui64NVX_ovr_2(signalGpu, fenceObjectCount, semaphoreArray[0], fenceValueArray);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreui64NVX(signalGpu: UInt32; fenceObjectCount: Int32; var semaphoreArray: UInt32; fenceValueArray: array of UInt64);
begin
z_SignalSemaphoreui64NVX_ovr_0(signalGpu, fenceObjectCount, semaphoreArray, fenceValueArray[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreui64NVX(signalGpu: UInt32; fenceObjectCount: Int32; var semaphoreArray: UInt32; var fenceValueArray: UInt64);
begin
z_SignalSemaphoreui64NVX_ovr_0(signalGpu, fenceObjectCount, semaphoreArray, fenceValueArray);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreui64NVX(signalGpu: UInt32; fenceObjectCount: Int32; var semaphoreArray: UInt32; fenceValueArray: IntPtr);
begin
z_SignalSemaphoreui64NVX_ovr_2(signalGpu, fenceObjectCount, semaphoreArray, fenceValueArray);
end;
public z_SignalSemaphoreui64NVX_ovr_6 := GetFuncOrNil&<procedure(signalGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; var fenceValueArray: UInt64)>(z_SignalSemaphoreui64NVX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreui64NVX(signalGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; fenceValueArray: array of UInt64);
begin
z_SignalSemaphoreui64NVX_ovr_6(signalGpu, fenceObjectCount, semaphoreArray, fenceValueArray[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreui64NVX(signalGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; var fenceValueArray: UInt64);
begin
z_SignalSemaphoreui64NVX_ovr_6(signalGpu, fenceObjectCount, semaphoreArray, fenceValueArray);
end;
public z_SignalSemaphoreui64NVX_ovr_8 := GetFuncOrNil&<procedure(signalGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; fenceValueArray: IntPtr)>(z_SignalSemaphoreui64NVX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SignalSemaphoreui64NVX(signalGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; fenceValueArray: IntPtr);
begin
z_SignalSemaphoreui64NVX_ovr_8(signalGpu, fenceObjectCount, semaphoreArray, fenceValueArray);
end;
public z_WaitSemaphoreui64NVX_adr := GetFuncAdr('glWaitSemaphoreui64NVX');
public z_WaitSemaphoreui64NVX_ovr_0 := GetFuncOrNil&<procedure(waitGpu: UInt32; fenceObjectCount: Int32; var semaphoreArray: UInt32; var fenceValueArray: UInt64)>(z_WaitSemaphoreui64NVX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreui64NVX(waitGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: array of UInt32; fenceValueArray: array of UInt64);
begin
z_WaitSemaphoreui64NVX_ovr_0(waitGpu, fenceObjectCount, semaphoreArray[0], fenceValueArray[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreui64NVX(waitGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: array of UInt32; var fenceValueArray: UInt64);
begin
z_WaitSemaphoreui64NVX_ovr_0(waitGpu, fenceObjectCount, semaphoreArray[0], fenceValueArray);
end;
public z_WaitSemaphoreui64NVX_ovr_2 := GetFuncOrNil&<procedure(waitGpu: UInt32; fenceObjectCount: Int32; var semaphoreArray: UInt32; fenceValueArray: IntPtr)>(z_WaitSemaphoreui64NVX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreui64NVX(waitGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: array of UInt32; fenceValueArray: IntPtr);
begin
z_WaitSemaphoreui64NVX_ovr_2(waitGpu, fenceObjectCount, semaphoreArray[0], fenceValueArray);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreui64NVX(waitGpu: UInt32; fenceObjectCount: Int32; var semaphoreArray: UInt32; fenceValueArray: array of UInt64);
begin
z_WaitSemaphoreui64NVX_ovr_0(waitGpu, fenceObjectCount, semaphoreArray, fenceValueArray[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreui64NVX(waitGpu: UInt32; fenceObjectCount: Int32; var semaphoreArray: UInt32; var fenceValueArray: UInt64);
begin
z_WaitSemaphoreui64NVX_ovr_0(waitGpu, fenceObjectCount, semaphoreArray, fenceValueArray);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreui64NVX(waitGpu: UInt32; fenceObjectCount: Int32; var semaphoreArray: UInt32; fenceValueArray: IntPtr);
begin
z_WaitSemaphoreui64NVX_ovr_2(waitGpu, fenceObjectCount, semaphoreArray, fenceValueArray);
end;
public z_WaitSemaphoreui64NVX_ovr_6 := GetFuncOrNil&<procedure(waitGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; var fenceValueArray: UInt64)>(z_WaitSemaphoreui64NVX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreui64NVX(waitGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; fenceValueArray: array of UInt64);
begin
z_WaitSemaphoreui64NVX_ovr_6(waitGpu, fenceObjectCount, semaphoreArray, fenceValueArray[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreui64NVX(waitGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; var fenceValueArray: UInt64);
begin
z_WaitSemaphoreui64NVX_ovr_6(waitGpu, fenceObjectCount, semaphoreArray, fenceValueArray);
end;
public z_WaitSemaphoreui64NVX_ovr_8 := GetFuncOrNil&<procedure(waitGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; fenceValueArray: IntPtr)>(z_WaitSemaphoreui64NVX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WaitSemaphoreui64NVX(waitGpu: UInt32; fenceObjectCount: Int32; semaphoreArray: IntPtr; fenceValueArray: IntPtr);
begin
z_WaitSemaphoreui64NVX_ovr_8(waitGpu, fenceObjectCount, semaphoreArray, fenceValueArray);
end;
public z_ClientWaitSemaphoreui64NVX_adr := GetFuncAdr('glClientWaitSemaphoreui64NVX');
public z_ClientWaitSemaphoreui64NVX_ovr_0 := GetFuncOrNil&<procedure(fenceObjectCount: Int32; var semaphoreArray: UInt32; var fenceValueArray: UInt64)>(z_ClientWaitSemaphoreui64NVX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClientWaitSemaphoreui64NVX(fenceObjectCount: Int32; semaphoreArray: array of UInt32; fenceValueArray: array of UInt64);
begin
z_ClientWaitSemaphoreui64NVX_ovr_0(fenceObjectCount, semaphoreArray[0], fenceValueArray[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClientWaitSemaphoreui64NVX(fenceObjectCount: Int32; semaphoreArray: array of UInt32; var fenceValueArray: UInt64);
begin
z_ClientWaitSemaphoreui64NVX_ovr_0(fenceObjectCount, semaphoreArray[0], fenceValueArray);
end;
public z_ClientWaitSemaphoreui64NVX_ovr_2 := GetFuncOrNil&<procedure(fenceObjectCount: Int32; var semaphoreArray: UInt32; fenceValueArray: IntPtr)>(z_ClientWaitSemaphoreui64NVX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClientWaitSemaphoreui64NVX(fenceObjectCount: Int32; semaphoreArray: array of UInt32; fenceValueArray: IntPtr);
begin
z_ClientWaitSemaphoreui64NVX_ovr_2(fenceObjectCount, semaphoreArray[0], fenceValueArray);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClientWaitSemaphoreui64NVX(fenceObjectCount: Int32; var semaphoreArray: UInt32; fenceValueArray: array of UInt64);
begin
z_ClientWaitSemaphoreui64NVX_ovr_0(fenceObjectCount, semaphoreArray, fenceValueArray[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClientWaitSemaphoreui64NVX(fenceObjectCount: Int32; var semaphoreArray: UInt32; var fenceValueArray: UInt64);
begin
z_ClientWaitSemaphoreui64NVX_ovr_0(fenceObjectCount, semaphoreArray, fenceValueArray);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClientWaitSemaphoreui64NVX(fenceObjectCount: Int32; var semaphoreArray: UInt32; fenceValueArray: IntPtr);
begin
z_ClientWaitSemaphoreui64NVX_ovr_2(fenceObjectCount, semaphoreArray, fenceValueArray);
end;
public z_ClientWaitSemaphoreui64NVX_ovr_6 := GetFuncOrNil&<procedure(fenceObjectCount: Int32; semaphoreArray: IntPtr; var fenceValueArray: UInt64)>(z_ClientWaitSemaphoreui64NVX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClientWaitSemaphoreui64NVX(fenceObjectCount: Int32; semaphoreArray: IntPtr; fenceValueArray: array of UInt64);
begin
z_ClientWaitSemaphoreui64NVX_ovr_6(fenceObjectCount, semaphoreArray, fenceValueArray[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClientWaitSemaphoreui64NVX(fenceObjectCount: Int32; semaphoreArray: IntPtr; var fenceValueArray: UInt64);
begin
z_ClientWaitSemaphoreui64NVX_ovr_6(fenceObjectCount, semaphoreArray, fenceValueArray);
end;
public z_ClientWaitSemaphoreui64NVX_ovr_8 := GetFuncOrNil&<procedure(fenceObjectCount: Int32; semaphoreArray: IntPtr; fenceValueArray: IntPtr)>(z_ClientWaitSemaphoreui64NVX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClientWaitSemaphoreui64NVX(fenceObjectCount: Int32; semaphoreArray: IntPtr; fenceValueArray: IntPtr);
begin
z_ClientWaitSemaphoreui64NVX_ovr_8(fenceObjectCount, semaphoreArray, fenceValueArray);
end;
end;
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);
public z_GetMemoryObjectDetachedResourcesuivNV_adr := GetFuncAdr('glGetMemoryObjectDetachedResourcesuivNV');
public z_GetMemoryObjectDetachedResourcesuivNV_ovr_0 := GetFuncOrNil&<procedure(memory: UInt32; pname: DummyEnum; first: Int32; count: Int32; var ¶ms: UInt32)>(z_GetMemoryObjectDetachedResourcesuivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMemoryObjectDetachedResourcesuivNV(memory: UInt32; pname: DummyEnum; first: Int32; count: Int32; ¶ms: array of UInt32);
begin
z_GetMemoryObjectDetachedResourcesuivNV_ovr_0(memory, pname, first, count, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMemoryObjectDetachedResourcesuivNV(memory: UInt32; pname: DummyEnum; first: Int32; count: Int32; var ¶ms: UInt32);
begin
z_GetMemoryObjectDetachedResourcesuivNV_ovr_0(memory, pname, first, count, ¶ms);
end;
public z_GetMemoryObjectDetachedResourcesuivNV_ovr_2 := GetFuncOrNil&<procedure(memory: UInt32; pname: DummyEnum; first: Int32; count: Int32; ¶ms: IntPtr)>(z_GetMemoryObjectDetachedResourcesuivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMemoryObjectDetachedResourcesuivNV(memory: UInt32; pname: DummyEnum; first: Int32; count: Int32; ¶ms: IntPtr);
begin
z_GetMemoryObjectDetachedResourcesuivNV_ovr_2(memory, pname, first, count, ¶ms);
end;
public z_ResetMemoryObjectParameterNV_adr := GetFuncAdr('glResetMemoryObjectParameterNV');
public z_ResetMemoryObjectParameterNV_ovr_0 := GetFuncOrNil&<procedure(memory: UInt32; pname: DummyEnum)>(z_ResetMemoryObjectParameterNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ResetMemoryObjectParameterNV(memory: UInt32; pname: DummyEnum);
begin
z_ResetMemoryObjectParameterNV_ovr_0(memory, pname);
end;
public z_TexAttachMemoryNV_adr := GetFuncAdr('glTexAttachMemoryNV');
public z_TexAttachMemoryNV_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; memory: UInt32; offset: UInt64)>(z_TexAttachMemoryNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexAttachMemoryNV(target: TextureTarget; memory: UInt32; offset: UInt64);
begin
z_TexAttachMemoryNV_ovr_0(target, memory, offset);
end;
public z_BufferAttachMemoryNV_adr := GetFuncAdr('glBufferAttachMemoryNV');
public z_BufferAttachMemoryNV_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; memory: UInt32; offset: UInt64)>(z_BufferAttachMemoryNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferAttachMemoryNV(target: BufferTargetARB; memory: UInt32; offset: UInt64);
begin
z_BufferAttachMemoryNV_ovr_0(target, memory, offset);
end;
public z_TextureAttachMemoryNV_adr := GetFuncAdr('glTextureAttachMemoryNV');
public z_TextureAttachMemoryNV_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; memory: UInt32; offset: UInt64)>(z_TextureAttachMemoryNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureAttachMemoryNV(texture: UInt32; memory: UInt32; offset: UInt64);
begin
z_TextureAttachMemoryNV_ovr_0(texture, memory, offset);
end;
public z_NamedBufferAttachMemoryNV_adr := GetFuncAdr('glNamedBufferAttachMemoryNV');
public z_NamedBufferAttachMemoryNV_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; memory: UInt32; offset: UInt64)>(z_NamedBufferAttachMemoryNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferAttachMemoryNV(buffer: UInt32; memory: UInt32; offset: UInt64);
begin
z_NamedBufferAttachMemoryNV_ovr_0(buffer, memory, offset);
end;
end;
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);
public z_DrawMeshTasksNV_adr := GetFuncAdr('glDrawMeshTasksNV');
public z_DrawMeshTasksNV_ovr_0 := GetFuncOrNil&<procedure(first: UInt32; count: UInt32)>(z_DrawMeshTasksNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawMeshTasksNV(first: UInt32; count: UInt32);
begin
z_DrawMeshTasksNV_ovr_0(first, count);
end;
public z_DrawMeshTasksIndirectNV_adr := GetFuncAdr('glDrawMeshTasksIndirectNV');
public z_DrawMeshTasksIndirectNV_ovr_0 := GetFuncOrNil&<procedure(indirect: IntPtr)>(z_DrawMeshTasksIndirectNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawMeshTasksIndirectNV(indirect: IntPtr);
begin
z_DrawMeshTasksIndirectNV_ovr_0(indirect);
end;
public z_MultiDrawMeshTasksIndirectNV_adr := GetFuncAdr('glMultiDrawMeshTasksIndirectNV');
public z_MultiDrawMeshTasksIndirectNV_ovr_0 := GetFuncOrNil&<procedure(indirect: IntPtr; drawcount: Int32; stride: Int32)>(z_MultiDrawMeshTasksIndirectNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawMeshTasksIndirectNV(indirect: IntPtr; drawcount: Int32; stride: Int32);
begin
z_MultiDrawMeshTasksIndirectNV_ovr_0(indirect, drawcount, stride);
end;
public z_MultiDrawMeshTasksIndirectCountNV_adr := GetFuncAdr('glMultiDrawMeshTasksIndirectCountNV');
public z_MultiDrawMeshTasksIndirectCountNV_ovr_0 := GetFuncOrNil&<procedure(indirect: IntPtr; drawcount: IntPtr; maxdrawcount: Int32; stride: Int32)>(z_MultiDrawMeshTasksIndirectCountNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiDrawMeshTasksIndirectCountNV(indirect: IntPtr; drawcount: IntPtr; maxdrawcount: Int32; stride: Int32);
begin
z_MultiDrawMeshTasksIndirectCountNV_ovr_0(indirect, drawcount, maxdrawcount, stride);
end;
end;
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);
public z_GenOcclusionQueriesNV_adr := GetFuncAdr('glGenOcclusionQueriesNV');
public z_GenOcclusionQueriesNV_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var ids: UInt32)>(z_GenOcclusionQueriesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenOcclusionQueriesNV(n: Int32; ids: array of UInt32);
begin
z_GenOcclusionQueriesNV_ovr_0(n, ids[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenOcclusionQueriesNV(n: Int32; var ids: UInt32);
begin
z_GenOcclusionQueriesNV_ovr_0(n, ids);
end;
public z_GenOcclusionQueriesNV_ovr_2 := GetFuncOrNil&<procedure(n: Int32; ids: IntPtr)>(z_GenOcclusionQueriesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenOcclusionQueriesNV(n: Int32; ids: IntPtr);
begin
z_GenOcclusionQueriesNV_ovr_2(n, ids);
end;
public z_DeleteOcclusionQueriesNV_adr := GetFuncAdr('glDeleteOcclusionQueriesNV');
public z_DeleteOcclusionQueriesNV_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var ids: UInt32)>(z_DeleteOcclusionQueriesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteOcclusionQueriesNV(n: Int32; ids: array of UInt32);
begin
z_DeleteOcclusionQueriesNV_ovr_0(n, ids[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteOcclusionQueriesNV(n: Int32; var ids: UInt32);
begin
z_DeleteOcclusionQueriesNV_ovr_0(n, ids);
end;
public z_DeleteOcclusionQueriesNV_ovr_2 := GetFuncOrNil&<procedure(n: Int32; ids: IntPtr)>(z_DeleteOcclusionQueriesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteOcclusionQueriesNV(n: Int32; ids: IntPtr);
begin
z_DeleteOcclusionQueriesNV_ovr_2(n, ids);
end;
public z_IsOcclusionQueryNV_adr := GetFuncAdr('glIsOcclusionQueryNV');
public z_IsOcclusionQueryNV_ovr_0 := GetFuncOrNil&<function(id: UInt32): boolean>(z_IsOcclusionQueryNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsOcclusionQueryNV(id: UInt32): boolean;
begin
Result := z_IsOcclusionQueryNV_ovr_0(id);
end;
public z_BeginOcclusionQueryNV_adr := GetFuncAdr('glBeginOcclusionQueryNV');
public z_BeginOcclusionQueryNV_ovr_0 := GetFuncOrNil&<procedure(id: UInt32)>(z_BeginOcclusionQueryNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginOcclusionQueryNV(id: UInt32);
begin
z_BeginOcclusionQueryNV_ovr_0(id);
end;
public z_EndOcclusionQueryNV_adr := GetFuncAdr('glEndOcclusionQueryNV');
public z_EndOcclusionQueryNV_ovr_0 := GetFuncOrNil&<procedure>(z_EndOcclusionQueryNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndOcclusionQueryNV;
begin
z_EndOcclusionQueryNV_ovr_0;
end;
public z_GetOcclusionQueryivNV_adr := GetFuncAdr('glGetOcclusionQueryivNV');
public z_GetOcclusionQueryivNV_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; pname: OcclusionQueryParameterNameNV; var ¶ms: Int32)>(z_GetOcclusionQueryivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetOcclusionQueryivNV(id: UInt32; pname: OcclusionQueryParameterNameNV; ¶ms: array of Int32);
begin
z_GetOcclusionQueryivNV_ovr_0(id, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetOcclusionQueryivNV(id: UInt32; pname: OcclusionQueryParameterNameNV; var ¶ms: Int32);
begin
z_GetOcclusionQueryivNV_ovr_0(id, pname, ¶ms);
end;
public z_GetOcclusionQueryivNV_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; pname: OcclusionQueryParameterNameNV; ¶ms: IntPtr)>(z_GetOcclusionQueryivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetOcclusionQueryivNV(id: UInt32; pname: OcclusionQueryParameterNameNV; ¶ms: IntPtr);
begin
z_GetOcclusionQueryivNV_ovr_2(id, pname, ¶ms);
end;
public z_GetOcclusionQueryuivNV_adr := GetFuncAdr('glGetOcclusionQueryuivNV');
public z_GetOcclusionQueryuivNV_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; pname: OcclusionQueryParameterNameNV; var ¶ms: UInt32)>(z_GetOcclusionQueryuivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetOcclusionQueryuivNV(id: UInt32; pname: OcclusionQueryParameterNameNV; ¶ms: array of UInt32);
begin
z_GetOcclusionQueryuivNV_ovr_0(id, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetOcclusionQueryuivNV(id: UInt32; pname: OcclusionQueryParameterNameNV; var ¶ms: UInt32);
begin
z_GetOcclusionQueryuivNV_ovr_0(id, pname, ¶ms);
end;
public z_GetOcclusionQueryuivNV_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; pname: OcclusionQueryParameterNameNV; ¶ms: IntPtr)>(z_GetOcclusionQueryuivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetOcclusionQueryuivNV(id: UInt32; pname: OcclusionQueryParameterNameNV; ¶ms: IntPtr);
begin
z_GetOcclusionQueryuivNV_ovr_2(id, pname, ¶ms);
end;
end;
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);
public z_ProgramBufferParametersfvNV_adr := GetFuncAdr('glProgramBufferParametersfvNV');
public z_ProgramBufferParametersfvNV_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; var ¶ms: single)>(z_ProgramBufferParametersfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramBufferParametersfvNV(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; ¶ms: array of single);
begin
z_ProgramBufferParametersfvNV_ovr_0(target, bindingIndex, wordIndex, count, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramBufferParametersfvNV(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; var ¶ms: single);
begin
z_ProgramBufferParametersfvNV_ovr_0(target, bindingIndex, wordIndex, count, ¶ms);
end;
public z_ProgramBufferParametersfvNV_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; ¶ms: IntPtr)>(z_ProgramBufferParametersfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramBufferParametersfvNV(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; ¶ms: IntPtr);
begin
z_ProgramBufferParametersfvNV_ovr_2(target, bindingIndex, wordIndex, count, ¶ms);
end;
public z_ProgramBufferParametersIivNV_adr := GetFuncAdr('glProgramBufferParametersIivNV');
public z_ProgramBufferParametersIivNV_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; var ¶ms: Int32)>(z_ProgramBufferParametersIivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramBufferParametersIivNV(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; ¶ms: array of Int32);
begin
z_ProgramBufferParametersIivNV_ovr_0(target, bindingIndex, wordIndex, count, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramBufferParametersIivNV(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; var ¶ms: Int32);
begin
z_ProgramBufferParametersIivNV_ovr_0(target, bindingIndex, wordIndex, count, ¶ms);
end;
public z_ProgramBufferParametersIivNV_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; ¶ms: IntPtr)>(z_ProgramBufferParametersIivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramBufferParametersIivNV(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; ¶ms: IntPtr);
begin
z_ProgramBufferParametersIivNV_ovr_2(target, bindingIndex, wordIndex, count, ¶ms);
end;
public z_ProgramBufferParametersIuivNV_adr := GetFuncAdr('glProgramBufferParametersIuivNV');
public z_ProgramBufferParametersIuivNV_ovr_0 := GetFuncOrNil&<procedure(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; var ¶ms: UInt32)>(z_ProgramBufferParametersIuivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramBufferParametersIuivNV(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; ¶ms: array of UInt32);
begin
z_ProgramBufferParametersIuivNV_ovr_0(target, bindingIndex, wordIndex, count, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramBufferParametersIuivNV(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; var ¶ms: UInt32);
begin
z_ProgramBufferParametersIuivNV_ovr_0(target, bindingIndex, wordIndex, count, ¶ms);
end;
public z_ProgramBufferParametersIuivNV_ovr_2 := GetFuncOrNil&<procedure(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; ¶ms: IntPtr)>(z_ProgramBufferParametersIuivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramBufferParametersIuivNV(target: ProgramTarget; bindingIndex: UInt32; wordIndex: UInt32; count: Int32; ¶ms: IntPtr);
begin
z_ProgramBufferParametersIuivNV_ovr_2(target, bindingIndex, wordIndex, count, ¶ms);
end;
end;
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);
public z_GenPathsNV_adr := GetFuncAdr('glGenPathsNV');
public z_GenPathsNV_ovr_0 := GetFuncOrNil&<function(range: Int32): UInt32>(z_GenPathsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GenPathsNV(range: Int32): UInt32;
begin
Result := z_GenPathsNV_ovr_0(range);
end;
public z_DeletePathsNV_adr := GetFuncAdr('glDeletePathsNV');
public z_DeletePathsNV_ovr_0 := GetFuncOrNil&<procedure(path: UInt32; range: Int32)>(z_DeletePathsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeletePathsNV(path: UInt32; range: Int32);
begin
z_DeletePathsNV_ovr_0(path, range);
end;
public z_IsPathNV_adr := GetFuncAdr('glIsPathNV');
public z_IsPathNV_ovr_0 := GetFuncOrNil&<function(path: UInt32): boolean>(z_IsPathNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsPathNV(path: UInt32): boolean;
begin
Result := z_IsPathNV_ovr_0(path);
end;
public z_PathCommandsNV_adr := GetFuncAdr('glPathCommandsNV');
public z_PathCommandsNV_ovr_0 := GetFuncOrNil&<procedure(path: UInt32; numCommands: Int32; var commands: Byte; numCoords: Int32; coordType: PathCoordType; coords: IntPtr)>(z_PathCommandsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathCommandsNV(path: UInt32; numCommands: Int32; commands: array of Byte; numCoords: Int32; coordType: PathCoordType; coords: IntPtr);
begin
z_PathCommandsNV_ovr_0(path, numCommands, commands[0], numCoords, coordType, coords);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathCommandsNV(path: UInt32; numCommands: Int32; var commands: Byte; numCoords: Int32; coordType: PathCoordType; coords: IntPtr);
begin
z_PathCommandsNV_ovr_0(path, numCommands, commands, numCoords, coordType, coords);
end;
public z_PathCommandsNV_ovr_2 := GetFuncOrNil&<procedure(path: UInt32; numCommands: Int32; commands: IntPtr; numCoords: Int32; coordType: PathCoordType; coords: IntPtr)>(z_PathCommandsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathCommandsNV(path: UInt32; numCommands: Int32; commands: IntPtr; numCoords: Int32; coordType: PathCoordType; coords: IntPtr);
begin
z_PathCommandsNV_ovr_2(path, numCommands, commands, numCoords, coordType, coords);
end;
public z_PathCoordsNV_adr := GetFuncAdr('glPathCoordsNV');
public z_PathCoordsNV_ovr_0 := GetFuncOrNil&<procedure(path: UInt32; numCoords: Int32; coordType: PathCoordType; coords: IntPtr)>(z_PathCoordsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathCoordsNV(path: UInt32; numCoords: Int32; coordType: PathCoordType; coords: IntPtr);
begin
z_PathCoordsNV_ovr_0(path, numCoords, coordType, coords);
end;
public z_PathSubCommandsNV_adr := GetFuncAdr('glPathSubCommandsNV');
public z_PathSubCommandsNV_ovr_0 := GetFuncOrNil&<procedure(path: UInt32; commandStart: Int32; commandsToDelete: Int32; numCommands: Int32; var commands: Byte; numCoords: Int32; coordType: PathCoordType; coords: IntPtr)>(z_PathSubCommandsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathSubCommandsNV(path: UInt32; commandStart: Int32; commandsToDelete: Int32; numCommands: Int32; commands: array of Byte; numCoords: Int32; coordType: PathCoordType; coords: IntPtr);
begin
z_PathSubCommandsNV_ovr_0(path, commandStart, commandsToDelete, numCommands, commands[0], numCoords, coordType, coords);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathSubCommandsNV(path: UInt32; commandStart: Int32; commandsToDelete: Int32; numCommands: Int32; var commands: Byte; numCoords: Int32; coordType: PathCoordType; coords: IntPtr);
begin
z_PathSubCommandsNV_ovr_0(path, commandStart, commandsToDelete, numCommands, commands, numCoords, coordType, coords);
end;
public z_PathSubCommandsNV_ovr_2 := GetFuncOrNil&<procedure(path: UInt32; commandStart: Int32; commandsToDelete: Int32; numCommands: Int32; commands: IntPtr; numCoords: Int32; coordType: PathCoordType; coords: IntPtr)>(z_PathSubCommandsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathSubCommandsNV(path: UInt32; commandStart: Int32; commandsToDelete: Int32; numCommands: Int32; commands: IntPtr; numCoords: Int32; coordType: PathCoordType; coords: IntPtr);
begin
z_PathSubCommandsNV_ovr_2(path, commandStart, commandsToDelete, numCommands, commands, numCoords, coordType, coords);
end;
public z_PathSubCoordsNV_adr := GetFuncAdr('glPathSubCoordsNV');
public z_PathSubCoordsNV_ovr_0 := GetFuncOrNil&<procedure(path: UInt32; coordStart: Int32; numCoords: Int32; coordType: PathCoordType; coords: IntPtr)>(z_PathSubCoordsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathSubCoordsNV(path: UInt32; coordStart: Int32; numCoords: Int32; coordType: PathCoordType; coords: IntPtr);
begin
z_PathSubCoordsNV_ovr_0(path, coordStart, numCoords, coordType, coords);
end;
public z_PathStringNV_adr := GetFuncAdr('glPathStringNV');
public z_PathStringNV_ovr_0 := GetFuncOrNil&<procedure(path: UInt32; format: PathStringFormat; length: Int32; pathString: IntPtr)>(z_PathStringNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathStringNV(path: UInt32; format: PathStringFormat; length: Int32; pathString: IntPtr);
begin
z_PathStringNV_ovr_0(path, format, length, pathString);
end;
public z_PathGlyphsNV_adr := GetFuncAdr('glPathGlyphsNV');
public z_PathGlyphsNV_ovr_0 := GetFuncOrNil&<procedure(firstPathName: UInt32; fontTarget: PathFontTarget; fontName: IntPtr; fontStyle: PathFontStyle; numGlyphs: Int32; &type: PathElementType; charcodes: IntPtr; handleMissingGlyphs: PathHandleMissingGlyphs; pathParameterTemplate: UInt32; emScale: single)>(z_PathGlyphsNV_adr);
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);
begin
z_PathGlyphsNV_ovr_0(firstPathName, fontTarget, fontName, fontStyle, numGlyphs, &type, charcodes, handleMissingGlyphs, pathParameterTemplate, emScale);
end;
public z_PathGlyphRangeNV_adr := GetFuncAdr('glPathGlyphRangeNV');
public z_PathGlyphRangeNV_ovr_0 := GetFuncOrNil&<procedure(firstPathName: UInt32; fontTarget: PathFontTarget; fontName: IntPtr; fontStyle: PathFontStyle; firstGlyph: UInt32; numGlyphs: Int32; handleMissingGlyphs: PathHandleMissingGlyphs; pathParameterTemplate: UInt32; emScale: single)>(z_PathGlyphRangeNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathGlyphRangeNV(firstPathName: UInt32; fontTarget: PathFontTarget; fontName: IntPtr; fontStyle: PathFontStyle; firstGlyph: UInt32; numGlyphs: Int32; handleMissingGlyphs: PathHandleMissingGlyphs; pathParameterTemplate: UInt32; emScale: single);
begin
z_PathGlyphRangeNV_ovr_0(firstPathName, fontTarget, fontName, fontStyle, firstGlyph, numGlyphs, handleMissingGlyphs, pathParameterTemplate, emScale);
end;
public z_WeightPathsNV_adr := GetFuncAdr('glWeightPathsNV');
public z_WeightPathsNV_ovr_0 := GetFuncOrNil&<procedure(resultPath: UInt32; numPaths: Int32; var paths: UInt32; var weights: single)>(z_WeightPathsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightPathsNV(resultPath: UInt32; numPaths: Int32; paths: array of UInt32; weights: array of single);
begin
z_WeightPathsNV_ovr_0(resultPath, numPaths, paths[0], weights[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightPathsNV(resultPath: UInt32; numPaths: Int32; paths: array of UInt32; var weights: single);
begin
z_WeightPathsNV_ovr_0(resultPath, numPaths, paths[0], weights);
end;
public z_WeightPathsNV_ovr_2 := GetFuncOrNil&<procedure(resultPath: UInt32; numPaths: Int32; var paths: UInt32; weights: IntPtr)>(z_WeightPathsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightPathsNV(resultPath: UInt32; numPaths: Int32; paths: array of UInt32; weights: IntPtr);
begin
z_WeightPathsNV_ovr_2(resultPath, numPaths, paths[0], weights);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightPathsNV(resultPath: UInt32; numPaths: Int32; var paths: UInt32; weights: array of single);
begin
z_WeightPathsNV_ovr_0(resultPath, numPaths, paths, weights[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightPathsNV(resultPath: UInt32; numPaths: Int32; var paths: UInt32; var weights: single);
begin
z_WeightPathsNV_ovr_0(resultPath, numPaths, paths, weights);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightPathsNV(resultPath: UInt32; numPaths: Int32; var paths: UInt32; weights: IntPtr);
begin
z_WeightPathsNV_ovr_2(resultPath, numPaths, paths, weights);
end;
public z_WeightPathsNV_ovr_6 := GetFuncOrNil&<procedure(resultPath: UInt32; numPaths: Int32; paths: IntPtr; var weights: single)>(z_WeightPathsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightPathsNV(resultPath: UInt32; numPaths: Int32; paths: IntPtr; weights: array of single);
begin
z_WeightPathsNV_ovr_6(resultPath, numPaths, paths, weights[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightPathsNV(resultPath: UInt32; numPaths: Int32; paths: IntPtr; var weights: single);
begin
z_WeightPathsNV_ovr_6(resultPath, numPaths, paths, weights);
end;
public z_WeightPathsNV_ovr_8 := GetFuncOrNil&<procedure(resultPath: UInt32; numPaths: Int32; paths: IntPtr; weights: IntPtr)>(z_WeightPathsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure WeightPathsNV(resultPath: UInt32; numPaths: Int32; paths: IntPtr; weights: IntPtr);
begin
z_WeightPathsNV_ovr_8(resultPath, numPaths, paths, weights);
end;
public z_CopyPathNV_adr := GetFuncAdr('glCopyPathNV');
public z_CopyPathNV_ovr_0 := GetFuncOrNil&<procedure(resultPath: UInt32; srcPath: UInt32)>(z_CopyPathNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyPathNV(resultPath: UInt32; srcPath: UInt32);
begin
z_CopyPathNV_ovr_0(resultPath, srcPath);
end;
public z_InterpolatePathsNV_adr := GetFuncAdr('glInterpolatePathsNV');
public z_InterpolatePathsNV_ovr_0 := GetFuncOrNil&<procedure(resultPath: UInt32; pathA: UInt32; pathB: UInt32; weight: single)>(z_InterpolatePathsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InterpolatePathsNV(resultPath: UInt32; pathA: UInt32; pathB: UInt32; weight: single);
begin
z_InterpolatePathsNV_ovr_0(resultPath, pathA, pathB, weight);
end;
public z_TransformPathNV_adr := GetFuncAdr('glTransformPathNV');
public z_TransformPathNV_ovr_0 := GetFuncOrNil&<procedure(resultPath: UInt32; srcPath: UInt32; transformType: PathTransformType; var transformValues: single)>(z_TransformPathNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformPathNV(resultPath: UInt32; srcPath: UInt32; transformType: PathTransformType; transformValues: array of single);
begin
z_TransformPathNV_ovr_0(resultPath, srcPath, transformType, transformValues[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformPathNV(resultPath: UInt32; srcPath: UInt32; transformType: PathTransformType; var transformValues: single);
begin
z_TransformPathNV_ovr_0(resultPath, srcPath, transformType, transformValues);
end;
public z_TransformPathNV_ovr_2 := GetFuncOrNil&<procedure(resultPath: UInt32; srcPath: UInt32; transformType: PathTransformType; transformValues: IntPtr)>(z_TransformPathNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformPathNV(resultPath: UInt32; srcPath: UInt32; transformType: PathTransformType; transformValues: IntPtr);
begin
z_TransformPathNV_ovr_2(resultPath, srcPath, transformType, transformValues);
end;
public z_PathParameterivNV_adr := GetFuncAdr('glPathParameterivNV');
public z_PathParameterivNV_ovr_0 := GetFuncOrNil&<procedure(path: UInt32; pname: PathParameter; var value: Int32)>(z_PathParameterivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathParameterivNV(path: UInt32; pname: PathParameter; value: array of Int32);
begin
z_PathParameterivNV_ovr_0(path, pname, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathParameterivNV(path: UInt32; pname: PathParameter; var value: Int32);
begin
z_PathParameterivNV_ovr_0(path, pname, value);
end;
public z_PathParameterivNV_ovr_2 := GetFuncOrNil&<procedure(path: UInt32; pname: PathParameter; value: IntPtr)>(z_PathParameterivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathParameterivNV(path: UInt32; pname: PathParameter; value: IntPtr);
begin
z_PathParameterivNV_ovr_2(path, pname, value);
end;
public z_PathParameteriNV_adr := GetFuncAdr('glPathParameteriNV');
public z_PathParameteriNV_ovr_0 := GetFuncOrNil&<procedure(path: UInt32; pname: PathParameter; value: Int32)>(z_PathParameteriNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathParameteriNV(path: UInt32; pname: PathParameter; value: Int32);
begin
z_PathParameteriNV_ovr_0(path, pname, value);
end;
public z_PathParameterfvNV_adr := GetFuncAdr('glPathParameterfvNV');
public z_PathParameterfvNV_ovr_0 := GetFuncOrNil&<procedure(path: UInt32; pname: PathParameter; var value: single)>(z_PathParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathParameterfvNV(path: UInt32; pname: PathParameter; value: array of single);
begin
z_PathParameterfvNV_ovr_0(path, pname, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathParameterfvNV(path: UInt32; pname: PathParameter; var value: single);
begin
z_PathParameterfvNV_ovr_0(path, pname, value);
end;
public z_PathParameterfvNV_ovr_2 := GetFuncOrNil&<procedure(path: UInt32; pname: PathParameter; value: IntPtr)>(z_PathParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathParameterfvNV(path: UInt32; pname: PathParameter; value: IntPtr);
begin
z_PathParameterfvNV_ovr_2(path, pname, value);
end;
public z_PathParameterfNV_adr := GetFuncAdr('glPathParameterfNV');
public z_PathParameterfNV_ovr_0 := GetFuncOrNil&<procedure(path: UInt32; pname: PathParameter; value: single)>(z_PathParameterfNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathParameterfNV(path: UInt32; pname: PathParameter; value: single);
begin
z_PathParameterfNV_ovr_0(path, pname, value);
end;
public z_PathDashArrayNV_adr := GetFuncAdr('glPathDashArrayNV');
public z_PathDashArrayNV_ovr_0 := GetFuncOrNil&<procedure(path: UInt32; dashCount: Int32; var dashArray: single)>(z_PathDashArrayNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathDashArrayNV(path: UInt32; dashCount: Int32; dashArray: array of single);
begin
z_PathDashArrayNV_ovr_0(path, dashCount, dashArray[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathDashArrayNV(path: UInt32; dashCount: Int32; var dashArray: single);
begin
z_PathDashArrayNV_ovr_0(path, dashCount, dashArray);
end;
public z_PathDashArrayNV_ovr_2 := GetFuncOrNil&<procedure(path: UInt32; dashCount: Int32; dashArray: IntPtr)>(z_PathDashArrayNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathDashArrayNV(path: UInt32; dashCount: Int32; dashArray: IntPtr);
begin
z_PathDashArrayNV_ovr_2(path, dashCount, dashArray);
end;
public z_PathStencilFuncNV_adr := GetFuncAdr('glPathStencilFuncNV');
public z_PathStencilFuncNV_ovr_0 := GetFuncOrNil&<procedure(func: StencilFunction; ref: Int32; mask: UInt32)>(z_PathStencilFuncNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathStencilFuncNV(func: StencilFunction; ref: Int32; mask: UInt32);
begin
z_PathStencilFuncNV_ovr_0(func, ref, mask);
end;
public z_PathStencilDepthOffsetNV_adr := GetFuncAdr('glPathStencilDepthOffsetNV');
public z_PathStencilDepthOffsetNV_ovr_0 := GetFuncOrNil&<procedure(factor: single; units: single)>(z_PathStencilDepthOffsetNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathStencilDepthOffsetNV(factor: single; units: single);
begin
z_PathStencilDepthOffsetNV_ovr_0(factor, units);
end;
public z_StencilFillPathNV_adr := GetFuncAdr('glStencilFillPathNV');
public z_StencilFillPathNV_ovr_0 := GetFuncOrNil&<procedure(path: UInt32; fillMode: PathFillMode; mask: UInt32)>(z_StencilFillPathNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilFillPathNV(path: UInt32; fillMode: PathFillMode; mask: UInt32);
begin
z_StencilFillPathNV_ovr_0(path, fillMode, mask);
end;
public z_StencilStrokePathNV_adr := GetFuncAdr('glStencilStrokePathNV');
public z_StencilStrokePathNV_ovr_0 := GetFuncOrNil&<procedure(path: UInt32; reference: Int32; mask: UInt32)>(z_StencilStrokePathNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilStrokePathNV(path: UInt32; reference: Int32; mask: UInt32);
begin
z_StencilStrokePathNV_ovr_0(path, reference, mask);
end;
public z_StencilFillPathInstancedNV_adr := GetFuncAdr('glStencilFillPathInstancedNV');
public z_StencilFillPathInstancedNV_ovr_0 := GetFuncOrNil&<procedure(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; fillMode: PathFillMode; mask: UInt32; transformType: PathTransformType; var transformValues: single)>(z_StencilFillPathInstancedNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilFillPathInstancedNV(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; fillMode: PathFillMode; mask: UInt32; transformType: PathTransformType; transformValues: array of single);
begin
z_StencilFillPathInstancedNV_ovr_0(numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilFillPathInstancedNV(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; fillMode: PathFillMode; mask: UInt32; transformType: PathTransformType; var transformValues: single);
begin
z_StencilFillPathInstancedNV_ovr_0(numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues);
end;
public z_StencilFillPathInstancedNV_ovr_2 := GetFuncOrNil&<procedure(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; fillMode: PathFillMode; mask: UInt32; transformType: PathTransformType; transformValues: IntPtr)>(z_StencilFillPathInstancedNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilFillPathInstancedNV(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; fillMode: PathFillMode; mask: UInt32; transformType: PathTransformType; transformValues: IntPtr);
begin
z_StencilFillPathInstancedNV_ovr_2(numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues);
end;
public z_StencilStrokePathInstancedNV_adr := GetFuncAdr('glStencilStrokePathInstancedNV');
public z_StencilStrokePathInstancedNV_ovr_0 := GetFuncOrNil&<procedure(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; reference: Int32; mask: UInt32; transformType: PathTransformType; var transformValues: single)>(z_StencilStrokePathInstancedNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilStrokePathInstancedNV(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; reference: Int32; mask: UInt32; transformType: PathTransformType; transformValues: array of single);
begin
z_StencilStrokePathInstancedNV_ovr_0(numPaths, pathNameType, paths, pathBase, reference, mask, transformType, transformValues[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilStrokePathInstancedNV(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; reference: Int32; mask: UInt32; transformType: PathTransformType; var transformValues: single);
begin
z_StencilStrokePathInstancedNV_ovr_0(numPaths, pathNameType, paths, pathBase, reference, mask, transformType, transformValues);
end;
public z_StencilStrokePathInstancedNV_ovr_2 := GetFuncOrNil&<procedure(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; reference: Int32; mask: UInt32; transformType: PathTransformType; transformValues: IntPtr)>(z_StencilStrokePathInstancedNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilStrokePathInstancedNV(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; reference: Int32; mask: UInt32; transformType: PathTransformType; transformValues: IntPtr);
begin
z_StencilStrokePathInstancedNV_ovr_2(numPaths, pathNameType, paths, pathBase, reference, mask, transformType, transformValues);
end;
public z_PathCoverDepthFuncNV_adr := GetFuncAdr('glPathCoverDepthFuncNV');
public z_PathCoverDepthFuncNV_ovr_0 := GetFuncOrNil&<procedure(func: DepthFunction)>(z_PathCoverDepthFuncNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathCoverDepthFuncNV(func: DepthFunction);
begin
z_PathCoverDepthFuncNV_ovr_0(func);
end;
public z_CoverFillPathNV_adr := GetFuncAdr('glCoverFillPathNV');
public z_CoverFillPathNV_ovr_0 := GetFuncOrNil&<procedure(path: UInt32; coverMode: PathCoverMode)>(z_CoverFillPathNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CoverFillPathNV(path: UInt32; coverMode: PathCoverMode);
begin
z_CoverFillPathNV_ovr_0(path, coverMode);
end;
public z_CoverStrokePathNV_adr := GetFuncAdr('glCoverStrokePathNV');
public z_CoverStrokePathNV_ovr_0 := GetFuncOrNil&<procedure(path: UInt32; coverMode: PathCoverMode)>(z_CoverStrokePathNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CoverStrokePathNV(path: UInt32; coverMode: PathCoverMode);
begin
z_CoverStrokePathNV_ovr_0(path, coverMode);
end;
public z_CoverFillPathInstancedNV_adr := GetFuncAdr('glCoverFillPathInstancedNV');
public z_CoverFillPathInstancedNV_ovr_0 := GetFuncOrNil&<procedure(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; coverMode: PathCoverMode; transformType: PathTransformType; var transformValues: single)>(z_CoverFillPathInstancedNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CoverFillPathInstancedNV(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; coverMode: PathCoverMode; transformType: PathTransformType; transformValues: array of single);
begin
z_CoverFillPathInstancedNV_ovr_0(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CoverFillPathInstancedNV(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; coverMode: PathCoverMode; transformType: PathTransformType; var transformValues: single);
begin
z_CoverFillPathInstancedNV_ovr_0(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
end;
public z_CoverFillPathInstancedNV_ovr_2 := GetFuncOrNil&<procedure(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; coverMode: PathCoverMode; transformType: PathTransformType; transformValues: IntPtr)>(z_CoverFillPathInstancedNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CoverFillPathInstancedNV(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; coverMode: PathCoverMode; transformType: PathTransformType; transformValues: IntPtr);
begin
z_CoverFillPathInstancedNV_ovr_2(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
end;
public z_CoverStrokePathInstancedNV_adr := GetFuncAdr('glCoverStrokePathInstancedNV');
public z_CoverStrokePathInstancedNV_ovr_0 := GetFuncOrNil&<procedure(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; coverMode: PathCoverMode; transformType: PathTransformType; var transformValues: single)>(z_CoverStrokePathInstancedNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CoverStrokePathInstancedNV(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; coverMode: PathCoverMode; transformType: PathTransformType; transformValues: array of single);
begin
z_CoverStrokePathInstancedNV_ovr_0(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CoverStrokePathInstancedNV(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; coverMode: PathCoverMode; transformType: PathTransformType; var transformValues: single);
begin
z_CoverStrokePathInstancedNV_ovr_0(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
end;
public z_CoverStrokePathInstancedNV_ovr_2 := GetFuncOrNil&<procedure(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; coverMode: PathCoverMode; transformType: PathTransformType; transformValues: IntPtr)>(z_CoverStrokePathInstancedNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CoverStrokePathInstancedNV(numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; coverMode: PathCoverMode; transformType: PathTransformType; transformValues: IntPtr);
begin
z_CoverStrokePathInstancedNV_ovr_2(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
end;
public z_GetPathParameterivNV_adr := GetFuncAdr('glGetPathParameterivNV');
public z_GetPathParameterivNV_ovr_0 := GetFuncOrNil&<procedure(path: UInt32; pname: PathParameter; var value: Int32)>(z_GetPathParameterivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathParameterivNV(path: UInt32; pname: PathParameter; value: array of Int32);
begin
z_GetPathParameterivNV_ovr_0(path, pname, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathParameterivNV(path: UInt32; pname: PathParameter; var value: Int32);
begin
z_GetPathParameterivNV_ovr_0(path, pname, value);
end;
public z_GetPathParameterivNV_ovr_2 := GetFuncOrNil&<procedure(path: UInt32; pname: PathParameter; value: IntPtr)>(z_GetPathParameterivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathParameterivNV(path: UInt32; pname: PathParameter; value: IntPtr);
begin
z_GetPathParameterivNV_ovr_2(path, pname, value);
end;
public z_GetPathParameterfvNV_adr := GetFuncAdr('glGetPathParameterfvNV');
public z_GetPathParameterfvNV_ovr_0 := GetFuncOrNil&<procedure(path: UInt32; pname: PathParameter; var value: single)>(z_GetPathParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathParameterfvNV(path: UInt32; pname: PathParameter; value: array of single);
begin
z_GetPathParameterfvNV_ovr_0(path, pname, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathParameterfvNV(path: UInt32; pname: PathParameter; var value: single);
begin
z_GetPathParameterfvNV_ovr_0(path, pname, value);
end;
public z_GetPathParameterfvNV_ovr_2 := GetFuncOrNil&<procedure(path: UInt32; pname: PathParameter; value: IntPtr)>(z_GetPathParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathParameterfvNV(path: UInt32; pname: PathParameter; value: IntPtr);
begin
z_GetPathParameterfvNV_ovr_2(path, pname, value);
end;
public z_GetPathCommandsNV_adr := GetFuncAdr('glGetPathCommandsNV');
public z_GetPathCommandsNV_ovr_0 := GetFuncOrNil&<procedure(path: UInt32; var commands: Byte)>(z_GetPathCommandsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathCommandsNV(path: UInt32; commands: array of Byte);
begin
z_GetPathCommandsNV_ovr_0(path, commands[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathCommandsNV(path: UInt32; var commands: Byte);
begin
z_GetPathCommandsNV_ovr_0(path, commands);
end;
public z_GetPathCommandsNV_ovr_2 := GetFuncOrNil&<procedure(path: UInt32; commands: IntPtr)>(z_GetPathCommandsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathCommandsNV(path: UInt32; commands: IntPtr);
begin
z_GetPathCommandsNV_ovr_2(path, commands);
end;
public z_GetPathCoordsNV_adr := GetFuncAdr('glGetPathCoordsNV');
public z_GetPathCoordsNV_ovr_0 := GetFuncOrNil&<procedure(path: UInt32; var coords: single)>(z_GetPathCoordsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathCoordsNV(path: UInt32; coords: array of single);
begin
z_GetPathCoordsNV_ovr_0(path, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathCoordsNV(path: UInt32; var coords: single);
begin
z_GetPathCoordsNV_ovr_0(path, coords);
end;
public z_GetPathCoordsNV_ovr_2 := GetFuncOrNil&<procedure(path: UInt32; coords: IntPtr)>(z_GetPathCoordsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathCoordsNV(path: UInt32; coords: IntPtr);
begin
z_GetPathCoordsNV_ovr_2(path, coords);
end;
public z_GetPathDashArrayNV_adr := GetFuncAdr('glGetPathDashArrayNV');
public z_GetPathDashArrayNV_ovr_0 := GetFuncOrNil&<procedure(path: UInt32; var dashArray: single)>(z_GetPathDashArrayNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathDashArrayNV(path: UInt32; dashArray: array of single);
begin
z_GetPathDashArrayNV_ovr_0(path, dashArray[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathDashArrayNV(path: UInt32; var dashArray: single);
begin
z_GetPathDashArrayNV_ovr_0(path, dashArray);
end;
public z_GetPathDashArrayNV_ovr_2 := GetFuncOrNil&<procedure(path: UInt32; dashArray: IntPtr)>(z_GetPathDashArrayNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathDashArrayNV(path: UInt32; dashArray: IntPtr);
begin
z_GetPathDashArrayNV_ovr_2(path, dashArray);
end;
public z_GetPathMetricsNV_adr := GetFuncAdr('glGetPathMetricsNV');
public z_GetPathMetricsNV_ovr_0 := GetFuncOrNil&<procedure(metricQueryMask: PathMetricMask; numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; stride: Int32; var metrics: single)>(z_GetPathMetricsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathMetricsNV(metricQueryMask: PathMetricMask; numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; stride: Int32; metrics: array of single);
begin
z_GetPathMetricsNV_ovr_0(metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathMetricsNV(metricQueryMask: PathMetricMask; numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; stride: Int32; var metrics: single);
begin
z_GetPathMetricsNV_ovr_0(metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics);
end;
public z_GetPathMetricsNV_ovr_2 := GetFuncOrNil&<procedure(metricQueryMask: PathMetricMask; numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; stride: Int32; metrics: IntPtr)>(z_GetPathMetricsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathMetricsNV(metricQueryMask: PathMetricMask; numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; stride: Int32; metrics: IntPtr);
begin
z_GetPathMetricsNV_ovr_2(metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics);
end;
public z_GetPathMetricRangeNV_adr := GetFuncAdr('glGetPathMetricRangeNV');
public z_GetPathMetricRangeNV_ovr_0 := GetFuncOrNil&<procedure(metricQueryMask: PathMetricMask; firstPathName: UInt32; numPaths: Int32; stride: Int32; var metrics: single)>(z_GetPathMetricRangeNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathMetricRangeNV(metricQueryMask: PathMetricMask; firstPathName: UInt32; numPaths: Int32; stride: Int32; metrics: array of single);
begin
z_GetPathMetricRangeNV_ovr_0(metricQueryMask, firstPathName, numPaths, stride, metrics[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathMetricRangeNV(metricQueryMask: PathMetricMask; firstPathName: UInt32; numPaths: Int32; stride: Int32; var metrics: single);
begin
z_GetPathMetricRangeNV_ovr_0(metricQueryMask, firstPathName, numPaths, stride, metrics);
end;
public z_GetPathMetricRangeNV_ovr_2 := GetFuncOrNil&<procedure(metricQueryMask: PathMetricMask; firstPathName: UInt32; numPaths: Int32; stride: Int32; metrics: IntPtr)>(z_GetPathMetricRangeNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathMetricRangeNV(metricQueryMask: PathMetricMask; firstPathName: UInt32; numPaths: Int32; stride: Int32; metrics: IntPtr);
begin
z_GetPathMetricRangeNV_ovr_2(metricQueryMask, firstPathName, numPaths, stride, metrics);
end;
public z_GetPathSpacingNV_adr := GetFuncAdr('glGetPathSpacingNV');
public z_GetPathSpacingNV_ovr_0 := GetFuncOrNil&<procedure(_pathListMode: PathListMode; numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; advanceScale: single; kerningScale: single; transformType: PathTransformType; var returnedSpacing: single)>(z_GetPathSpacingNV_adr);
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);
begin
z_GetPathSpacingNV_ovr_0(_pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, returnedSpacing[0]);
end;
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);
begin
z_GetPathSpacingNV_ovr_0(_pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, returnedSpacing);
end;
public z_GetPathSpacingNV_ovr_2 := GetFuncOrNil&<procedure(_pathListMode: PathListMode; numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; advanceScale: single; kerningScale: single; transformType: PathTransformType; returnedSpacing: IntPtr)>(z_GetPathSpacingNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathSpacingNV(_pathListMode: PathListMode; numPaths: Int32; pathNameType: PathElementType; paths: IntPtr; pathBase: UInt32; advanceScale: single; kerningScale: single; transformType: PathTransformType; returnedSpacing: IntPtr);
begin
z_GetPathSpacingNV_ovr_2(_pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, returnedSpacing);
end;
public z_IsPointInFillPathNV_adr := GetFuncAdr('glIsPointInFillPathNV');
public z_IsPointInFillPathNV_ovr_0 := GetFuncOrNil&<function(path: UInt32; mask: UInt32; x: single; y: single): boolean>(z_IsPointInFillPathNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsPointInFillPathNV(path: UInt32; mask: UInt32; x: single; y: single): boolean;
begin
Result := z_IsPointInFillPathNV_ovr_0(path, mask, x, y);
end;
public z_IsPointInStrokePathNV_adr := GetFuncAdr('glIsPointInStrokePathNV');
public z_IsPointInStrokePathNV_ovr_0 := GetFuncOrNil&<function(path: UInt32; x: single; y: single): boolean>(z_IsPointInStrokePathNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsPointInStrokePathNV(path: UInt32; x: single; y: single): boolean;
begin
Result := z_IsPointInStrokePathNV_ovr_0(path, x, y);
end;
public z_GetPathLengthNV_adr := GetFuncAdr('glGetPathLengthNV');
public z_GetPathLengthNV_ovr_0 := GetFuncOrNil&<function(path: UInt32; startSegment: Int32; numSegments: Int32): single>(z_GetPathLengthNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetPathLengthNV(path: UInt32; startSegment: Int32; numSegments: Int32): single;
begin
Result := z_GetPathLengthNV_ovr_0(path, startSegment, numSegments);
end;
public z_PointAlongPathNV_adr := GetFuncAdr('glPointAlongPathNV');
public z_PointAlongPathNV_ovr_0 := GetFuncOrNil&<function(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; var y: single; var tangentX: single; var tangentY: single): boolean>(z_PointAlongPathNV_adr);
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;
begin
Result := z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x[0], y[0], tangentX[0], tangentY[0]);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x[0], y[0], tangentX[0], tangentY);
end;
public z_PointAlongPathNV_ovr_2 := GetFuncOrNil&<function(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; var y: single; var tangentX: single; tangentY: IntPtr): boolean>(z_PointAlongPathNV_adr);
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;
begin
Result := z_PointAlongPathNV_ovr_2(path, startSegment, numSegments, distance, x[0], y[0], tangentX[0], tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x[0], y[0], tangentX, tangentY[0]);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x[0], y[0], tangentX, tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_2(path, startSegment, numSegments, distance, x[0], y[0], tangentX, tangentY);
end;
public z_PointAlongPathNV_ovr_6 := GetFuncOrNil&<function(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; var y: single; tangentX: IntPtr; var tangentY: single): boolean>(z_PointAlongPathNV_adr);
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;
begin
Result := z_PointAlongPathNV_ovr_6(path, startSegment, numSegments, distance, x[0], y[0], tangentX, tangentY[0]);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_6(path, startSegment, numSegments, distance, x[0], y[0], tangentX, tangentY);
end;
public z_PointAlongPathNV_ovr_8 := GetFuncOrNil&<function(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; var y: single; tangentX: IntPtr; tangentY: IntPtr): boolean>(z_PointAlongPathNV_adr);
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;
begin
Result := z_PointAlongPathNV_ovr_8(path, startSegment, numSegments, distance, x[0], y[0], tangentX, tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x[0], y, tangentX[0], tangentY[0]);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x[0], y, tangentX[0], tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_2(path, startSegment, numSegments, distance, x[0], y, tangentX[0], tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x[0], y, tangentX, tangentY[0]);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x[0], y, tangentX, tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_2(path, startSegment, numSegments, distance, x[0], y, tangentX, tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_6(path, startSegment, numSegments, distance, x[0], y, tangentX, tangentY[0]);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_6(path, startSegment, numSegments, distance, x[0], y, tangentX, tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_8(path, startSegment, numSegments, distance, x[0], y, tangentX, tangentY);
end;
public z_PointAlongPathNV_ovr_18 := GetFuncOrNil&<function(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; var tangentX: single; var tangentY: single): boolean>(z_PointAlongPathNV_adr);
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;
begin
Result := z_PointAlongPathNV_ovr_18(path, startSegment, numSegments, distance, x[0], y, tangentX[0], tangentY[0]);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_18(path, startSegment, numSegments, distance, x[0], y, tangentX[0], tangentY);
end;
public z_PointAlongPathNV_ovr_20 := GetFuncOrNil&<function(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; var tangentX: single; tangentY: IntPtr): boolean>(z_PointAlongPathNV_adr);
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;
begin
Result := z_PointAlongPathNV_ovr_20(path, startSegment, numSegments, distance, x[0], y, tangentX[0], tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_18(path, startSegment, numSegments, distance, x[0], y, tangentX, tangentY[0]);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_18(path, startSegment, numSegments, distance, x[0], y, tangentX, tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_20(path, startSegment, numSegments, distance, x[0], y, tangentX, tangentY);
end;
public z_PointAlongPathNV_ovr_24 := GetFuncOrNil&<function(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean>(z_PointAlongPathNV_adr);
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;
begin
Result := z_PointAlongPathNV_ovr_24(path, startSegment, numSegments, distance, x[0], y, tangentX, tangentY[0]);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_24(path, startSegment, numSegments, distance, x[0], y, tangentX, tangentY);
end;
public z_PointAlongPathNV_ovr_26 := GetFuncOrNil&<function(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean>(z_PointAlongPathNV_adr);
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;
begin
Result := z_PointAlongPathNV_ovr_26(path, startSegment, numSegments, distance, x[0], y, tangentX, tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x, y[0], tangentX[0], tangentY[0]);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x, y[0], tangentX[0], tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_2(path, startSegment, numSegments, distance, x, y[0], tangentX[0], tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x, y[0], tangentX, tangentY[0]);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x, y[0], tangentX, tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_2(path, startSegment, numSegments, distance, x, y[0], tangentX, tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_6(path, startSegment, numSegments, distance, x, y[0], tangentX, tangentY[0]);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_6(path, startSegment, numSegments, distance, x, y[0], tangentX, tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_8(path, startSegment, numSegments, distance, x, y[0], tangentX, tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x, y, tangentX[0], tangentY[0]);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x, y, tangentX[0], tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_2(path, startSegment, numSegments, distance, x, y, tangentX[0], tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x, y, tangentX, tangentY[0]);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_0(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_2(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_6(path, startSegment, numSegments, distance, x, y, tangentX, tangentY[0]);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_6(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_8(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_18(path, startSegment, numSegments, distance, x, y, tangentX[0], tangentY[0]);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_18(path, startSegment, numSegments, distance, x, y, tangentX[0], tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_20(path, startSegment, numSegments, distance, x, y, tangentX[0], tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_18(path, startSegment, numSegments, distance, x, y, tangentX, tangentY[0]);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_18(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_20(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_24(path, startSegment, numSegments, distance, x, y, tangentX, tangentY[0]);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_24(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; var x: single; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean;
begin
Result := z_PointAlongPathNV_ovr_26(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
end;
public z_PointAlongPathNV_ovr_54 := GetFuncOrNil&<function(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; var tangentX: single; var tangentY: single): boolean>(z_PointAlongPathNV_adr);
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;
begin
Result := z_PointAlongPathNV_ovr_54(path, startSegment, numSegments, distance, x, y[0], tangentX[0], tangentY[0]);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_54(path, startSegment, numSegments, distance, x, y[0], tangentX[0], tangentY);
end;
public z_PointAlongPathNV_ovr_56 := GetFuncOrNil&<function(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; var tangentX: single; tangentY: IntPtr): boolean>(z_PointAlongPathNV_adr);
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;
begin
Result := z_PointAlongPathNV_ovr_56(path, startSegment, numSegments, distance, x, y[0], tangentX[0], tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_54(path, startSegment, numSegments, distance, x, y[0], tangentX, tangentY[0]);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_54(path, startSegment, numSegments, distance, x, y[0], tangentX, tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_56(path, startSegment, numSegments, distance, x, y[0], tangentX, tangentY);
end;
public z_PointAlongPathNV_ovr_60 := GetFuncOrNil&<function(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; var tangentY: single): boolean>(z_PointAlongPathNV_adr);
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;
begin
Result := z_PointAlongPathNV_ovr_60(path, startSegment, numSegments, distance, x, y[0], tangentX, tangentY[0]);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_60(path, startSegment, numSegments, distance, x, y[0], tangentX, tangentY);
end;
public z_PointAlongPathNV_ovr_62 := GetFuncOrNil&<function(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; tangentY: IntPtr): boolean>(z_PointAlongPathNV_adr);
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;
begin
Result := z_PointAlongPathNV_ovr_62(path, startSegment, numSegments, distance, x, y[0], tangentX, tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_54(path, startSegment, numSegments, distance, x, y, tangentX[0], tangentY[0]);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_54(path, startSegment, numSegments, distance, x, y, tangentX[0], tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_56(path, startSegment, numSegments, distance, x, y, tangentX[0], tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_54(path, startSegment, numSegments, distance, x, y, tangentX, tangentY[0]);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_54(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_56(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_60(path, startSegment, numSegments, distance, x, y, tangentX, tangentY[0]);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_60(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; var y: single; tangentX: IntPtr; tangentY: IntPtr): boolean;
begin
Result := z_PointAlongPathNV_ovr_62(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
end;
public z_PointAlongPathNV_ovr_72 := GetFuncOrNil&<function(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; var tangentY: single): boolean>(z_PointAlongPathNV_adr);
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;
begin
Result := z_PointAlongPathNV_ovr_72(path, startSegment, numSegments, distance, x, y, tangentX[0], tangentY[0]);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_72(path, startSegment, numSegments, distance, x, y, tangentX[0], tangentY);
end;
public z_PointAlongPathNV_ovr_74 := GetFuncOrNil&<function(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; tangentY: IntPtr): boolean>(z_PointAlongPathNV_adr);
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;
begin
Result := z_PointAlongPathNV_ovr_74(path, startSegment, numSegments, distance, x, y, tangentX[0], tangentY);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_72(path, startSegment, numSegments, distance, x, y, tangentX, tangentY[0]);
end;
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;
begin
Result := z_PointAlongPathNV_ovr_72(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; var tangentX: single; tangentY: IntPtr): boolean;
begin
Result := z_PointAlongPathNV_ovr_74(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
end;
public z_PointAlongPathNV_ovr_78 := GetFuncOrNil&<function(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean>(z_PointAlongPathNV_adr);
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;
begin
Result := z_PointAlongPathNV_ovr_78(path, startSegment, numSegments, distance, x, y, tangentX, tangentY[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; var tangentY: single): boolean;
begin
Result := z_PointAlongPathNV_ovr_78(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
end;
public z_PointAlongPathNV_ovr_80 := GetFuncOrNil&<function(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean>(z_PointAlongPathNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PointAlongPathNV(path: UInt32; startSegment: Int32; numSegments: Int32; distance: single; x: IntPtr; y: IntPtr; tangentX: IntPtr; tangentY: IntPtr): boolean;
begin
Result := z_PointAlongPathNV_ovr_80(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
end;
public z_MatrixLoad3x2fNV_adr := GetFuncAdr('glMatrixLoad3x2fNV');
public z_MatrixLoad3x2fNV_ovr_0 := GetFuncOrNil&<procedure(matrixMode: DummyEnum; var m: single)>(z_MatrixLoad3x2fNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoad3x2fNV(matrixMode: DummyEnum; m: array of single);
begin
z_MatrixLoad3x2fNV_ovr_0(matrixMode, m[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoad3x2fNV(matrixMode: DummyEnum; var m: single);
begin
z_MatrixLoad3x2fNV_ovr_0(matrixMode, m);
end;
public z_MatrixLoad3x2fNV_ovr_2 := GetFuncOrNil&<procedure(matrixMode: DummyEnum; m: IntPtr)>(z_MatrixLoad3x2fNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoad3x2fNV(matrixMode: DummyEnum; m: IntPtr);
begin
z_MatrixLoad3x2fNV_ovr_2(matrixMode, m);
end;
public z_MatrixLoad3x3fNV_adr := GetFuncAdr('glMatrixLoad3x3fNV');
public z_MatrixLoad3x3fNV_ovr_0 := GetFuncOrNil&<procedure(matrixMode: DummyEnum; var m: single)>(z_MatrixLoad3x3fNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoad3x3fNV(matrixMode: DummyEnum; m: array of single);
begin
z_MatrixLoad3x3fNV_ovr_0(matrixMode, m[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoad3x3fNV(matrixMode: DummyEnum; var m: single);
begin
z_MatrixLoad3x3fNV_ovr_0(matrixMode, m);
end;
public z_MatrixLoad3x3fNV_ovr_2 := GetFuncOrNil&<procedure(matrixMode: DummyEnum; m: IntPtr)>(z_MatrixLoad3x3fNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoad3x3fNV(matrixMode: DummyEnum; m: IntPtr);
begin
z_MatrixLoad3x3fNV_ovr_2(matrixMode, m);
end;
public z_MatrixLoadTranspose3x3fNV_adr := GetFuncAdr('glMatrixLoadTranspose3x3fNV');
public z_MatrixLoadTranspose3x3fNV_ovr_0 := GetFuncOrNil&<procedure(matrixMode: DummyEnum; var m: single)>(z_MatrixLoadTranspose3x3fNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadTranspose3x3fNV(matrixMode: DummyEnum; m: array of single);
begin
z_MatrixLoadTranspose3x3fNV_ovr_0(matrixMode, m[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadTranspose3x3fNV(matrixMode: DummyEnum; var m: single);
begin
z_MatrixLoadTranspose3x3fNV_ovr_0(matrixMode, m);
end;
public z_MatrixLoadTranspose3x3fNV_ovr_2 := GetFuncOrNil&<procedure(matrixMode: DummyEnum; m: IntPtr)>(z_MatrixLoadTranspose3x3fNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixLoadTranspose3x3fNV(matrixMode: DummyEnum; m: IntPtr);
begin
z_MatrixLoadTranspose3x3fNV_ovr_2(matrixMode, m);
end;
public z_MatrixMult3x2fNV_adr := GetFuncAdr('glMatrixMult3x2fNV');
public z_MatrixMult3x2fNV_ovr_0 := GetFuncOrNil&<procedure(matrixMode: DummyEnum; var m: single)>(z_MatrixMult3x2fNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMult3x2fNV(matrixMode: DummyEnum; m: array of single);
begin
z_MatrixMult3x2fNV_ovr_0(matrixMode, m[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMult3x2fNV(matrixMode: DummyEnum; var m: single);
begin
z_MatrixMult3x2fNV_ovr_0(matrixMode, m);
end;
public z_MatrixMult3x2fNV_ovr_2 := GetFuncOrNil&<procedure(matrixMode: DummyEnum; m: IntPtr)>(z_MatrixMult3x2fNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMult3x2fNV(matrixMode: DummyEnum; m: IntPtr);
begin
z_MatrixMult3x2fNV_ovr_2(matrixMode, m);
end;
public z_MatrixMult3x3fNV_adr := GetFuncAdr('glMatrixMult3x3fNV');
public z_MatrixMult3x3fNV_ovr_0 := GetFuncOrNil&<procedure(matrixMode: DummyEnum; var m: single)>(z_MatrixMult3x3fNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMult3x3fNV(matrixMode: DummyEnum; m: array of single);
begin
z_MatrixMult3x3fNV_ovr_0(matrixMode, m[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMult3x3fNV(matrixMode: DummyEnum; var m: single);
begin
z_MatrixMult3x3fNV_ovr_0(matrixMode, m);
end;
public z_MatrixMult3x3fNV_ovr_2 := GetFuncOrNil&<procedure(matrixMode: DummyEnum; m: IntPtr)>(z_MatrixMult3x3fNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMult3x3fNV(matrixMode: DummyEnum; m: IntPtr);
begin
z_MatrixMult3x3fNV_ovr_2(matrixMode, m);
end;
public z_MatrixMultTranspose3x3fNV_adr := GetFuncAdr('glMatrixMultTranspose3x3fNV');
public z_MatrixMultTranspose3x3fNV_ovr_0 := GetFuncOrNil&<procedure(matrixMode: DummyEnum; var m: single)>(z_MatrixMultTranspose3x3fNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultTranspose3x3fNV(matrixMode: DummyEnum; m: array of single);
begin
z_MatrixMultTranspose3x3fNV_ovr_0(matrixMode, m[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultTranspose3x3fNV(matrixMode: DummyEnum; var m: single);
begin
z_MatrixMultTranspose3x3fNV_ovr_0(matrixMode, m);
end;
public z_MatrixMultTranspose3x3fNV_ovr_2 := GetFuncOrNil&<procedure(matrixMode: DummyEnum; m: IntPtr)>(z_MatrixMultTranspose3x3fNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MatrixMultTranspose3x3fNV(matrixMode: DummyEnum; m: IntPtr);
begin
z_MatrixMultTranspose3x3fNV_ovr_2(matrixMode, m);
end;
public z_StencilThenCoverFillPathNV_adr := GetFuncAdr('glStencilThenCoverFillPathNV');
public z_StencilThenCoverFillPathNV_ovr_0 := GetFuncOrNil&<procedure(path: UInt32; fillMode: DummyEnum; mask: UInt32; coverMode: DummyEnum)>(z_StencilThenCoverFillPathNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilThenCoverFillPathNV(path: UInt32; fillMode: DummyEnum; mask: UInt32; coverMode: DummyEnum);
begin
z_StencilThenCoverFillPathNV_ovr_0(path, fillMode, mask, coverMode);
end;
public z_StencilThenCoverStrokePathNV_adr := GetFuncAdr('glStencilThenCoverStrokePathNV');
public z_StencilThenCoverStrokePathNV_ovr_0 := GetFuncOrNil&<procedure(path: UInt32; reference: Int32; mask: UInt32; coverMode: DummyEnum)>(z_StencilThenCoverStrokePathNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilThenCoverStrokePathNV(path: UInt32; reference: Int32; mask: UInt32; coverMode: DummyEnum);
begin
z_StencilThenCoverStrokePathNV_ovr_0(path, reference, mask, coverMode);
end;
public z_StencilThenCoverFillPathInstancedNV_adr := GetFuncAdr('glStencilThenCoverFillPathInstancedNV');
public z_StencilThenCoverFillPathInstancedNV_ovr_0 := GetFuncOrNil&<procedure(numPaths: Int32; pathNameType: DummyEnum; paths: IntPtr; pathBase: UInt32; fillMode: DummyEnum; mask: UInt32; coverMode: DummyEnum; transformType: DummyEnum; var transformValues: single)>(z_StencilThenCoverFillPathInstancedNV_adr);
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);
begin
z_StencilThenCoverFillPathInstancedNV_ovr_0(numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode, transformType, transformValues[0]);
end;
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);
begin
z_StencilThenCoverFillPathInstancedNV_ovr_0(numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode, transformType, transformValues);
end;
public z_StencilThenCoverFillPathInstancedNV_ovr_2 := GetFuncOrNil&<procedure(numPaths: Int32; pathNameType: DummyEnum; paths: IntPtr; pathBase: UInt32; fillMode: DummyEnum; mask: UInt32; coverMode: DummyEnum; transformType: DummyEnum; transformValues: IntPtr)>(z_StencilThenCoverFillPathInstancedNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilThenCoverFillPathInstancedNV(numPaths: Int32; pathNameType: DummyEnum; paths: IntPtr; pathBase: UInt32; fillMode: DummyEnum; mask: UInt32; coverMode: DummyEnum; transformType: DummyEnum; transformValues: IntPtr);
begin
z_StencilThenCoverFillPathInstancedNV_ovr_2(numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode, transformType, transformValues);
end;
public z_StencilThenCoverStrokePathInstancedNV_adr := GetFuncAdr('glStencilThenCoverStrokePathInstancedNV');
public z_StencilThenCoverStrokePathInstancedNV_ovr_0 := GetFuncOrNil&<procedure(numPaths: Int32; pathNameType: DummyEnum; paths: IntPtr; pathBase: UInt32; reference: Int32; mask: UInt32; coverMode: DummyEnum; transformType: DummyEnum; var transformValues: single)>(z_StencilThenCoverStrokePathInstancedNV_adr);
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);
begin
z_StencilThenCoverStrokePathInstancedNV_ovr_0(numPaths, pathNameType, paths, pathBase, reference, mask, coverMode, transformType, transformValues[0]);
end;
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);
begin
z_StencilThenCoverStrokePathInstancedNV_ovr_0(numPaths, pathNameType, paths, pathBase, reference, mask, coverMode, transformType, transformValues);
end;
public z_StencilThenCoverStrokePathInstancedNV_ovr_2 := GetFuncOrNil&<procedure(numPaths: Int32; pathNameType: DummyEnum; paths: IntPtr; pathBase: UInt32; reference: Int32; mask: UInt32; coverMode: DummyEnum; transformType: DummyEnum; transformValues: IntPtr)>(z_StencilThenCoverStrokePathInstancedNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StencilThenCoverStrokePathInstancedNV(numPaths: Int32; pathNameType: DummyEnum; paths: IntPtr; pathBase: UInt32; reference: Int32; mask: UInt32; coverMode: DummyEnum; transformType: DummyEnum; transformValues: IntPtr);
begin
z_StencilThenCoverStrokePathInstancedNV_ovr_2(numPaths, pathNameType, paths, pathBase, reference, mask, coverMode, transformType, transformValues);
end;
public z_PathGlyphIndexRangeNV_adr := GetFuncAdr('glPathGlyphIndexRangeNV');
public z_PathGlyphIndexRangeNV_ovr_0 := GetFuncOrNil&<function(fontTarget: DummyEnum; fontName: IntPtr; fontStyle: PathFontStyle; pathParameterTemplate: UInt32; emScale: single; baseAndCount: UInt32): DummyEnum>(z_PathGlyphIndexRangeNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PathGlyphIndexRangeNV(fontTarget: DummyEnum; fontName: IntPtr; fontStyle: PathFontStyle; pathParameterTemplate: UInt32; emScale: single; baseAndCount: UInt32): DummyEnum;
begin
Result := z_PathGlyphIndexRangeNV_ovr_0(fontTarget, fontName, fontStyle, pathParameterTemplate, emScale, baseAndCount);
end;
public z_PathGlyphIndexArrayNV_adr := GetFuncAdr('glPathGlyphIndexArrayNV');
public z_PathGlyphIndexArrayNV_ovr_0 := GetFuncOrNil&<function(firstPathName: UInt32; fontTarget: DummyEnum; fontName: IntPtr; fontStyle: PathFontStyle; firstGlyphIndex: UInt32; numGlyphs: Int32; pathParameterTemplate: UInt32; emScale: single): DummyEnum>(z_PathGlyphIndexArrayNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PathGlyphIndexArrayNV(firstPathName: UInt32; fontTarget: DummyEnum; fontName: IntPtr; fontStyle: PathFontStyle; firstGlyphIndex: UInt32; numGlyphs: Int32; pathParameterTemplate: UInt32; emScale: single): DummyEnum;
begin
Result := z_PathGlyphIndexArrayNV_ovr_0(firstPathName, fontTarget, fontName, fontStyle, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale);
end;
public z_PathMemoryGlyphIndexArrayNV_adr := GetFuncAdr('glPathMemoryGlyphIndexArrayNV');
public z_PathMemoryGlyphIndexArrayNV_ovr_0 := GetFuncOrNil&<function(firstPathName: UInt32; fontTarget: DummyEnum; fontSize: IntPtr; fontData: IntPtr; faceIndex: Int32; firstGlyphIndex: UInt32; numGlyphs: Int32; pathParameterTemplate: UInt32; emScale: single): DummyEnum>(z_PathMemoryGlyphIndexArrayNV_adr);
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;
begin
Result := z_PathMemoryGlyphIndexArrayNV_ovr_0(firstPathName, fontTarget, fontSize, fontData, faceIndex, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale);
end;
public z_ProgramPathFragmentInputGenNV_adr := GetFuncAdr('glProgramPathFragmentInputGenNV');
public z_ProgramPathFragmentInputGenNV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; genMode: DummyEnum; components: Int32; var coeffs: single)>(z_ProgramPathFragmentInputGenNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramPathFragmentInputGenNV(&program: UInt32; location: Int32; genMode: DummyEnum; components: Int32; coeffs: array of single);
begin
z_ProgramPathFragmentInputGenNV_ovr_0(&program, location, genMode, components, coeffs[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramPathFragmentInputGenNV(&program: UInt32; location: Int32; genMode: DummyEnum; components: Int32; var coeffs: single);
begin
z_ProgramPathFragmentInputGenNV_ovr_0(&program, location, genMode, components, coeffs);
end;
public z_ProgramPathFragmentInputGenNV_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; genMode: DummyEnum; components: Int32; coeffs: IntPtr)>(z_ProgramPathFragmentInputGenNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramPathFragmentInputGenNV(&program: UInt32; location: Int32; genMode: DummyEnum; components: Int32; coeffs: IntPtr);
begin
z_ProgramPathFragmentInputGenNV_ovr_2(&program, location, genMode, components, coeffs);
end;
public z_GetProgramResourcefvNV_adr := GetFuncAdr('glGetProgramResourcefvNV');
public z_GetProgramResourcefvNV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: DummyEnum; count: Int32; var length: Int32; var ¶ms: single)>(z_GetProgramResourcefvNV_adr);
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);
begin
z_GetProgramResourcefvNV_ovr_0(&program, _programInterface, index, propCount, props[0], count, length[0], ¶ms[0]);
end;
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);
begin
z_GetProgramResourcefvNV_ovr_0(&program, _programInterface, index, propCount, props[0], count, length[0], ¶ms);
end;
public z_GetProgramResourcefvNV_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: DummyEnum; count: Int32; var length: Int32; ¶ms: IntPtr)>(z_GetProgramResourcefvNV_adr);
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);
begin
z_GetProgramResourcefvNV_ovr_2(&program, _programInterface, index, propCount, props[0], count, length[0], ¶ms);
end;
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);
begin
z_GetProgramResourcefvNV_ovr_0(&program, _programInterface, index, propCount, props[0], count, length, ¶ms[0]);
end;
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);
begin
z_GetProgramResourcefvNV_ovr_0(&program, _programInterface, index, propCount, props[0], count, length, ¶ms);
end;
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);
begin
z_GetProgramResourcefvNV_ovr_2(&program, _programInterface, index, propCount, props[0], count, length, ¶ms);
end;
public z_GetProgramResourcefvNV_ovr_6 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: DummyEnum; count: Int32; length: IntPtr; var ¶ms: single)>(z_GetProgramResourcefvNV_adr);
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);
begin
z_GetProgramResourcefvNV_ovr_6(&program, _programInterface, index, propCount, props[0], count, length, ¶ms[0]);
end;
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);
begin
z_GetProgramResourcefvNV_ovr_6(&program, _programInterface, index, propCount, props[0], count, length, ¶ms);
end;
public z_GetProgramResourcefvNV_ovr_8 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: DummyEnum; count: Int32; length: IntPtr; ¶ms: IntPtr)>(z_GetProgramResourcefvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: array of DummyEnum; count: Int32; length: IntPtr; ¶ms: IntPtr);
begin
z_GetProgramResourcefvNV_ovr_8(&program, _programInterface, index, propCount, props[0], count, length, ¶ms);
end;
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);
begin
z_GetProgramResourcefvNV_ovr_0(&program, _programInterface, index, propCount, props, count, length[0], ¶ms[0]);
end;
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);
begin
z_GetProgramResourcefvNV_ovr_0(&program, _programInterface, index, propCount, props, count, length[0], ¶ms);
end;
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);
begin
z_GetProgramResourcefvNV_ovr_2(&program, _programInterface, index, propCount, props, count, length[0], ¶ms);
end;
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);
begin
z_GetProgramResourcefvNV_ovr_0(&program, _programInterface, index, propCount, props, count, length, ¶ms[0]);
end;
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);
begin
z_GetProgramResourcefvNV_ovr_0(&program, _programInterface, index, propCount, props, count, length, ¶ms);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: DummyEnum; count: Int32; var length: Int32; ¶ms: IntPtr);
begin
z_GetProgramResourcefvNV_ovr_2(&program, _programInterface, index, propCount, props, count, length, ¶ms);
end;
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);
begin
z_GetProgramResourcefvNV_ovr_6(&program, _programInterface, index, propCount, props, count, length, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: DummyEnum; count: Int32; length: IntPtr; var ¶ms: single);
begin
z_GetProgramResourcefvNV_ovr_6(&program, _programInterface, index, propCount, props, count, length, ¶ms);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; var props: DummyEnum; count: Int32; length: IntPtr; ¶ms: IntPtr);
begin
z_GetProgramResourcefvNV_ovr_8(&program, _programInterface, index, propCount, props, count, length, ¶ms);
end;
public z_GetProgramResourcefvNV_ovr_18 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; var ¶ms: single)>(z_GetProgramResourcefvNV_adr);
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);
begin
z_GetProgramResourcefvNV_ovr_18(&program, _programInterface, index, propCount, props, count, length[0], ¶ms[0]);
end;
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);
begin
z_GetProgramResourcefvNV_ovr_18(&program, _programInterface, index, propCount, props, count, length[0], ¶ms);
end;
public z_GetProgramResourcefvNV_ovr_20 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; ¶ms: IntPtr)>(z_GetProgramResourcefvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: array of Int32; ¶ms: IntPtr);
begin
z_GetProgramResourcefvNV_ovr_20(&program, _programInterface, index, propCount, props, count, length[0], ¶ms);
end;
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);
begin
z_GetProgramResourcefvNV_ovr_18(&program, _programInterface, index, propCount, props, count, length, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; var ¶ms: single);
begin
z_GetProgramResourcefvNV_ovr_18(&program, _programInterface, index, propCount, props, count, length, ¶ms);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; var length: Int32; ¶ms: IntPtr);
begin
z_GetProgramResourcefvNV_ovr_20(&program, _programInterface, index, propCount, props, count, length, ¶ms);
end;
public z_GetProgramResourcefvNV_ovr_24 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; var ¶ms: single)>(z_GetProgramResourcefvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: array of single);
begin
z_GetProgramResourcefvNV_ovr_24(&program, _programInterface, index, propCount, props, count, length, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; var ¶ms: single);
begin
z_GetProgramResourcefvNV_ovr_24(&program, _programInterface, index, propCount, props, count, length, ¶ms);
end;
public z_GetProgramResourcefvNV_ovr_26 := GetFuncOrNil&<procedure(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr)>(z_GetProgramResourcefvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramResourcefvNV(&program: UInt32; _programInterface: ProgramInterface; index: UInt32; propCount: Int32; props: IntPtr; count: Int32; length: IntPtr; ¶ms: IntPtr);
begin
z_GetProgramResourcefvNV_ovr_26(&program, _programInterface, index, propCount, props, count, length, ¶ms);
end;
public z_PathColorGenNV_adr := GetFuncAdr('glPathColorGenNV');
public z_PathColorGenNV_ovr_0 := GetFuncOrNil&<procedure(color: PathColor; genMode: PathGenMode; colorFormat: PathColorFormat; var coeffs: single)>(z_PathColorGenNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathColorGenNV(color: PathColor; genMode: PathGenMode; colorFormat: PathColorFormat; coeffs: array of single);
begin
z_PathColorGenNV_ovr_0(color, genMode, colorFormat, coeffs[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathColorGenNV(color: PathColor; genMode: PathGenMode; colorFormat: PathColorFormat; var coeffs: single);
begin
z_PathColorGenNV_ovr_0(color, genMode, colorFormat, coeffs);
end;
public z_PathColorGenNV_ovr_2 := GetFuncOrNil&<procedure(color: PathColor; genMode: PathGenMode; colorFormat: PathColorFormat; coeffs: IntPtr)>(z_PathColorGenNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathColorGenNV(color: PathColor; genMode: PathGenMode; colorFormat: PathColorFormat; coeffs: IntPtr);
begin
z_PathColorGenNV_ovr_2(color, genMode, colorFormat, coeffs);
end;
public z_PathTexGenNV_adr := GetFuncAdr('glPathTexGenNV');
public z_PathTexGenNV_ovr_0 := GetFuncOrNil&<procedure(texCoordSet: PathColor; genMode: PathGenMode; components: Int32; var coeffs: single)>(z_PathTexGenNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathTexGenNV(texCoordSet: PathColor; genMode: PathGenMode; components: Int32; coeffs: array of single);
begin
z_PathTexGenNV_ovr_0(texCoordSet, genMode, components, coeffs[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathTexGenNV(texCoordSet: PathColor; genMode: PathGenMode; components: Int32; var coeffs: single);
begin
z_PathTexGenNV_ovr_0(texCoordSet, genMode, components, coeffs);
end;
public z_PathTexGenNV_ovr_2 := GetFuncOrNil&<procedure(texCoordSet: PathColor; genMode: PathGenMode; components: Int32; coeffs: IntPtr)>(z_PathTexGenNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathTexGenNV(texCoordSet: PathColor; genMode: PathGenMode; components: Int32; coeffs: IntPtr);
begin
z_PathTexGenNV_ovr_2(texCoordSet, genMode, components, coeffs);
end;
public z_PathFogGenNV_adr := GetFuncAdr('glPathFogGenNV');
public z_PathFogGenNV_ovr_0 := GetFuncOrNil&<procedure(genMode: PathGenMode)>(z_PathFogGenNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PathFogGenNV(genMode: PathGenMode);
begin
z_PathFogGenNV_ovr_0(genMode);
end;
public z_GetPathColorGenivNV_adr := GetFuncAdr('glGetPathColorGenivNV');
public z_GetPathColorGenivNV_ovr_0 := GetFuncOrNil&<procedure(color: PathColor; pname: PathGenMode; var value: Int32)>(z_GetPathColorGenivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathColorGenivNV(color: PathColor; pname: PathGenMode; value: array of Int32);
begin
z_GetPathColorGenivNV_ovr_0(color, pname, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathColorGenivNV(color: PathColor; pname: PathGenMode; var value: Int32);
begin
z_GetPathColorGenivNV_ovr_0(color, pname, value);
end;
public z_GetPathColorGenivNV_ovr_2 := GetFuncOrNil&<procedure(color: PathColor; pname: PathGenMode; value: IntPtr)>(z_GetPathColorGenivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathColorGenivNV(color: PathColor; pname: PathGenMode; value: IntPtr);
begin
z_GetPathColorGenivNV_ovr_2(color, pname, value);
end;
public z_GetPathColorGenfvNV_adr := GetFuncAdr('glGetPathColorGenfvNV');
public z_GetPathColorGenfvNV_ovr_0 := GetFuncOrNil&<procedure(color: PathColor; pname: PathGenMode; var value: single)>(z_GetPathColorGenfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathColorGenfvNV(color: PathColor; pname: PathGenMode; value: array of single);
begin
z_GetPathColorGenfvNV_ovr_0(color, pname, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathColorGenfvNV(color: PathColor; pname: PathGenMode; var value: single);
begin
z_GetPathColorGenfvNV_ovr_0(color, pname, value);
end;
public z_GetPathColorGenfvNV_ovr_2 := GetFuncOrNil&<procedure(color: PathColor; pname: PathGenMode; value: IntPtr)>(z_GetPathColorGenfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathColorGenfvNV(color: PathColor; pname: PathGenMode; value: IntPtr);
begin
z_GetPathColorGenfvNV_ovr_2(color, pname, value);
end;
public z_GetPathTexGenivNV_adr := GetFuncAdr('glGetPathTexGenivNV');
public z_GetPathTexGenivNV_ovr_0 := GetFuncOrNil&<procedure(texCoordSet: TextureUnit; pname: PathGenMode; var value: Int32)>(z_GetPathTexGenivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathTexGenivNV(texCoordSet: TextureUnit; pname: PathGenMode; value: array of Int32);
begin
z_GetPathTexGenivNV_ovr_0(texCoordSet, pname, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathTexGenivNV(texCoordSet: TextureUnit; pname: PathGenMode; var value: Int32);
begin
z_GetPathTexGenivNV_ovr_0(texCoordSet, pname, value);
end;
public z_GetPathTexGenivNV_ovr_2 := GetFuncOrNil&<procedure(texCoordSet: TextureUnit; pname: PathGenMode; value: IntPtr)>(z_GetPathTexGenivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathTexGenivNV(texCoordSet: TextureUnit; pname: PathGenMode; value: IntPtr);
begin
z_GetPathTexGenivNV_ovr_2(texCoordSet, pname, value);
end;
public z_GetPathTexGenfvNV_adr := GetFuncAdr('glGetPathTexGenfvNV');
public z_GetPathTexGenfvNV_ovr_0 := GetFuncOrNil&<procedure(texCoordSet: TextureUnit; pname: PathGenMode; var value: single)>(z_GetPathTexGenfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathTexGenfvNV(texCoordSet: TextureUnit; pname: PathGenMode; value: array of single);
begin
z_GetPathTexGenfvNV_ovr_0(texCoordSet, pname, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathTexGenfvNV(texCoordSet: TextureUnit; pname: PathGenMode; var value: single);
begin
z_GetPathTexGenfvNV_ovr_0(texCoordSet, pname, value);
end;
public z_GetPathTexGenfvNV_ovr_2 := GetFuncOrNil&<procedure(texCoordSet: TextureUnit; pname: PathGenMode; value: IntPtr)>(z_GetPathTexGenfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPathTexGenfvNV(texCoordSet: TextureUnit; pname: PathGenMode; value: IntPtr);
begin
z_GetPathTexGenfvNV_ovr_2(texCoordSet, pname, value);
end;
end;
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);
public z_PixelDataRangeNV_adr := GetFuncAdr('glPixelDataRangeNV');
public z_PixelDataRangeNV_ovr_0 := GetFuncOrNil&<procedure(target: PixelDataRangeTargetNV; length: Int32; pointer: IntPtr)>(z_PixelDataRangeNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelDataRangeNV(target: PixelDataRangeTargetNV; length: Int32; pointer: IntPtr);
begin
z_PixelDataRangeNV_ovr_0(target, length, pointer);
end;
public z_FlushPixelDataRangeNV_adr := GetFuncAdr('glFlushPixelDataRangeNV');
public z_FlushPixelDataRangeNV_ovr_0 := GetFuncOrNil&<procedure(target: PixelDataRangeTargetNV)>(z_FlushPixelDataRangeNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FlushPixelDataRangeNV(target: PixelDataRangeTargetNV);
begin
z_FlushPixelDataRangeNV_ovr_0(target);
end;
end;
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);
public z_PointParameteriNV_adr := GetFuncAdr('glPointParameteriNV');
public z_PointParameteriNV_ovr_0 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; param: Int32)>(z_PointParameteriNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameteriNV(pname: PointParameterNameARB; param: Int32);
begin
z_PointParameteriNV_ovr_0(pname, param);
end;
public z_PointParameterivNV_adr := GetFuncAdr('glPointParameterivNV');
public z_PointParameterivNV_ovr_0 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; var ¶ms: Int32)>(z_PointParameterivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterivNV(pname: PointParameterNameARB; ¶ms: array of Int32);
begin
z_PointParameterivNV_ovr_0(pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterivNV(pname: PointParameterNameARB; var ¶ms: Int32);
begin
z_PointParameterivNV_ovr_0(pname, ¶ms);
end;
public z_PointParameterivNV_ovr_2 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; ¶ms: IntPtr)>(z_PointParameterivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterivNV(pname: PointParameterNameARB; ¶ms: IntPtr);
begin
z_PointParameterivNV_ovr_2(pname, ¶ms);
end;
end;
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);
public z_PresentFrameKeyedNV_adr := GetFuncAdr('glPresentFrameKeyedNV');
public z_PresentFrameKeyedNV_ovr_0 := GetFuncOrNil&<procedure(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_adr);
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);
begin
z_PresentFrameKeyedNV_ovr_0(video_slot, minPresentTime, beginPresentTimeId, presentDurationId, &type, target0, fill0, key0, target1, fill1, key1);
end;
public z_PresentFrameDualFillNV_adr := GetFuncAdr('glPresentFrameDualFillNV');
public z_PresentFrameDualFillNV_ovr_0 := GetFuncOrNil&<procedure(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_adr);
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);
begin
z_PresentFrameDualFillNV_ovr_0(video_slot, minPresentTime, beginPresentTimeId, presentDurationId, &type, target0, fill0, target1, fill1, target2, fill2, target3, fill3);
end;
public z_GetVideoivNV_adr := GetFuncAdr('glGetVideoivNV');
public z_GetVideoivNV_ovr_0 := GetFuncOrNil&<procedure(video_slot: UInt32; pname: DummyEnum; var ¶ms: Int32)>(z_GetVideoivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoivNV(video_slot: UInt32; pname: DummyEnum; ¶ms: array of Int32);
begin
z_GetVideoivNV_ovr_0(video_slot, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoivNV(video_slot: UInt32; pname: DummyEnum; var ¶ms: Int32);
begin
z_GetVideoivNV_ovr_0(video_slot, pname, ¶ms);
end;
public z_GetVideoivNV_ovr_2 := GetFuncOrNil&<procedure(video_slot: UInt32; pname: DummyEnum; ¶ms: IntPtr)>(z_GetVideoivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoivNV(video_slot: UInt32; pname: DummyEnum; ¶ms: IntPtr);
begin
z_GetVideoivNV_ovr_2(video_slot, pname, ¶ms);
end;
public z_GetVideouivNV_adr := GetFuncAdr('glGetVideouivNV');
public z_GetVideouivNV_ovr_0 := GetFuncOrNil&<procedure(video_slot: UInt32; pname: DummyEnum; var ¶ms: UInt32)>(z_GetVideouivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideouivNV(video_slot: UInt32; pname: DummyEnum; ¶ms: array of UInt32);
begin
z_GetVideouivNV_ovr_0(video_slot, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideouivNV(video_slot: UInt32; pname: DummyEnum; var ¶ms: UInt32);
begin
z_GetVideouivNV_ovr_0(video_slot, pname, ¶ms);
end;
public z_GetVideouivNV_ovr_2 := GetFuncOrNil&<procedure(video_slot: UInt32; pname: DummyEnum; ¶ms: IntPtr)>(z_GetVideouivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideouivNV(video_slot: UInt32; pname: DummyEnum; ¶ms: IntPtr);
begin
z_GetVideouivNV_ovr_2(video_slot, pname, ¶ms);
end;
public z_GetVideoi64vNV_adr := GetFuncAdr('glGetVideoi64vNV');
public z_GetVideoi64vNV_ovr_0 := GetFuncOrNil&<procedure(video_slot: UInt32; pname: DummyEnum; var ¶ms: Int64)>(z_GetVideoi64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoi64vNV(video_slot: UInt32; pname: DummyEnum; ¶ms: array of Int64);
begin
z_GetVideoi64vNV_ovr_0(video_slot, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoi64vNV(video_slot: UInt32; pname: DummyEnum; var ¶ms: Int64);
begin
z_GetVideoi64vNV_ovr_0(video_slot, pname, ¶ms);
end;
public z_GetVideoi64vNV_ovr_2 := GetFuncOrNil&<procedure(video_slot: UInt32; pname: DummyEnum; ¶ms: IntPtr)>(z_GetVideoi64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoi64vNV(video_slot: UInt32; pname: DummyEnum; ¶ms: IntPtr);
begin
z_GetVideoi64vNV_ovr_2(video_slot, pname, ¶ms);
end;
public z_GetVideoui64vNV_adr := GetFuncAdr('glGetVideoui64vNV');
public z_GetVideoui64vNV_ovr_0 := GetFuncOrNil&<procedure(video_slot: UInt32; pname: DummyEnum; var ¶ms: UInt64)>(z_GetVideoui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoui64vNV(video_slot: UInt32; pname: DummyEnum; ¶ms: array of UInt64);
begin
z_GetVideoui64vNV_ovr_0(video_slot, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoui64vNV(video_slot: UInt32; pname: DummyEnum; var ¶ms: UInt64);
begin
z_GetVideoui64vNV_ovr_0(video_slot, pname, ¶ms);
end;
public z_GetVideoui64vNV_ovr_2 := GetFuncOrNil&<procedure(video_slot: UInt32; pname: DummyEnum; ¶ms: IntPtr)>(z_GetVideoui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoui64vNV(video_slot: UInt32; pname: DummyEnum; ¶ms: IntPtr);
begin
z_GetVideoui64vNV_ovr_2(video_slot, pname, ¶ms);
end;
end;
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);
public z_PrimitiveRestartNV_adr := GetFuncAdr('glPrimitiveRestartNV');
public z_PrimitiveRestartNV_ovr_0 := GetFuncOrNil&<procedure>(z_PrimitiveRestartNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrimitiveRestartNV;
begin
z_PrimitiveRestartNV_ovr_0;
end;
public z_PrimitiveRestartIndexNV_adr := GetFuncAdr('glPrimitiveRestartIndexNV');
public z_PrimitiveRestartIndexNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32)>(z_PrimitiveRestartIndexNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrimitiveRestartIndexNV(index: UInt32);
begin
z_PrimitiveRestartIndexNV_ovr_0(index);
end;
end;
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);
public z_QueryResourceNV_adr := GetFuncAdr('glQueryResourceNV');
public z_QueryResourceNV_ovr_0 := GetFuncOrNil&<function(queryType: DummyEnum; tagId: Int32; count: UInt32; var buffer: Int32): Int32>(z_QueryResourceNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function QueryResourceNV(queryType: DummyEnum; tagId: Int32; count: UInt32; buffer: array of Int32): Int32;
begin
Result := z_QueryResourceNV_ovr_0(queryType, tagId, count, buffer[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function QueryResourceNV(queryType: DummyEnum; tagId: Int32; count: UInt32; var buffer: Int32): Int32;
begin
Result := z_QueryResourceNV_ovr_0(queryType, tagId, count, buffer);
end;
public z_QueryResourceNV_ovr_2 := GetFuncOrNil&<function(queryType: DummyEnum; tagId: Int32; count: UInt32; buffer: IntPtr): Int32>(z_QueryResourceNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function QueryResourceNV(queryType: DummyEnum; tagId: Int32; count: UInt32; buffer: IntPtr): Int32;
begin
Result := z_QueryResourceNV_ovr_2(queryType, tagId, count, buffer);
end;
end;
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);
public z_GenQueryResourceTagNV_adr := GetFuncAdr('glGenQueryResourceTagNV');
public z_GenQueryResourceTagNV_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var tagIds: Int32)>(z_GenQueryResourceTagNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenQueryResourceTagNV(n: Int32; tagIds: array of Int32);
begin
z_GenQueryResourceTagNV_ovr_0(n, tagIds[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenQueryResourceTagNV(n: Int32; var tagIds: Int32);
begin
z_GenQueryResourceTagNV_ovr_0(n, tagIds);
end;
public z_GenQueryResourceTagNV_ovr_2 := GetFuncOrNil&<procedure(n: Int32; tagIds: IntPtr)>(z_GenQueryResourceTagNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenQueryResourceTagNV(n: Int32; tagIds: IntPtr);
begin
z_GenQueryResourceTagNV_ovr_2(n, tagIds);
end;
public z_DeleteQueryResourceTagNV_adr := GetFuncAdr('glDeleteQueryResourceTagNV');
public z_DeleteQueryResourceTagNV_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var tagIds: Int32)>(z_DeleteQueryResourceTagNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteQueryResourceTagNV(n: Int32; tagIds: array of Int32);
begin
z_DeleteQueryResourceTagNV_ovr_0(n, tagIds[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteQueryResourceTagNV(n: Int32; var tagIds: Int32);
begin
z_DeleteQueryResourceTagNV_ovr_0(n, tagIds);
end;
public z_DeleteQueryResourceTagNV_ovr_2 := GetFuncOrNil&<procedure(n: Int32; tagIds: IntPtr)>(z_DeleteQueryResourceTagNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteQueryResourceTagNV(n: Int32; tagIds: IntPtr);
begin
z_DeleteQueryResourceTagNV_ovr_2(n, tagIds);
end;
public z_QueryResourceTagNV_adr := GetFuncAdr('glQueryResourceTagNV');
public z_QueryResourceTagNV_ovr_0 := GetFuncOrNil&<procedure(tagId: Int32; tagString: IntPtr)>(z_QueryResourceTagNV_adr);
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);
begin
z_QueryResourceTagNV_ovr_0(tagId, tagString);
end;
end;
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);
public z_CombinerParameterfvNV_adr := GetFuncAdr('glCombinerParameterfvNV');
public z_CombinerParameterfvNV_ovr_0 := GetFuncOrNil&<procedure(pname: CombinerParameterNV; var ¶ms: single)>(z_CombinerParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CombinerParameterfvNV(pname: CombinerParameterNV; ¶ms: array of single);
begin
z_CombinerParameterfvNV_ovr_0(pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CombinerParameterfvNV(pname: CombinerParameterNV; var ¶ms: single);
begin
z_CombinerParameterfvNV_ovr_0(pname, ¶ms);
end;
public z_CombinerParameterfvNV_ovr_2 := GetFuncOrNil&<procedure(pname: CombinerParameterNV; ¶ms: IntPtr)>(z_CombinerParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CombinerParameterfvNV(pname: CombinerParameterNV; ¶ms: IntPtr);
begin
z_CombinerParameterfvNV_ovr_2(pname, ¶ms);
end;
public z_CombinerParameterfNV_adr := GetFuncAdr('glCombinerParameterfNV');
public z_CombinerParameterfNV_ovr_0 := GetFuncOrNil&<procedure(pname: CombinerParameterNV; param: single)>(z_CombinerParameterfNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CombinerParameterfNV(pname: CombinerParameterNV; param: single);
begin
z_CombinerParameterfNV_ovr_0(pname, param);
end;
public z_CombinerParameterivNV_adr := GetFuncAdr('glCombinerParameterivNV');
public z_CombinerParameterivNV_ovr_0 := GetFuncOrNil&<procedure(pname: CombinerParameterNV; var ¶ms: Int32)>(z_CombinerParameterivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CombinerParameterivNV(pname: CombinerParameterNV; ¶ms: array of Int32);
begin
z_CombinerParameterivNV_ovr_0(pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CombinerParameterivNV(pname: CombinerParameterNV; var ¶ms: Int32);
begin
z_CombinerParameterivNV_ovr_0(pname, ¶ms);
end;
public z_CombinerParameterivNV_ovr_2 := GetFuncOrNil&<procedure(pname: CombinerParameterNV; ¶ms: IntPtr)>(z_CombinerParameterivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CombinerParameterivNV(pname: CombinerParameterNV; ¶ms: IntPtr);
begin
z_CombinerParameterivNV_ovr_2(pname, ¶ms);
end;
public z_CombinerParameteriNV_adr := GetFuncAdr('glCombinerParameteriNV');
public z_CombinerParameteriNV_ovr_0 := GetFuncOrNil&<procedure(pname: CombinerParameterNV; param: Int32)>(z_CombinerParameteriNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CombinerParameteriNV(pname: CombinerParameterNV; param: Int32);
begin
z_CombinerParameteriNV_ovr_0(pname, param);
end;
public z_CombinerInputNV_adr := GetFuncAdr('glCombinerInputNV');
public z_CombinerInputNV_ovr_0 := GetFuncOrNil&<procedure(stage: CombinerStageNV; portion: CombinerPortionNV; variable: CombinerVariableNV; input: CombinerRegisterNV; mapping: CombinerMappingNV; componentUsage: CombinerComponentUsageNV)>(z_CombinerInputNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CombinerInputNV(stage: CombinerStageNV; portion: CombinerPortionNV; variable: CombinerVariableNV; input: CombinerRegisterNV; mapping: CombinerMappingNV; componentUsage: CombinerComponentUsageNV);
begin
z_CombinerInputNV_ovr_0(stage, portion, variable, input, mapping, componentUsage);
end;
public z_CombinerOutputNV_adr := GetFuncAdr('glCombinerOutputNV');
public z_CombinerOutputNV_ovr_0 := GetFuncOrNil&<procedure(stage: CombinerStageNV; portion: CombinerPortionNV; abOutput: CombinerRegisterNV; cdOutput: CombinerRegisterNV; sumOutput: CombinerRegisterNV; scale: CombinerScaleNV; bias: CombinerBiasNV; abDotProduct: boolean; cdDotProduct: boolean; muxSum: boolean)>(z_CombinerOutputNV_adr);
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);
begin
z_CombinerOutputNV_ovr_0(stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum);
end;
public z_FinalCombinerInputNV_adr := GetFuncAdr('glFinalCombinerInputNV');
public z_FinalCombinerInputNV_ovr_0 := GetFuncOrNil&<procedure(variable: CombinerVariableNV; input: CombinerRegisterNV; mapping: CombinerMappingNV; componentUsage: CombinerComponentUsageNV)>(z_FinalCombinerInputNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FinalCombinerInputNV(variable: CombinerVariableNV; input: CombinerRegisterNV; mapping: CombinerMappingNV; componentUsage: CombinerComponentUsageNV);
begin
z_FinalCombinerInputNV_ovr_0(variable, input, mapping, componentUsage);
end;
public z_GetCombinerInputParameterfvNV_adr := GetFuncAdr('glGetCombinerInputParameterfvNV');
public z_GetCombinerInputParameterfvNV_ovr_0 := GetFuncOrNil&<procedure(stage: CombinerStageNV; portion: CombinerPortionNV; variable: CombinerVariableNV; pname: CombinerParameterNV; var ¶ms: single)>(z_GetCombinerInputParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerInputParameterfvNV(stage: CombinerStageNV; portion: CombinerPortionNV; variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: array of single);
begin
z_GetCombinerInputParameterfvNV_ovr_0(stage, portion, variable, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerInputParameterfvNV(stage: CombinerStageNV; portion: CombinerPortionNV; variable: CombinerVariableNV; pname: CombinerParameterNV; var ¶ms: single);
begin
z_GetCombinerInputParameterfvNV_ovr_0(stage, portion, variable, pname, ¶ms);
end;
public z_GetCombinerInputParameterfvNV_ovr_2 := GetFuncOrNil&<procedure(stage: CombinerStageNV; portion: CombinerPortionNV; variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: IntPtr)>(z_GetCombinerInputParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerInputParameterfvNV(stage: CombinerStageNV; portion: CombinerPortionNV; variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: IntPtr);
begin
z_GetCombinerInputParameterfvNV_ovr_2(stage, portion, variable, pname, ¶ms);
end;
public z_GetCombinerInputParameterivNV_adr := GetFuncAdr('glGetCombinerInputParameterivNV');
public z_GetCombinerInputParameterivNV_ovr_0 := GetFuncOrNil&<procedure(stage: CombinerStageNV; portion: CombinerPortionNV; variable: CombinerVariableNV; pname: CombinerParameterNV; var ¶ms: Int32)>(z_GetCombinerInputParameterivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerInputParameterivNV(stage: CombinerStageNV; portion: CombinerPortionNV; variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: array of Int32);
begin
z_GetCombinerInputParameterivNV_ovr_0(stage, portion, variable, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerInputParameterivNV(stage: CombinerStageNV; portion: CombinerPortionNV; variable: CombinerVariableNV; pname: CombinerParameterNV; var ¶ms: Int32);
begin
z_GetCombinerInputParameterivNV_ovr_0(stage, portion, variable, pname, ¶ms);
end;
public z_GetCombinerInputParameterivNV_ovr_2 := GetFuncOrNil&<procedure(stage: CombinerStageNV; portion: CombinerPortionNV; variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: IntPtr)>(z_GetCombinerInputParameterivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerInputParameterivNV(stage: CombinerStageNV; portion: CombinerPortionNV; variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: IntPtr);
begin
z_GetCombinerInputParameterivNV_ovr_2(stage, portion, variable, pname, ¶ms);
end;
public z_GetCombinerOutputParameterfvNV_adr := GetFuncAdr('glGetCombinerOutputParameterfvNV');
public z_GetCombinerOutputParameterfvNV_ovr_0 := GetFuncOrNil&<procedure(stage: CombinerStageNV; portion: CombinerPortionNV; pname: CombinerParameterNV; var ¶ms: single)>(z_GetCombinerOutputParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerOutputParameterfvNV(stage: CombinerStageNV; portion: CombinerPortionNV; pname: CombinerParameterNV; ¶ms: array of single);
begin
z_GetCombinerOutputParameterfvNV_ovr_0(stage, portion, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerOutputParameterfvNV(stage: CombinerStageNV; portion: CombinerPortionNV; pname: CombinerParameterNV; var ¶ms: single);
begin
z_GetCombinerOutputParameterfvNV_ovr_0(stage, portion, pname, ¶ms);
end;
public z_GetCombinerOutputParameterfvNV_ovr_2 := GetFuncOrNil&<procedure(stage: CombinerStageNV; portion: CombinerPortionNV; pname: CombinerParameterNV; ¶ms: IntPtr)>(z_GetCombinerOutputParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerOutputParameterfvNV(stage: CombinerStageNV; portion: CombinerPortionNV; pname: CombinerParameterNV; ¶ms: IntPtr);
begin
z_GetCombinerOutputParameterfvNV_ovr_2(stage, portion, pname, ¶ms);
end;
public z_GetCombinerOutputParameterivNV_adr := GetFuncAdr('glGetCombinerOutputParameterivNV');
public z_GetCombinerOutputParameterivNV_ovr_0 := GetFuncOrNil&<procedure(stage: CombinerStageNV; portion: CombinerPortionNV; pname: CombinerParameterNV; var ¶ms: Int32)>(z_GetCombinerOutputParameterivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerOutputParameterivNV(stage: CombinerStageNV; portion: CombinerPortionNV; pname: CombinerParameterNV; ¶ms: array of Int32);
begin
z_GetCombinerOutputParameterivNV_ovr_0(stage, portion, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerOutputParameterivNV(stage: CombinerStageNV; portion: CombinerPortionNV; pname: CombinerParameterNV; var ¶ms: Int32);
begin
z_GetCombinerOutputParameterivNV_ovr_0(stage, portion, pname, ¶ms);
end;
public z_GetCombinerOutputParameterivNV_ovr_2 := GetFuncOrNil&<procedure(stage: CombinerStageNV; portion: CombinerPortionNV; pname: CombinerParameterNV; ¶ms: IntPtr)>(z_GetCombinerOutputParameterivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerOutputParameterivNV(stage: CombinerStageNV; portion: CombinerPortionNV; pname: CombinerParameterNV; ¶ms: IntPtr);
begin
z_GetCombinerOutputParameterivNV_ovr_2(stage, portion, pname, ¶ms);
end;
public z_GetFinalCombinerInputParameterfvNV_adr := GetFuncAdr('glGetFinalCombinerInputParameterfvNV');
public z_GetFinalCombinerInputParameterfvNV_ovr_0 := GetFuncOrNil&<procedure(variable: CombinerVariableNV; pname: CombinerParameterNV; var ¶ms: single)>(z_GetFinalCombinerInputParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFinalCombinerInputParameterfvNV(variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: array of single);
begin
z_GetFinalCombinerInputParameterfvNV_ovr_0(variable, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFinalCombinerInputParameterfvNV(variable: CombinerVariableNV; pname: CombinerParameterNV; var ¶ms: single);
begin
z_GetFinalCombinerInputParameterfvNV_ovr_0(variable, pname, ¶ms);
end;
public z_GetFinalCombinerInputParameterfvNV_ovr_2 := GetFuncOrNil&<procedure(variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: IntPtr)>(z_GetFinalCombinerInputParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFinalCombinerInputParameterfvNV(variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: IntPtr);
begin
z_GetFinalCombinerInputParameterfvNV_ovr_2(variable, pname, ¶ms);
end;
public z_GetFinalCombinerInputParameterivNV_adr := GetFuncAdr('glGetFinalCombinerInputParameterivNV');
public z_GetFinalCombinerInputParameterivNV_ovr_0 := GetFuncOrNil&<procedure(variable: CombinerVariableNV; pname: CombinerParameterNV; var ¶ms: Int32)>(z_GetFinalCombinerInputParameterivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFinalCombinerInputParameterivNV(variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: array of Int32);
begin
z_GetFinalCombinerInputParameterivNV_ovr_0(variable, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFinalCombinerInputParameterivNV(variable: CombinerVariableNV; pname: CombinerParameterNV; var ¶ms: Int32);
begin
z_GetFinalCombinerInputParameterivNV_ovr_0(variable, pname, ¶ms);
end;
public z_GetFinalCombinerInputParameterivNV_ovr_2 := GetFuncOrNil&<procedure(variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: IntPtr)>(z_GetFinalCombinerInputParameterivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFinalCombinerInputParameterivNV(variable: CombinerVariableNV; pname: CombinerParameterNV; ¶ms: IntPtr);
begin
z_GetFinalCombinerInputParameterivNV_ovr_2(variable, pname, ¶ms);
end;
end;
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);
public z_CombinerStageParameterfvNV_adr := GetFuncAdr('glCombinerStageParameterfvNV');
public z_CombinerStageParameterfvNV_ovr_0 := GetFuncOrNil&<procedure(stage: CombinerStageNV; pname: CombinerParameterNV; var ¶ms: single)>(z_CombinerStageParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CombinerStageParameterfvNV(stage: CombinerStageNV; pname: CombinerParameterNV; ¶ms: array of single);
begin
z_CombinerStageParameterfvNV_ovr_0(stage, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CombinerStageParameterfvNV(stage: CombinerStageNV; pname: CombinerParameterNV; var ¶ms: single);
begin
z_CombinerStageParameterfvNV_ovr_0(stage, pname, ¶ms);
end;
public z_CombinerStageParameterfvNV_ovr_2 := GetFuncOrNil&<procedure(stage: CombinerStageNV; pname: CombinerParameterNV; ¶ms: IntPtr)>(z_CombinerStageParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CombinerStageParameterfvNV(stage: CombinerStageNV; pname: CombinerParameterNV; ¶ms: IntPtr);
begin
z_CombinerStageParameterfvNV_ovr_2(stage, pname, ¶ms);
end;
public z_GetCombinerStageParameterfvNV_adr := GetFuncAdr('glGetCombinerStageParameterfvNV');
public z_GetCombinerStageParameterfvNV_ovr_0 := GetFuncOrNil&<procedure(stage: CombinerStageNV; pname: CombinerParameterNV; var ¶ms: single)>(z_GetCombinerStageParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerStageParameterfvNV(stage: CombinerStageNV; pname: CombinerParameterNV; ¶ms: array of single);
begin
z_GetCombinerStageParameterfvNV_ovr_0(stage, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerStageParameterfvNV(stage: CombinerStageNV; pname: CombinerParameterNV; var ¶ms: single);
begin
z_GetCombinerStageParameterfvNV_ovr_0(stage, pname, ¶ms);
end;
public z_GetCombinerStageParameterfvNV_ovr_2 := GetFuncOrNil&<procedure(stage: CombinerStageNV; pname: CombinerParameterNV; ¶ms: IntPtr)>(z_GetCombinerStageParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetCombinerStageParameterfvNV(stage: CombinerStageNV; pname: CombinerParameterNV; ¶ms: IntPtr);
begin
z_GetCombinerStageParameterfvNV_ovr_2(stage, pname, ¶ms);
end;
end;
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);
public z_FramebufferSampleLocationsfvNV_adr := GetFuncAdr('glFramebufferSampleLocationsfvNV');
public z_FramebufferSampleLocationsfvNV_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; start: UInt32; count: Int32; var v: single)>(z_FramebufferSampleLocationsfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferSampleLocationsfvNV(target: FramebufferTarget; start: UInt32; count: Int32; v: array of single);
begin
z_FramebufferSampleLocationsfvNV_ovr_0(target, start, count, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferSampleLocationsfvNV(target: FramebufferTarget; start: UInt32; count: Int32; var v: single);
begin
z_FramebufferSampleLocationsfvNV_ovr_0(target, start, count, v);
end;
public z_FramebufferSampleLocationsfvNV_ovr_2 := GetFuncOrNil&<procedure(target: FramebufferTarget; start: UInt32; count: Int32; v: IntPtr)>(z_FramebufferSampleLocationsfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferSampleLocationsfvNV(target: FramebufferTarget; start: UInt32; count: Int32; v: IntPtr);
begin
z_FramebufferSampleLocationsfvNV_ovr_2(target, start, count, v);
end;
public z_NamedFramebufferSampleLocationsfvNV_adr := GetFuncAdr('glNamedFramebufferSampleLocationsfvNV');
public z_NamedFramebufferSampleLocationsfvNV_ovr_0 := GetFuncOrNil&<procedure(framebuffer: UInt32; start: UInt32; count: Int32; var v: single)>(z_NamedFramebufferSampleLocationsfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferSampleLocationsfvNV(framebuffer: UInt32; start: UInt32; count: Int32; v: array of single);
begin
z_NamedFramebufferSampleLocationsfvNV_ovr_0(framebuffer, start, count, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferSampleLocationsfvNV(framebuffer: UInt32; start: UInt32; count: Int32; var v: single);
begin
z_NamedFramebufferSampleLocationsfvNV_ovr_0(framebuffer, start, count, v);
end;
public z_NamedFramebufferSampleLocationsfvNV_ovr_2 := GetFuncOrNil&<procedure(framebuffer: UInt32; start: UInt32; count: Int32; v: IntPtr)>(z_NamedFramebufferSampleLocationsfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedFramebufferSampleLocationsfvNV(framebuffer: UInt32; start: UInt32; count: Int32; v: IntPtr);
begin
z_NamedFramebufferSampleLocationsfvNV_ovr_2(framebuffer, start, count, v);
end;
public z_ResolveDepthValuesNV_adr := GetFuncAdr('glResolveDepthValuesNV');
public z_ResolveDepthValuesNV_ovr_0 := GetFuncOrNil&<procedure>(z_ResolveDepthValuesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ResolveDepthValuesNV;
begin
z_ResolveDepthValuesNV_ovr_0;
end;
end;
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);
public z_ScissorExclusiveNV_adr := GetFuncAdr('glScissorExclusiveNV');
public z_ScissorExclusiveNV_ovr_0 := GetFuncOrNil&<procedure(x: Int32; y: Int32; width: Int32; height: Int32)>(z_ScissorExclusiveNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScissorExclusiveNV(x: Int32; y: Int32; width: Int32; height: Int32);
begin
z_ScissorExclusiveNV_ovr_0(x, y, width, height);
end;
public z_ScissorExclusiveArrayvNV_adr := GetFuncAdr('glScissorExclusiveArrayvNV');
public z_ScissorExclusiveArrayvNV_ovr_0 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; var v: Int32)>(z_ScissorExclusiveArrayvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScissorExclusiveArrayvNV(first: UInt32; count: Int32; v: array of Int32);
begin
z_ScissorExclusiveArrayvNV_ovr_0(first, count, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScissorExclusiveArrayvNV(first: UInt32; count: Int32; var v: Int32);
begin
z_ScissorExclusiveArrayvNV_ovr_0(first, count, v);
end;
public z_ScissorExclusiveArrayvNV_ovr_2 := GetFuncOrNil&<procedure(first: UInt32; count: Int32; v: IntPtr)>(z_ScissorExclusiveArrayvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScissorExclusiveArrayvNV(first: UInt32; count: Int32; v: IntPtr);
begin
z_ScissorExclusiveArrayvNV_ovr_2(first, count, v);
end;
end;
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);
public z_MakeBufferResidentNV_adr := GetFuncAdr('glMakeBufferResidentNV');
public z_MakeBufferResidentNV_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; access: DummyEnum)>(z_MakeBufferResidentNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MakeBufferResidentNV(target: DummyEnum; access: DummyEnum);
begin
z_MakeBufferResidentNV_ovr_0(target, access);
end;
public z_MakeBufferNonResidentNV_adr := GetFuncAdr('glMakeBufferNonResidentNV');
public z_MakeBufferNonResidentNV_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum)>(z_MakeBufferNonResidentNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MakeBufferNonResidentNV(target: DummyEnum);
begin
z_MakeBufferNonResidentNV_ovr_0(target);
end;
public z_IsBufferResidentNV_adr := GetFuncAdr('glIsBufferResidentNV');
public z_IsBufferResidentNV_ovr_0 := GetFuncOrNil&<function(target: DummyEnum): boolean>(z_IsBufferResidentNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsBufferResidentNV(target: DummyEnum): boolean;
begin
Result := z_IsBufferResidentNV_ovr_0(target);
end;
public z_MakeNamedBufferResidentNV_adr := GetFuncAdr('glMakeNamedBufferResidentNV');
public z_MakeNamedBufferResidentNV_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; access: DummyEnum)>(z_MakeNamedBufferResidentNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MakeNamedBufferResidentNV(buffer: UInt32; access: DummyEnum);
begin
z_MakeNamedBufferResidentNV_ovr_0(buffer, access);
end;
public z_MakeNamedBufferNonResidentNV_adr := GetFuncAdr('glMakeNamedBufferNonResidentNV');
public z_MakeNamedBufferNonResidentNV_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32)>(z_MakeNamedBufferNonResidentNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MakeNamedBufferNonResidentNV(buffer: UInt32);
begin
z_MakeNamedBufferNonResidentNV_ovr_0(buffer);
end;
public z_IsNamedBufferResidentNV_adr := GetFuncAdr('glIsNamedBufferResidentNV');
public z_IsNamedBufferResidentNV_ovr_0 := GetFuncOrNil&<function(buffer: UInt32): boolean>(z_IsNamedBufferResidentNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsNamedBufferResidentNV(buffer: UInt32): boolean;
begin
Result := z_IsNamedBufferResidentNV_ovr_0(buffer);
end;
public z_GetBufferParameterui64vNV_adr := GetFuncAdr('glGetBufferParameterui64vNV');
public z_GetBufferParameterui64vNV_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: DummyEnum; var ¶ms: UInt64)>(z_GetBufferParameterui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameterui64vNV(target: BufferTargetARB; pname: DummyEnum; ¶ms: array of UInt64);
begin
z_GetBufferParameterui64vNV_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameterui64vNV(target: BufferTargetARB; pname: DummyEnum; var ¶ms: UInt64);
begin
z_GetBufferParameterui64vNV_ovr_0(target, pname, ¶ms);
end;
public z_GetBufferParameterui64vNV_ovr_2 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: DummyEnum; ¶ms: IntPtr)>(z_GetBufferParameterui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameterui64vNV(target: BufferTargetARB; pname: DummyEnum; ¶ms: IntPtr);
begin
z_GetBufferParameterui64vNV_ovr_2(target, pname, ¶ms);
end;
public z_GetNamedBufferParameterui64vNV_adr := GetFuncAdr('glGetNamedBufferParameterui64vNV');
public z_GetNamedBufferParameterui64vNV_ovr_0 := GetFuncOrNil&<procedure(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: UInt64)>(z_GetNamedBufferParameterui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameterui64vNV(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: array of UInt64);
begin
z_GetNamedBufferParameterui64vNV_ovr_0(buffer, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameterui64vNV(buffer: UInt32; pname: VertexBufferObjectParameter; var ¶ms: UInt64);
begin
z_GetNamedBufferParameterui64vNV_ovr_0(buffer, pname, ¶ms);
end;
public z_GetNamedBufferParameterui64vNV_ovr_2 := GetFuncOrNil&<procedure(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: IntPtr)>(z_GetNamedBufferParameterui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferParameterui64vNV(buffer: UInt32; pname: VertexBufferObjectParameter; ¶ms: IntPtr);
begin
z_GetNamedBufferParameterui64vNV_ovr_2(buffer, pname, ¶ms);
end;
public z_GetIntegerui64vNV_adr := GetFuncAdr('glGetIntegerui64vNV');
public z_GetIntegerui64vNV_ovr_0 := GetFuncOrNil&<procedure(value: DummyEnum; var result: UInt64)>(z_GetIntegerui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerui64vNV(value: DummyEnum; result: array of UInt64);
begin
z_GetIntegerui64vNV_ovr_0(value, result[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerui64vNV(value: DummyEnum; var result: UInt64);
begin
z_GetIntegerui64vNV_ovr_0(value, result);
end;
public z_GetIntegerui64vNV_ovr_2 := GetFuncOrNil&<procedure(value: DummyEnum; result: IntPtr)>(z_GetIntegerui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerui64vNV(value: DummyEnum; result: IntPtr);
begin
z_GetIntegerui64vNV_ovr_2(value, result);
end;
public z_Uniformui64NV_adr := GetFuncAdr('glUniformui64NV');
public z_Uniformui64NV_ovr_0 := GetFuncOrNil&<procedure(location: Int32; value: UInt64)>(z_Uniformui64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniformui64NV(location: Int32; value: UInt64);
begin
z_Uniformui64NV_ovr_0(location, value);
end;
public z_Uniformui64vNV_adr := GetFuncAdr('glUniformui64vNV');
public z_Uniformui64vNV_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: UInt64)>(z_Uniformui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniformui64vNV(location: Int32; count: Int32; value: array of UInt64);
begin
z_Uniformui64vNV_ovr_0(location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniformui64vNV(location: Int32; count: Int32; var value: UInt64);
begin
z_Uniformui64vNV_ovr_0(location, count, value);
end;
public z_Uniformui64vNV_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniformui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniformui64vNV(location: Int32; count: Int32; value: IntPtr);
begin
z_Uniformui64vNV_ovr_2(location, count, value);
end;
public z_GetUniformui64vNV_adr := GetFuncAdr('glGetUniformui64vNV');
public z_GetUniformui64vNV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; var ¶ms: UInt64)>(z_GetUniformui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformui64vNV(&program: UInt32; location: Int32; ¶ms: array of UInt64);
begin
z_GetUniformui64vNV_ovr_0(&program, location, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformui64vNV(&program: UInt32; location: Int32; var ¶ms: UInt64);
begin
z_GetUniformui64vNV_ovr_0(&program, location, ¶ms);
end;
public z_GetUniformui64vNV_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; ¶ms: IntPtr)>(z_GetUniformui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetUniformui64vNV(&program: UInt32; location: Int32; ¶ms: IntPtr);
begin
z_GetUniformui64vNV_ovr_2(&program, location, ¶ms);
end;
public z_ProgramUniformui64NV_adr := GetFuncAdr('glProgramUniformui64NV');
public z_ProgramUniformui64NV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; value: UInt64)>(z_ProgramUniformui64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformui64NV(&program: UInt32; location: Int32; value: UInt64);
begin
z_ProgramUniformui64NV_ovr_0(&program, location, value);
end;
public z_ProgramUniformui64vNV_adr := GetFuncAdr('glProgramUniformui64vNV');
public z_ProgramUniformui64vNV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; var value: UInt64)>(z_ProgramUniformui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformui64vNV(&program: UInt32; location: Int32; count: Int32; value: array of UInt64);
begin
z_ProgramUniformui64vNV_ovr_0(&program, location, count, value[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformui64vNV(&program: UInt32; location: Int32; count: Int32; var value: UInt64);
begin
z_ProgramUniformui64vNV_ovr_0(&program, location, count, value);
end;
public z_ProgramUniformui64vNV_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; location: Int32; count: Int32; value: IntPtr)>(z_ProgramUniformui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramUniformui64vNV(&program: UInt32; location: Int32; count: Int32; value: IntPtr);
begin
z_ProgramUniformui64vNV_ovr_2(&program, location, count, value);
end;
end;
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);
public z_BindShadingRateImageNV_adr := GetFuncAdr('glBindShadingRateImageNV');
public z_BindShadingRateImageNV_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32)>(z_BindShadingRateImageNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindShadingRateImageNV(texture: UInt32);
begin
z_BindShadingRateImageNV_ovr_0(texture);
end;
public z_GetShadingRateImagePaletteNV_adr := GetFuncAdr('glGetShadingRateImagePaletteNV');
public z_GetShadingRateImagePaletteNV_ovr_0 := GetFuncOrNil&<procedure(viewport: UInt32; entry: UInt32; var rate: DummyEnum)>(z_GetShadingRateImagePaletteNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShadingRateImagePaletteNV(viewport: UInt32; entry: UInt32; rate: array of DummyEnum);
begin
z_GetShadingRateImagePaletteNV_ovr_0(viewport, entry, rate[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShadingRateImagePaletteNV(viewport: UInt32; entry: UInt32; var rate: DummyEnum);
begin
z_GetShadingRateImagePaletteNV_ovr_0(viewport, entry, rate);
end;
public z_GetShadingRateImagePaletteNV_ovr_2 := GetFuncOrNil&<procedure(viewport: UInt32; entry: UInt32; rate: IntPtr)>(z_GetShadingRateImagePaletteNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShadingRateImagePaletteNV(viewport: UInt32; entry: UInt32; rate: IntPtr);
begin
z_GetShadingRateImagePaletteNV_ovr_2(viewport, entry, rate);
end;
public z_GetShadingRateSampleLocationivNV_adr := GetFuncAdr('glGetShadingRateSampleLocationivNV');
public z_GetShadingRateSampleLocationivNV_ovr_0 := GetFuncOrNil&<procedure(rate: DummyEnum; samples: UInt32; index: UInt32; var location: Int32)>(z_GetShadingRateSampleLocationivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShadingRateSampleLocationivNV(rate: DummyEnum; samples: UInt32; index: UInt32; location: array of Int32);
begin
z_GetShadingRateSampleLocationivNV_ovr_0(rate, samples, index, location[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShadingRateSampleLocationivNV(rate: DummyEnum; samples: UInt32; index: UInt32; var location: Int32);
begin
z_GetShadingRateSampleLocationivNV_ovr_0(rate, samples, index, location);
end;
public z_GetShadingRateSampleLocationivNV_ovr_2 := GetFuncOrNil&<procedure(rate: DummyEnum; samples: UInt32; index: UInt32; location: IntPtr)>(z_GetShadingRateSampleLocationivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetShadingRateSampleLocationivNV(rate: DummyEnum; samples: UInt32; index: UInt32; location: IntPtr);
begin
z_GetShadingRateSampleLocationivNV_ovr_2(rate, samples, index, location);
end;
public z_ShadingRateImageBarrierNV_adr := GetFuncAdr('glShadingRateImageBarrierNV');
public z_ShadingRateImageBarrierNV_ovr_0 := GetFuncOrNil&<procedure(synchronize: boolean)>(z_ShadingRateImageBarrierNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShadingRateImageBarrierNV(synchronize: boolean);
begin
z_ShadingRateImageBarrierNV_ovr_0(synchronize);
end;
public z_ShadingRateImagePaletteNV_adr := GetFuncAdr('glShadingRateImagePaletteNV');
public z_ShadingRateImagePaletteNV_ovr_0 := GetFuncOrNil&<procedure(viewport: UInt32; first: UInt32; count: Int32; var rates: DummyEnum)>(z_ShadingRateImagePaletteNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShadingRateImagePaletteNV(viewport: UInt32; first: UInt32; count: Int32; rates: array of DummyEnum);
begin
z_ShadingRateImagePaletteNV_ovr_0(viewport, first, count, rates[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShadingRateImagePaletteNV(viewport: UInt32; first: UInt32; count: Int32; var rates: DummyEnum);
begin
z_ShadingRateImagePaletteNV_ovr_0(viewport, first, count, rates);
end;
public z_ShadingRateImagePaletteNV_ovr_2 := GetFuncOrNil&<procedure(viewport: UInt32; first: UInt32; count: Int32; rates: IntPtr)>(z_ShadingRateImagePaletteNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShadingRateImagePaletteNV(viewport: UInt32; first: UInt32; count: Int32; rates: IntPtr);
begin
z_ShadingRateImagePaletteNV_ovr_2(viewport, first, count, rates);
end;
public z_ShadingRateSampleOrderNV_adr := GetFuncAdr('glShadingRateSampleOrderNV');
public z_ShadingRateSampleOrderNV_ovr_0 := GetFuncOrNil&<procedure(order: DummyEnum)>(z_ShadingRateSampleOrderNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShadingRateSampleOrderNV(order: DummyEnum);
begin
z_ShadingRateSampleOrderNV_ovr_0(order);
end;
public z_ShadingRateSampleOrderCustomNV_adr := GetFuncAdr('glShadingRateSampleOrderCustomNV');
public z_ShadingRateSampleOrderCustomNV_ovr_0 := GetFuncOrNil&<procedure(rate: DummyEnum; samples: UInt32; var locations: Int32)>(z_ShadingRateSampleOrderCustomNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShadingRateSampleOrderCustomNV(rate: DummyEnum; samples: UInt32; locations: array of Int32);
begin
z_ShadingRateSampleOrderCustomNV_ovr_0(rate, samples, locations[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShadingRateSampleOrderCustomNV(rate: DummyEnum; samples: UInt32; var locations: Int32);
begin
z_ShadingRateSampleOrderCustomNV_ovr_0(rate, samples, locations);
end;
public z_ShadingRateSampleOrderCustomNV_ovr_2 := GetFuncOrNil&<procedure(rate: DummyEnum; samples: UInt32; locations: IntPtr)>(z_ShadingRateSampleOrderCustomNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ShadingRateSampleOrderCustomNV(rate: DummyEnum; samples: UInt32; locations: IntPtr);
begin
z_ShadingRateSampleOrderCustomNV_ovr_2(rate, samples, locations);
end;
end;
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);
public z_TextureBarrierNV_adr := GetFuncAdr('glTextureBarrierNV');
public z_TextureBarrierNV_ovr_0 := GetFuncOrNil&<procedure>(z_TextureBarrierNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureBarrierNV;
begin
z_TextureBarrierNV_ovr_0;
end;
end;
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);
public z_TexImage2DMultisampleCoverageNV_adr := GetFuncAdr('glTexImage2DMultisampleCoverageNV');
public z_TexImage2DMultisampleCoverageNV_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; coverageSamples: Int32; colorSamples: Int32; internalFormat: Int32; width: Int32; height: Int32; fixedSampleLocations: boolean)>(z_TexImage2DMultisampleCoverageNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexImage2DMultisampleCoverageNV(target: TextureTarget; coverageSamples: Int32; colorSamples: Int32; internalFormat: Int32; width: Int32; height: Int32; fixedSampleLocations: boolean);
begin
z_TexImage2DMultisampleCoverageNV_ovr_0(target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations);
end;
public z_TexImage3DMultisampleCoverageNV_adr := GetFuncAdr('glTexImage3DMultisampleCoverageNV');
public z_TexImage3DMultisampleCoverageNV_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; coverageSamples: Int32; colorSamples: Int32; internalFormat: Int32; width: Int32; height: Int32; depth: Int32; fixedSampleLocations: boolean)>(z_TexImage3DMultisampleCoverageNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexImage3DMultisampleCoverageNV(target: TextureTarget; coverageSamples: Int32; colorSamples: Int32; internalFormat: Int32; width: Int32; height: Int32; depth: Int32; fixedSampleLocations: boolean);
begin
z_TexImage3DMultisampleCoverageNV_ovr_0(target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations);
end;
public z_TextureImage2DMultisampleNV_adr := GetFuncAdr('glTextureImage2DMultisampleNV');
public z_TextureImage2DMultisampleNV_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; samples: Int32; internalFormat: Int32; width: Int32; height: Int32; fixedSampleLocations: boolean)>(z_TextureImage2DMultisampleNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureImage2DMultisampleNV(texture: UInt32; target: TextureTarget; samples: Int32; internalFormat: Int32; width: Int32; height: Int32; fixedSampleLocations: boolean);
begin
z_TextureImage2DMultisampleNV_ovr_0(texture, target, samples, internalFormat, width, height, fixedSampleLocations);
end;
public z_TextureImage3DMultisampleNV_adr := GetFuncAdr('glTextureImage3DMultisampleNV');
public z_TextureImage3DMultisampleNV_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; samples: Int32; internalFormat: Int32; width: Int32; height: Int32; depth: Int32; fixedSampleLocations: boolean)>(z_TextureImage3DMultisampleNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureImage3DMultisampleNV(texture: UInt32; target: TextureTarget; samples: Int32; internalFormat: Int32; width: Int32; height: Int32; depth: Int32; fixedSampleLocations: boolean);
begin
z_TextureImage3DMultisampleNV_ovr_0(texture, target, samples, internalFormat, width, height, depth, fixedSampleLocations);
end;
public z_TextureImage2DMultisampleCoverageNV_adr := GetFuncAdr('glTextureImage2DMultisampleCoverageNV');
public z_TextureImage2DMultisampleCoverageNV_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; coverageSamples: Int32; colorSamples: Int32; internalFormat: Int32; width: Int32; height: Int32; fixedSampleLocations: boolean)>(z_TextureImage2DMultisampleCoverageNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureImage2DMultisampleCoverageNV(texture: UInt32; target: TextureTarget; coverageSamples: Int32; colorSamples: Int32; internalFormat: Int32; width: Int32; height: Int32; fixedSampleLocations: boolean);
begin
z_TextureImage2DMultisampleCoverageNV_ovr_0(texture, target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations);
end;
public z_TextureImage3DMultisampleCoverageNV_adr := GetFuncAdr('glTextureImage3DMultisampleCoverageNV');
public z_TextureImage3DMultisampleCoverageNV_ovr_0 := GetFuncOrNil&<procedure(texture: UInt32; target: TextureTarget; coverageSamples: Int32; colorSamples: Int32; internalFormat: Int32; width: Int32; height: Int32; depth: Int32; fixedSampleLocations: boolean)>(z_TextureImage3DMultisampleCoverageNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureImage3DMultisampleCoverageNV(texture: UInt32; target: TextureTarget; coverageSamples: Int32; colorSamples: Int32; internalFormat: Int32; width: Int32; height: Int32; depth: Int32; fixedSampleLocations: boolean);
begin
z_TextureImage3DMultisampleCoverageNV_ovr_0(texture, target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations);
end;
end;
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);
public z_BeginTransformFeedbackNV_adr := GetFuncAdr('glBeginTransformFeedbackNV');
public z_BeginTransformFeedbackNV_ovr_0 := GetFuncOrNil&<procedure(primitiveMode: PrimitiveType)>(z_BeginTransformFeedbackNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginTransformFeedbackNV(primitiveMode: PrimitiveType);
begin
z_BeginTransformFeedbackNV_ovr_0(primitiveMode);
end;
public z_EndTransformFeedbackNV_adr := GetFuncAdr('glEndTransformFeedbackNV');
public z_EndTransformFeedbackNV_ovr_0 := GetFuncOrNil&<procedure>(z_EndTransformFeedbackNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndTransformFeedbackNV;
begin
z_EndTransformFeedbackNV_ovr_0;
end;
public z_TransformFeedbackAttribsNV_adr := GetFuncAdr('glTransformFeedbackAttribsNV');
public z_TransformFeedbackAttribsNV_ovr_0 := GetFuncOrNil&<procedure(count: Int32; var attribs: Int32; bufferMode: DummyEnum)>(z_TransformFeedbackAttribsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackAttribsNV(count: Int32; attribs: array of Int32; bufferMode: DummyEnum);
begin
z_TransformFeedbackAttribsNV_ovr_0(count, attribs[0], bufferMode);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackAttribsNV(count: Int32; var attribs: Int32; bufferMode: DummyEnum);
begin
z_TransformFeedbackAttribsNV_ovr_0(count, attribs, bufferMode);
end;
public z_TransformFeedbackAttribsNV_ovr_2 := GetFuncOrNil&<procedure(count: Int32; attribs: IntPtr; bufferMode: DummyEnum)>(z_TransformFeedbackAttribsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackAttribsNV(count: Int32; attribs: IntPtr; bufferMode: DummyEnum);
begin
z_TransformFeedbackAttribsNV_ovr_2(count, attribs, bufferMode);
end;
public z_BindBufferRangeNV_adr := GetFuncAdr('glBindBufferRangeNV');
public z_BindBufferRangeNV_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; buffer: UInt32; offset: IntPtr; size: IntPtr)>(z_BindBufferRangeNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferRangeNV(target: BufferTargetARB; index: UInt32; buffer: UInt32; offset: IntPtr; size: IntPtr);
begin
z_BindBufferRangeNV_ovr_0(target, index, buffer, offset, size);
end;
public z_BindBufferOffsetNV_adr := GetFuncAdr('glBindBufferOffsetNV');
public z_BindBufferOffsetNV_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; buffer: UInt32; offset: IntPtr)>(z_BindBufferOffsetNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferOffsetNV(target: BufferTargetARB; index: UInt32; buffer: UInt32; offset: IntPtr);
begin
z_BindBufferOffsetNV_ovr_0(target, index, buffer, offset);
end;
public z_BindBufferBaseNV_adr := GetFuncAdr('glBindBufferBaseNV');
public z_BindBufferBaseNV_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; buffer: UInt32)>(z_BindBufferBaseNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferBaseNV(target: BufferTargetARB; index: UInt32; buffer: UInt32);
begin
z_BindBufferBaseNV_ovr_0(target, index, buffer);
end;
public z_TransformFeedbackVaryingsNV_adr := GetFuncAdr('glTransformFeedbackVaryingsNV');
public z_TransformFeedbackVaryingsNV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; count: Int32; var locations: Int32; bufferMode: DummyEnum)>(z_TransformFeedbackVaryingsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackVaryingsNV(&program: UInt32; count: Int32; locations: array of Int32; bufferMode: DummyEnum);
begin
z_TransformFeedbackVaryingsNV_ovr_0(&program, count, locations[0], bufferMode);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackVaryingsNV(&program: UInt32; count: Int32; var locations: Int32; bufferMode: DummyEnum);
begin
z_TransformFeedbackVaryingsNV_ovr_0(&program, count, locations, bufferMode);
end;
public z_TransformFeedbackVaryingsNV_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; count: Int32; locations: IntPtr; bufferMode: DummyEnum)>(z_TransformFeedbackVaryingsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackVaryingsNV(&program: UInt32; count: Int32; locations: IntPtr; bufferMode: DummyEnum);
begin
z_TransformFeedbackVaryingsNV_ovr_2(&program, count, locations, bufferMode);
end;
public z_ActiveVaryingNV_adr := GetFuncAdr('glActiveVaryingNV');
public z_ActiveVaryingNV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; name: IntPtr)>(z_ActiveVaryingNV_adr);
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);
begin
z_ActiveVaryingNV_ovr_0(&program, name);
end;
public z_GetVaryingLocationNV_adr := GetFuncAdr('glGetVaryingLocationNV');
public z_GetVaryingLocationNV_ovr_0 := GetFuncOrNil&<function(&program: UInt32; name: IntPtr): Int32>(z_GetVaryingLocationNV_adr);
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;
begin
Result := z_GetVaryingLocationNV_ovr_0(&program, name);
end;
public z_GetActiveVaryingNV_adr := GetFuncAdr('glGetActiveVaryingNV');
public z_GetActiveVaryingNV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; var &type: DummyEnum; name: IntPtr)>(z_GetActiveVaryingNV_adr);
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);
begin
z_GetActiveVaryingNV_ovr_0(&program, index, bufSize, length[0], size[0], &type[0], name);
end;
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);
begin
z_GetActiveVaryingNV_ovr_0(&program, index, bufSize, length[0], size[0], &type, name);
end;
public z_GetActiveVaryingNV_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetActiveVaryingNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: array of Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveVaryingNV_ovr_2(&program, index, bufSize, length[0], size[0], &type, name);
end;
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);
begin
z_GetActiveVaryingNV_ovr_0(&program, index, bufSize, length[0], size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; var size: Int32; var &type: DummyEnum; name: IntPtr);
begin
z_GetActiveVaryingNV_ovr_0(&program, index, bufSize, length[0], size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; var size: Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveVaryingNV_ovr_2(&program, index, bufSize, length[0], size, &type, name);
end;
public z_GetActiveVaryingNV_ovr_6 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; var &type: DummyEnum; name: IntPtr)>(z_GetActiveVaryingNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: IntPtr; &type: array of DummyEnum; name: IntPtr);
begin
z_GetActiveVaryingNV_ovr_6(&program, index, bufSize, length[0], size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: IntPtr; var &type: DummyEnum; name: IntPtr);
begin
z_GetActiveVaryingNV_ovr_6(&program, index, bufSize, length[0], size, &type, name);
end;
public z_GetActiveVaryingNV_ovr_8 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveVaryingNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: array of Int32; size: IntPtr; &type: IntPtr; name: IntPtr);
begin
z_GetActiveVaryingNV_ovr_8(&program, index, bufSize, length[0], size, &type, name);
end;
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);
begin
z_GetActiveVaryingNV_ovr_0(&program, index, bufSize, length, size[0], &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: array of Int32; var &type: DummyEnum; name: IntPtr);
begin
z_GetActiveVaryingNV_ovr_0(&program, index, bufSize, length, size[0], &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: array of Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveVaryingNV_ovr_2(&program, index, bufSize, length, size[0], &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: array of DummyEnum; name: IntPtr);
begin
z_GetActiveVaryingNV_ovr_0(&program, index, bufSize, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; var &type: DummyEnum; name: IntPtr);
begin
z_GetActiveVaryingNV_ovr_0(&program, index, bufSize, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; var size: Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveVaryingNV_ovr_2(&program, index, bufSize, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: array of DummyEnum; name: IntPtr);
begin
z_GetActiveVaryingNV_ovr_6(&program, index, bufSize, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; var &type: DummyEnum; name: IntPtr);
begin
z_GetActiveVaryingNV_ovr_6(&program, index, bufSize, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; var length: Int32; size: IntPtr; &type: IntPtr; name: IntPtr);
begin
z_GetActiveVaryingNV_ovr_8(&program, index, bufSize, length, size, &type, name);
end;
public z_GetActiveVaryingNV_ovr_18 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: DummyEnum; name: IntPtr)>(z_GetActiveVaryingNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: array of Int32; &type: array of DummyEnum; name: IntPtr);
begin
z_GetActiveVaryingNV_ovr_18(&program, index, bufSize, length, size[0], &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: array of Int32; var &type: DummyEnum; name: IntPtr);
begin
z_GetActiveVaryingNV_ovr_18(&program, index, bufSize, length, size[0], &type, name);
end;
public z_GetActiveVaryingNV_ovr_20 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr)>(z_GetActiveVaryingNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: array of Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveVaryingNV_ovr_20(&program, index, bufSize, length, size[0], &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: array of DummyEnum; name: IntPtr);
begin
z_GetActiveVaryingNV_ovr_18(&program, index, bufSize, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; var &type: DummyEnum; name: IntPtr);
begin
z_GetActiveVaryingNV_ovr_18(&program, index, bufSize, length, size, &type, name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; var size: Int32; &type: IntPtr; name: IntPtr);
begin
z_GetActiveVaryingNV_ovr_20(&program, index, bufSize, length, size, &type, name);
end;
public z_GetActiveVaryingNV_ovr_24 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: DummyEnum; name: IntPtr)>(z_GetActiveVaryingNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: array of DummyEnum; name: IntPtr);
begin
z_GetActiveVaryingNV_ovr_24(&program, index, bufSize, length, size, &type[0], name);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; var &type: DummyEnum; name: IntPtr);
begin
z_GetActiveVaryingNV_ovr_24(&program, index, bufSize, length, size, &type, name);
end;
public z_GetActiveVaryingNV_ovr_26 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr)>(z_GetActiveVaryingNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetActiveVaryingNV(&program: UInt32; index: UInt32; bufSize: Int32; length: IntPtr; size: IntPtr; &type: IntPtr; name: IntPtr);
begin
z_GetActiveVaryingNV_ovr_26(&program, index, bufSize, length, size, &type, name);
end;
public z_GetTransformFeedbackVaryingNV_adr := GetFuncAdr('glGetTransformFeedbackVaryingNV');
public z_GetTransformFeedbackVaryingNV_ovr_0 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; var location: Int32)>(z_GetTransformFeedbackVaryingNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingNV(&program: UInt32; index: UInt32; location: array of Int32);
begin
z_GetTransformFeedbackVaryingNV_ovr_0(&program, index, location[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingNV(&program: UInt32; index: UInt32; var location: Int32);
begin
z_GetTransformFeedbackVaryingNV_ovr_0(&program, index, location);
end;
public z_GetTransformFeedbackVaryingNV_ovr_2 := GetFuncOrNil&<procedure(&program: UInt32; index: UInt32; location: IntPtr)>(z_GetTransformFeedbackVaryingNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTransformFeedbackVaryingNV(&program: UInt32; index: UInt32; location: IntPtr);
begin
z_GetTransformFeedbackVaryingNV_ovr_2(&program, index, location);
end;
public z_TransformFeedbackStreamAttribsNV_adr := GetFuncAdr('glTransformFeedbackStreamAttribsNV');
public z_TransformFeedbackStreamAttribsNV_ovr_0 := GetFuncOrNil&<procedure(count: Int32; var attribs: Int32; nbuffers: Int32; var bufstreams: Int32; bufferMode: DummyEnum)>(z_TransformFeedbackStreamAttribsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackStreamAttribsNV(count: Int32; attribs: array of Int32; nbuffers: Int32; bufstreams: array of Int32; bufferMode: DummyEnum);
begin
z_TransformFeedbackStreamAttribsNV_ovr_0(count, attribs[0], nbuffers, bufstreams[0], bufferMode);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackStreamAttribsNV(count: Int32; attribs: array of Int32; nbuffers: Int32; var bufstreams: Int32; bufferMode: DummyEnum);
begin
z_TransformFeedbackStreamAttribsNV_ovr_0(count, attribs[0], nbuffers, bufstreams, bufferMode);
end;
public z_TransformFeedbackStreamAttribsNV_ovr_2 := GetFuncOrNil&<procedure(count: Int32; var attribs: Int32; nbuffers: Int32; bufstreams: IntPtr; bufferMode: DummyEnum)>(z_TransformFeedbackStreamAttribsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackStreamAttribsNV(count: Int32; attribs: array of Int32; nbuffers: Int32; bufstreams: IntPtr; bufferMode: DummyEnum);
begin
z_TransformFeedbackStreamAttribsNV_ovr_2(count, attribs[0], nbuffers, bufstreams, bufferMode);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackStreamAttribsNV(count: Int32; var attribs: Int32; nbuffers: Int32; bufstreams: array of Int32; bufferMode: DummyEnum);
begin
z_TransformFeedbackStreamAttribsNV_ovr_0(count, attribs, nbuffers, bufstreams[0], bufferMode);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackStreamAttribsNV(count: Int32; var attribs: Int32; nbuffers: Int32; var bufstreams: Int32; bufferMode: DummyEnum);
begin
z_TransformFeedbackStreamAttribsNV_ovr_0(count, attribs, nbuffers, bufstreams, bufferMode);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackStreamAttribsNV(count: Int32; var attribs: Int32; nbuffers: Int32; bufstreams: IntPtr; bufferMode: DummyEnum);
begin
z_TransformFeedbackStreamAttribsNV_ovr_2(count, attribs, nbuffers, bufstreams, bufferMode);
end;
public z_TransformFeedbackStreamAttribsNV_ovr_6 := GetFuncOrNil&<procedure(count: Int32; attribs: IntPtr; nbuffers: Int32; var bufstreams: Int32; bufferMode: DummyEnum)>(z_TransformFeedbackStreamAttribsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackStreamAttribsNV(count: Int32; attribs: IntPtr; nbuffers: Int32; bufstreams: array of Int32; bufferMode: DummyEnum);
begin
z_TransformFeedbackStreamAttribsNV_ovr_6(count, attribs, nbuffers, bufstreams[0], bufferMode);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackStreamAttribsNV(count: Int32; attribs: IntPtr; nbuffers: Int32; var bufstreams: Int32; bufferMode: DummyEnum);
begin
z_TransformFeedbackStreamAttribsNV_ovr_6(count, attribs, nbuffers, bufstreams, bufferMode);
end;
public z_TransformFeedbackStreamAttribsNV_ovr_8 := GetFuncOrNil&<procedure(count: Int32; attribs: IntPtr; nbuffers: Int32; bufstreams: IntPtr; bufferMode: DummyEnum)>(z_TransformFeedbackStreamAttribsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TransformFeedbackStreamAttribsNV(count: Int32; attribs: IntPtr; nbuffers: Int32; bufstreams: IntPtr; bufferMode: DummyEnum);
begin
z_TransformFeedbackStreamAttribsNV_ovr_8(count, attribs, nbuffers, bufstreams, bufferMode);
end;
end;
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);
public z_BindTransformFeedbackNV_adr := GetFuncAdr('glBindTransformFeedbackNV');
public z_BindTransformFeedbackNV_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; id: UInt32)>(z_BindTransformFeedbackNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindTransformFeedbackNV(target: BufferTargetARB; id: UInt32);
begin
z_BindTransformFeedbackNV_ovr_0(target, id);
end;
public z_DeleteTransformFeedbacksNV_adr := GetFuncAdr('glDeleteTransformFeedbacksNV');
public z_DeleteTransformFeedbacksNV_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var ids: UInt32)>(z_DeleteTransformFeedbacksNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteTransformFeedbacksNV(n: Int32; ids: array of UInt32);
begin
z_DeleteTransformFeedbacksNV_ovr_0(n, ids[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteTransformFeedbacksNV(n: Int32; var ids: UInt32);
begin
z_DeleteTransformFeedbacksNV_ovr_0(n, ids);
end;
public z_DeleteTransformFeedbacksNV_ovr_2 := GetFuncOrNil&<procedure(n: Int32; ids: IntPtr)>(z_DeleteTransformFeedbacksNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteTransformFeedbacksNV(n: Int32; ids: IntPtr);
begin
z_DeleteTransformFeedbacksNV_ovr_2(n, ids);
end;
public z_GenTransformFeedbacksNV_adr := GetFuncAdr('glGenTransformFeedbacksNV');
public z_GenTransformFeedbacksNV_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var ids: UInt32)>(z_GenTransformFeedbacksNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenTransformFeedbacksNV(n: Int32; ids: array of UInt32);
begin
z_GenTransformFeedbacksNV_ovr_0(n, ids[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenTransformFeedbacksNV(n: Int32; var ids: UInt32);
begin
z_GenTransformFeedbacksNV_ovr_0(n, ids);
end;
public z_GenTransformFeedbacksNV_ovr_2 := GetFuncOrNil&<procedure(n: Int32; ids: IntPtr)>(z_GenTransformFeedbacksNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenTransformFeedbacksNV(n: Int32; ids: IntPtr);
begin
z_GenTransformFeedbacksNV_ovr_2(n, ids);
end;
public z_IsTransformFeedbackNV_adr := GetFuncAdr('glIsTransformFeedbackNV');
public z_IsTransformFeedbackNV_ovr_0 := GetFuncOrNil&<function(id: UInt32): boolean>(z_IsTransformFeedbackNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsTransformFeedbackNV(id: UInt32): boolean;
begin
Result := z_IsTransformFeedbackNV_ovr_0(id);
end;
public z_PauseTransformFeedbackNV_adr := GetFuncAdr('glPauseTransformFeedbackNV');
public z_PauseTransformFeedbackNV_ovr_0 := GetFuncOrNil&<procedure>(z_PauseTransformFeedbackNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PauseTransformFeedbackNV;
begin
z_PauseTransformFeedbackNV_ovr_0;
end;
public z_ResumeTransformFeedbackNV_adr := GetFuncAdr('glResumeTransformFeedbackNV');
public z_ResumeTransformFeedbackNV_ovr_0 := GetFuncOrNil&<procedure>(z_ResumeTransformFeedbackNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ResumeTransformFeedbackNV;
begin
z_ResumeTransformFeedbackNV_ovr_0;
end;
public z_DrawTransformFeedbackNV_adr := GetFuncAdr('glDrawTransformFeedbackNV');
public z_DrawTransformFeedbackNV_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; id: UInt32)>(z_DrawTransformFeedbackNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawTransformFeedbackNV(mode: PrimitiveType; id: UInt32);
begin
z_DrawTransformFeedbackNV_ovr_0(mode, id);
end;
end;
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);
public z_VDPAUInitNV_adr := GetFuncAdr('glVDPAUInitNV');
public z_VDPAUInitNV_ovr_0 := GetFuncOrNil&<procedure(vdpDevice: IntPtr; getProcAddress: IntPtr)>(z_VDPAUInitNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUInitNV(vdpDevice: IntPtr; getProcAddress: IntPtr);
begin
z_VDPAUInitNV_ovr_0(vdpDevice, getProcAddress);
end;
public z_VDPAUFiniNV_adr := GetFuncAdr('glVDPAUFiniNV');
public z_VDPAUFiniNV_ovr_0 := GetFuncOrNil&<procedure>(z_VDPAUFiniNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUFiniNV;
begin
z_VDPAUFiniNV_ovr_0;
end;
public z_VDPAURegisterVideoSurfaceNV_adr := GetFuncAdr('glVDPAURegisterVideoSurfaceNV');
public z_VDPAURegisterVideoSurfaceNV_ovr_0 := GetFuncOrNil&<function(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; var textureNames: UInt32): GLvdpauSurfaceNV>(z_VDPAURegisterVideoSurfaceNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VDPAURegisterVideoSurfaceNV(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; textureNames: array of UInt32): GLvdpauSurfaceNV;
begin
Result := z_VDPAURegisterVideoSurfaceNV_ovr_0(vdpSurface, target, numTextureNames, textureNames[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VDPAURegisterVideoSurfaceNV(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; var textureNames: UInt32): GLvdpauSurfaceNV;
begin
Result := z_VDPAURegisterVideoSurfaceNV_ovr_0(vdpSurface, target, numTextureNames, textureNames);
end;
public z_VDPAURegisterVideoSurfaceNV_ovr_2 := GetFuncOrNil&<function(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; textureNames: IntPtr): GLvdpauSurfaceNV>(z_VDPAURegisterVideoSurfaceNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VDPAURegisterVideoSurfaceNV(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; textureNames: IntPtr): GLvdpauSurfaceNV;
begin
Result := z_VDPAURegisterVideoSurfaceNV_ovr_2(vdpSurface, target, numTextureNames, textureNames);
end;
public z_VDPAURegisterOutputSurfaceNV_adr := GetFuncAdr('glVDPAURegisterOutputSurfaceNV');
public z_VDPAURegisterOutputSurfaceNV_ovr_0 := GetFuncOrNil&<function(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; var textureNames: UInt32): GLvdpauSurfaceNV>(z_VDPAURegisterOutputSurfaceNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VDPAURegisterOutputSurfaceNV(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; textureNames: array of UInt32): GLvdpauSurfaceNV;
begin
Result := z_VDPAURegisterOutputSurfaceNV_ovr_0(vdpSurface, target, numTextureNames, textureNames[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VDPAURegisterOutputSurfaceNV(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; var textureNames: UInt32): GLvdpauSurfaceNV;
begin
Result := z_VDPAURegisterOutputSurfaceNV_ovr_0(vdpSurface, target, numTextureNames, textureNames);
end;
public z_VDPAURegisterOutputSurfaceNV_ovr_2 := GetFuncOrNil&<function(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; textureNames: IntPtr): GLvdpauSurfaceNV>(z_VDPAURegisterOutputSurfaceNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VDPAURegisterOutputSurfaceNV(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; textureNames: IntPtr): GLvdpauSurfaceNV;
begin
Result := z_VDPAURegisterOutputSurfaceNV_ovr_2(vdpSurface, target, numTextureNames, textureNames);
end;
public z_VDPAUIsSurfaceNV_adr := GetFuncAdr('glVDPAUIsSurfaceNV');
public z_VDPAUIsSurfaceNV_ovr_0 := GetFuncOrNil&<function(surface: GLvdpauSurfaceNV): boolean>(z_VDPAUIsSurfaceNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VDPAUIsSurfaceNV(surface: GLvdpauSurfaceNV): boolean;
begin
Result := z_VDPAUIsSurfaceNV_ovr_0(surface);
end;
public z_VDPAUUnregisterSurfaceNV_adr := GetFuncAdr('glVDPAUUnregisterSurfaceNV');
public z_VDPAUUnregisterSurfaceNV_ovr_0 := GetFuncOrNil&<procedure(surface: GLvdpauSurfaceNV)>(z_VDPAUUnregisterSurfaceNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUUnregisterSurfaceNV(surface: GLvdpauSurfaceNV);
begin
z_VDPAUUnregisterSurfaceNV_ovr_0(surface);
end;
public z_VDPAUGetSurfaceivNV_adr := GetFuncAdr('glVDPAUGetSurfaceivNV');
public z_VDPAUGetSurfaceivNV_ovr_0 := GetFuncOrNil&<procedure(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; var length: Int32; var values: Int32)>(z_VDPAUGetSurfaceivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUGetSurfaceivNV(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; length: array of Int32; values: array of Int32);
begin
z_VDPAUGetSurfaceivNV_ovr_0(surface, pname, count, length[0], values[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUGetSurfaceivNV(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; length: array of Int32; var values: Int32);
begin
z_VDPAUGetSurfaceivNV_ovr_0(surface, pname, count, length[0], values);
end;
public z_VDPAUGetSurfaceivNV_ovr_2 := GetFuncOrNil&<procedure(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; var length: Int32; values: IntPtr)>(z_VDPAUGetSurfaceivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUGetSurfaceivNV(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; length: array of Int32; values: IntPtr);
begin
z_VDPAUGetSurfaceivNV_ovr_2(surface, pname, count, length[0], values);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUGetSurfaceivNV(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; var length: Int32; values: array of Int32);
begin
z_VDPAUGetSurfaceivNV_ovr_0(surface, pname, count, length, values[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUGetSurfaceivNV(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; var length: Int32; var values: Int32);
begin
z_VDPAUGetSurfaceivNV_ovr_0(surface, pname, count, length, values);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUGetSurfaceivNV(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; var length: Int32; values: IntPtr);
begin
z_VDPAUGetSurfaceivNV_ovr_2(surface, pname, count, length, values);
end;
public z_VDPAUGetSurfaceivNV_ovr_6 := GetFuncOrNil&<procedure(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; length: IntPtr; var values: Int32)>(z_VDPAUGetSurfaceivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUGetSurfaceivNV(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; length: IntPtr; values: array of Int32);
begin
z_VDPAUGetSurfaceivNV_ovr_6(surface, pname, count, length, values[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUGetSurfaceivNV(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; length: IntPtr; var values: Int32);
begin
z_VDPAUGetSurfaceivNV_ovr_6(surface, pname, count, length, values);
end;
public z_VDPAUGetSurfaceivNV_ovr_8 := GetFuncOrNil&<procedure(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; length: IntPtr; values: IntPtr)>(z_VDPAUGetSurfaceivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUGetSurfaceivNV(surface: GLvdpauSurfaceNV; pname: DummyEnum; count: Int32; length: IntPtr; values: IntPtr);
begin
z_VDPAUGetSurfaceivNV_ovr_8(surface, pname, count, length, values);
end;
public z_VDPAUSurfaceAccessNV_adr := GetFuncAdr('glVDPAUSurfaceAccessNV');
public z_VDPAUSurfaceAccessNV_ovr_0 := GetFuncOrNil&<procedure(surface: GLvdpauSurfaceNV; access: DummyEnum)>(z_VDPAUSurfaceAccessNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUSurfaceAccessNV(surface: GLvdpauSurfaceNV; access: DummyEnum);
begin
z_VDPAUSurfaceAccessNV_ovr_0(surface, access);
end;
public z_VDPAUMapSurfacesNV_adr := GetFuncAdr('glVDPAUMapSurfacesNV');
public z_VDPAUMapSurfacesNV_ovr_0 := GetFuncOrNil&<procedure(numSurfaces: Int32; var surfaces: GLvdpauSurfaceNV)>(z_VDPAUMapSurfacesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUMapSurfacesNV(numSurfaces: Int32; surfaces: array of GLvdpauSurfaceNV);
begin
z_VDPAUMapSurfacesNV_ovr_0(numSurfaces, surfaces[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUMapSurfacesNV(numSurfaces: Int32; var surfaces: GLvdpauSurfaceNV);
begin
z_VDPAUMapSurfacesNV_ovr_0(numSurfaces, surfaces);
end;
public z_VDPAUMapSurfacesNV_ovr_2 := GetFuncOrNil&<procedure(numSurfaces: Int32; surfaces: IntPtr)>(z_VDPAUMapSurfacesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUMapSurfacesNV(numSurfaces: Int32; surfaces: IntPtr);
begin
z_VDPAUMapSurfacesNV_ovr_2(numSurfaces, surfaces);
end;
public z_VDPAUUnmapSurfacesNV_adr := GetFuncAdr('glVDPAUUnmapSurfacesNV');
public z_VDPAUUnmapSurfacesNV_ovr_0 := GetFuncOrNil&<procedure(numSurface: Int32; var surfaces: GLvdpauSurfaceNV)>(z_VDPAUUnmapSurfacesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUUnmapSurfacesNV(numSurface: Int32; surfaces: array of GLvdpauSurfaceNV);
begin
z_VDPAUUnmapSurfacesNV_ovr_0(numSurface, surfaces[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUUnmapSurfacesNV(numSurface: Int32; var surfaces: GLvdpauSurfaceNV);
begin
z_VDPAUUnmapSurfacesNV_ovr_0(numSurface, surfaces);
end;
public z_VDPAUUnmapSurfacesNV_ovr_2 := GetFuncOrNil&<procedure(numSurface: Int32; surfaces: IntPtr)>(z_VDPAUUnmapSurfacesNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VDPAUUnmapSurfacesNV(numSurface: Int32; surfaces: IntPtr);
begin
z_VDPAUUnmapSurfacesNV_ovr_2(numSurface, surfaces);
end;
end;
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);
public z_VDPAURegisterVideoSurfaceWithPictureStructureNV_adr := GetFuncAdr('glVDPAURegisterVideoSurfaceWithPictureStructureNV');
public z_VDPAURegisterVideoSurfaceWithPictureStructureNV_ovr_0 := GetFuncOrNil&<function(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; var textureNames: UInt32; isFrameStructure: boolean): GLvdpauSurfaceNV>(z_VDPAURegisterVideoSurfaceWithPictureStructureNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VDPAURegisterVideoSurfaceWithPictureStructureNV(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; textureNames: array of UInt32; isFrameStructure: boolean): GLvdpauSurfaceNV;
begin
Result := z_VDPAURegisterVideoSurfaceWithPictureStructureNV_ovr_0(vdpSurface, target, numTextureNames, textureNames[0], isFrameStructure);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VDPAURegisterVideoSurfaceWithPictureStructureNV(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; var textureNames: UInt32; isFrameStructure: boolean): GLvdpauSurfaceNV;
begin
Result := z_VDPAURegisterVideoSurfaceWithPictureStructureNV_ovr_0(vdpSurface, target, numTextureNames, textureNames, isFrameStructure);
end;
public z_VDPAURegisterVideoSurfaceWithPictureStructureNV_ovr_2 := GetFuncOrNil&<function(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; textureNames: IntPtr; isFrameStructure: boolean): GLvdpauSurfaceNV>(z_VDPAURegisterVideoSurfaceWithPictureStructureNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VDPAURegisterVideoSurfaceWithPictureStructureNV(vdpSurface: IntPtr; target: DummyEnum; numTextureNames: Int32; textureNames: IntPtr; isFrameStructure: boolean): GLvdpauSurfaceNV;
begin
Result := z_VDPAURegisterVideoSurfaceWithPictureStructureNV_ovr_2(vdpSurface, target, numTextureNames, textureNames, isFrameStructure);
end;
end;
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);
public z_FlushVertexArrayRangeNV_adr := GetFuncAdr('glFlushVertexArrayRangeNV');
public z_FlushVertexArrayRangeNV_ovr_0 := GetFuncOrNil&<procedure>(z_FlushVertexArrayRangeNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FlushVertexArrayRangeNV;
begin
z_FlushVertexArrayRangeNV_ovr_0;
end;
public z_VertexArrayRangeNV_adr := GetFuncAdr('glVertexArrayRangeNV');
public z_VertexArrayRangeNV_ovr_0 := GetFuncOrNil&<procedure(length: Int32; pointer: IntPtr)>(z_VertexArrayRangeNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexArrayRangeNV(length: Int32; pointer: IntPtr);
begin
z_VertexArrayRangeNV_ovr_0(length, pointer);
end;
end;
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);
public z_VertexAttribL1i64NV_adr := GetFuncAdr('glVertexAttribL1i64NV');
public z_VertexAttribL1i64NV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Int64)>(z_VertexAttribL1i64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1i64NV(index: UInt32; x: Int64);
begin
z_VertexAttribL1i64NV_ovr_0(index, x);
end;
public z_VertexAttribL2i64NV_adr := GetFuncAdr('glVertexAttribL2i64NV');
public z_VertexAttribL2i64NV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Int64; y: Int64)>(z_VertexAttribL2i64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2i64NV(index: UInt32; x: Int64; y: Int64);
begin
z_VertexAttribL2i64NV_ovr_0(index, x, y);
end;
public z_VertexAttribL3i64NV_adr := GetFuncAdr('glVertexAttribL3i64NV');
public z_VertexAttribL3i64NV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Int64; y: Int64; z: Int64)>(z_VertexAttribL3i64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3i64NV(index: UInt32; x: Int64; y: Int64; z: Int64);
begin
z_VertexAttribL3i64NV_ovr_0(index, x, y, z);
end;
public z_VertexAttribL4i64NV_adr := GetFuncAdr('glVertexAttribL4i64NV');
public z_VertexAttribL4i64NV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Int64; y: Int64; z: Int64; w: Int64)>(z_VertexAttribL4i64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4i64NV(index: UInt32; x: Int64; y: Int64; z: Int64; w: Int64);
begin
z_VertexAttribL4i64NV_ovr_0(index, x, y, z, w);
end;
public z_VertexAttribL1i64vNV_adr := GetFuncAdr('glVertexAttribL1i64vNV');
public z_VertexAttribL1i64vNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int64)>(z_VertexAttribL1i64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1i64vNV(index: UInt32; v: array of Int64);
begin
z_VertexAttribL1i64vNV_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1i64vNV(index: UInt32; var v: Int64);
begin
z_VertexAttribL1i64vNV_ovr_0(index, v);
end;
public z_VertexAttribL1i64vNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribL1i64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1i64vNV(index: UInt32; v: IntPtr);
begin
z_VertexAttribL1i64vNV_ovr_2(index, v);
end;
public z_VertexAttribL2i64vNV_adr := GetFuncAdr('glVertexAttribL2i64vNV');
public z_VertexAttribL2i64vNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int64)>(z_VertexAttribL2i64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2i64vNV(index: UInt32; v: array of Int64);
begin
z_VertexAttribL2i64vNV_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2i64vNV(index: UInt32; var v: Int64);
begin
z_VertexAttribL2i64vNV_ovr_0(index, v);
end;
public z_VertexAttribL2i64vNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribL2i64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2i64vNV(index: UInt32; v: IntPtr);
begin
z_VertexAttribL2i64vNV_ovr_2(index, v);
end;
public z_VertexAttribL3i64vNV_adr := GetFuncAdr('glVertexAttribL3i64vNV');
public z_VertexAttribL3i64vNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int64)>(z_VertexAttribL3i64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3i64vNV(index: UInt32; v: array of Int64);
begin
z_VertexAttribL3i64vNV_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3i64vNV(index: UInt32; var v: Int64);
begin
z_VertexAttribL3i64vNV_ovr_0(index, v);
end;
public z_VertexAttribL3i64vNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribL3i64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3i64vNV(index: UInt32; v: IntPtr);
begin
z_VertexAttribL3i64vNV_ovr_2(index, v);
end;
public z_VertexAttribL4i64vNV_adr := GetFuncAdr('glVertexAttribL4i64vNV');
public z_VertexAttribL4i64vNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int64)>(z_VertexAttribL4i64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4i64vNV(index: UInt32; v: array of Int64);
begin
z_VertexAttribL4i64vNV_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4i64vNV(index: UInt32; var v: Int64);
begin
z_VertexAttribL4i64vNV_ovr_0(index, v);
end;
public z_VertexAttribL4i64vNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribL4i64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4i64vNV(index: UInt32; v: IntPtr);
begin
z_VertexAttribL4i64vNV_ovr_2(index, v);
end;
public z_VertexAttribL1ui64NV_adr := GetFuncAdr('glVertexAttribL1ui64NV');
public z_VertexAttribL1ui64NV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: UInt64)>(z_VertexAttribL1ui64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1ui64NV(index: UInt32; x: UInt64);
begin
z_VertexAttribL1ui64NV_ovr_0(index, x);
end;
public z_VertexAttribL2ui64NV_adr := GetFuncAdr('glVertexAttribL2ui64NV');
public z_VertexAttribL2ui64NV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: UInt64; y: UInt64)>(z_VertexAttribL2ui64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2ui64NV(index: UInt32; x: UInt64; y: UInt64);
begin
z_VertexAttribL2ui64NV_ovr_0(index, x, y);
end;
public z_VertexAttribL3ui64NV_adr := GetFuncAdr('glVertexAttribL3ui64NV');
public z_VertexAttribL3ui64NV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: UInt64; y: UInt64; z: UInt64)>(z_VertexAttribL3ui64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3ui64NV(index: UInt32; x: UInt64; y: UInt64; z: UInt64);
begin
z_VertexAttribL3ui64NV_ovr_0(index, x, y, z);
end;
public z_VertexAttribL4ui64NV_adr := GetFuncAdr('glVertexAttribL4ui64NV');
public z_VertexAttribL4ui64NV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: UInt64; y: UInt64; z: UInt64; w: UInt64)>(z_VertexAttribL4ui64NV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4ui64NV(index: UInt32; x: UInt64; y: UInt64; z: UInt64; w: UInt64);
begin
z_VertexAttribL4ui64NV_ovr_0(index, x, y, z, w);
end;
public z_VertexAttribL1ui64vNV_adr := GetFuncAdr('glVertexAttribL1ui64vNV');
public z_VertexAttribL1ui64vNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt64)>(z_VertexAttribL1ui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1ui64vNV(index: UInt32; v: array of UInt64);
begin
z_VertexAttribL1ui64vNV_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1ui64vNV(index: UInt32; var v: UInt64);
begin
z_VertexAttribL1ui64vNV_ovr_0(index, v);
end;
public z_VertexAttribL1ui64vNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribL1ui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL1ui64vNV(index: UInt32; v: IntPtr);
begin
z_VertexAttribL1ui64vNV_ovr_2(index, v);
end;
public z_VertexAttribL2ui64vNV_adr := GetFuncAdr('glVertexAttribL2ui64vNV');
public z_VertexAttribL2ui64vNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt64)>(z_VertexAttribL2ui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2ui64vNV(index: UInt32; v: array of UInt64);
begin
z_VertexAttribL2ui64vNV_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2ui64vNV(index: UInt32; var v: UInt64);
begin
z_VertexAttribL2ui64vNV_ovr_0(index, v);
end;
public z_VertexAttribL2ui64vNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribL2ui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL2ui64vNV(index: UInt32; v: IntPtr);
begin
z_VertexAttribL2ui64vNV_ovr_2(index, v);
end;
public z_VertexAttribL3ui64vNV_adr := GetFuncAdr('glVertexAttribL3ui64vNV');
public z_VertexAttribL3ui64vNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt64)>(z_VertexAttribL3ui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3ui64vNV(index: UInt32; v: array of UInt64);
begin
z_VertexAttribL3ui64vNV_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3ui64vNV(index: UInt32; var v: UInt64);
begin
z_VertexAttribL3ui64vNV_ovr_0(index, v);
end;
public z_VertexAttribL3ui64vNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribL3ui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL3ui64vNV(index: UInt32; v: IntPtr);
begin
z_VertexAttribL3ui64vNV_ovr_2(index, v);
end;
public z_VertexAttribL4ui64vNV_adr := GetFuncAdr('glVertexAttribL4ui64vNV');
public z_VertexAttribL4ui64vNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: UInt64)>(z_VertexAttribL4ui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4ui64vNV(index: UInt32; v: array of UInt64);
begin
z_VertexAttribL4ui64vNV_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4ui64vNV(index: UInt32; var v: UInt64);
begin
z_VertexAttribL4ui64vNV_ovr_0(index, v);
end;
public z_VertexAttribL4ui64vNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttribL4ui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribL4ui64vNV(index: UInt32; v: IntPtr);
begin
z_VertexAttribL4ui64vNV_ovr_2(index, v);
end;
public z_GetVertexAttribLi64vNV_adr := GetFuncAdr('glGetVertexAttribLi64vNV');
public z_GetVertexAttribLi64vNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnum; var ¶ms: Int64)>(z_GetVertexAttribLi64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLi64vNV(index: UInt32; pname: VertexAttribEnum; ¶ms: array of Int64);
begin
z_GetVertexAttribLi64vNV_ovr_0(index, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLi64vNV(index: UInt32; pname: VertexAttribEnum; var ¶ms: Int64);
begin
z_GetVertexAttribLi64vNV_ovr_0(index, pname, ¶ms);
end;
public z_GetVertexAttribLi64vNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr)>(z_GetVertexAttribLi64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLi64vNV(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr);
begin
z_GetVertexAttribLi64vNV_ovr_2(index, pname, ¶ms);
end;
public z_GetVertexAttribLui64vNV_adr := GetFuncAdr('glGetVertexAttribLui64vNV');
public z_GetVertexAttribLui64vNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnum; var ¶ms: UInt64)>(z_GetVertexAttribLui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLui64vNV(index: UInt32; pname: VertexAttribEnum; ¶ms: array of UInt64);
begin
z_GetVertexAttribLui64vNV_ovr_0(index, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLui64vNV(index: UInt32; pname: VertexAttribEnum; var ¶ms: UInt64);
begin
z_GetVertexAttribLui64vNV_ovr_0(index, pname, ¶ms);
end;
public z_GetVertexAttribLui64vNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr)>(z_GetVertexAttribLui64vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribLui64vNV(index: UInt32; pname: VertexAttribEnum; ¶ms: IntPtr);
begin
z_GetVertexAttribLui64vNV_ovr_2(index, pname, ¶ms);
end;
public z_VertexAttribLFormatNV_adr := GetFuncAdr('glVertexAttribLFormatNV');
public z_VertexAttribLFormatNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; size: Int32; &type: VertexAttribLType; stride: Int32)>(z_VertexAttribLFormatNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribLFormatNV(index: UInt32; size: Int32; &type: VertexAttribLType; stride: Int32);
begin
z_VertexAttribLFormatNV_ovr_0(index, size, &type, stride);
end;
end;
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);
public z_BufferAddressRangeNV_adr := GetFuncAdr('glBufferAddressRangeNV');
public z_BufferAddressRangeNV_ovr_0 := GetFuncOrNil&<procedure(pname: DummyEnum; index: UInt32; address: UInt64; length: IntPtr)>(z_BufferAddressRangeNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferAddressRangeNV(pname: DummyEnum; index: UInt32; address: UInt64; length: IntPtr);
begin
z_BufferAddressRangeNV_ovr_0(pname, index, address, length);
end;
public z_VertexFormatNV_adr := GetFuncAdr('glVertexFormatNV');
public z_VertexFormatNV_ovr_0 := GetFuncOrNil&<procedure(size: Int32; &type: VertexPointerType; stride: Int32)>(z_VertexFormatNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexFormatNV(size: Int32; &type: VertexPointerType; stride: Int32);
begin
z_VertexFormatNV_ovr_0(size, &type, stride);
end;
public z_NormalFormatNV_adr := GetFuncAdr('glNormalFormatNV');
public z_NormalFormatNV_ovr_0 := GetFuncOrNil&<procedure(&type: DummyEnum; stride: Int32)>(z_NormalFormatNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NormalFormatNV(&type: DummyEnum; stride: Int32);
begin
z_NormalFormatNV_ovr_0(&type, stride);
end;
public z_ColorFormatNV_adr := GetFuncAdr('glColorFormatNV');
public z_ColorFormatNV_ovr_0 := GetFuncOrNil&<procedure(size: Int32; &type: DummyEnum; stride: Int32)>(z_ColorFormatNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorFormatNV(size: Int32; &type: DummyEnum; stride: Int32);
begin
z_ColorFormatNV_ovr_0(size, &type, stride);
end;
public z_IndexFormatNV_adr := GetFuncAdr('glIndexFormatNV');
public z_IndexFormatNV_ovr_0 := GetFuncOrNil&<procedure(&type: DummyEnum; stride: Int32)>(z_IndexFormatNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IndexFormatNV(&type: DummyEnum; stride: Int32);
begin
z_IndexFormatNV_ovr_0(&type, stride);
end;
public z_TexCoordFormatNV_adr := GetFuncAdr('glTexCoordFormatNV');
public z_TexCoordFormatNV_ovr_0 := GetFuncOrNil&<procedure(size: Int32; &type: DummyEnum; stride: Int32)>(z_TexCoordFormatNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoordFormatNV(size: Int32; &type: DummyEnum; stride: Int32);
begin
z_TexCoordFormatNV_ovr_0(size, &type, stride);
end;
public z_EdgeFlagFormatNV_adr := GetFuncAdr('glEdgeFlagFormatNV');
public z_EdgeFlagFormatNV_ovr_0 := GetFuncOrNil&<procedure(stride: Int32)>(z_EdgeFlagFormatNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EdgeFlagFormatNV(stride: Int32);
begin
z_EdgeFlagFormatNV_ovr_0(stride);
end;
public z_SecondaryColorFormatNV_adr := GetFuncAdr('glSecondaryColorFormatNV');
public z_SecondaryColorFormatNV_ovr_0 := GetFuncOrNil&<procedure(size: Int32; &type: ColorPointerType; stride: Int32)>(z_SecondaryColorFormatNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SecondaryColorFormatNV(size: Int32; &type: ColorPointerType; stride: Int32);
begin
z_SecondaryColorFormatNV_ovr_0(size, &type, stride);
end;
public z_FogCoordFormatNV_adr := GetFuncAdr('glFogCoordFormatNV');
public z_FogCoordFormatNV_ovr_0 := GetFuncOrNil&<procedure(&type: DummyEnum; stride: Int32)>(z_FogCoordFormatNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogCoordFormatNV(&type: DummyEnum; stride: Int32);
begin
z_FogCoordFormatNV_ovr_0(&type, stride);
end;
public z_VertexAttribFormatNV_adr := GetFuncAdr('glVertexAttribFormatNV');
public z_VertexAttribFormatNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; size: Int32; &type: VertexAttribType; normalized: boolean; stride: Int32)>(z_VertexAttribFormatNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribFormatNV(index: UInt32; size: Int32; &type: VertexAttribType; normalized: boolean; stride: Int32);
begin
z_VertexAttribFormatNV_ovr_0(index, size, &type, normalized, stride);
end;
public z_VertexAttribIFormatNV_adr := GetFuncAdr('glVertexAttribIFormatNV');
public z_VertexAttribIFormatNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; size: Int32; &type: VertexAttribIType; stride: Int32)>(z_VertexAttribIFormatNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribIFormatNV(index: UInt32; size: Int32; &type: VertexAttribIType; stride: Int32);
begin
z_VertexAttribIFormatNV_ovr_0(index, size, &type, stride);
end;
public z_GetIntegerui64i_vNV_adr := GetFuncAdr('glGetIntegerui64i_vNV');
public z_GetIntegerui64i_vNV_ovr_0 := GetFuncOrNil&<procedure(value: DummyEnum; index: UInt32; var result: UInt64)>(z_GetIntegerui64i_vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerui64i_vNV(value: DummyEnum; index: UInt32; result: array of UInt64);
begin
z_GetIntegerui64i_vNV_ovr_0(value, index, result[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerui64i_vNV(value: DummyEnum; index: UInt32; var result: UInt64);
begin
z_GetIntegerui64i_vNV_ovr_0(value, index, result);
end;
public z_GetIntegerui64i_vNV_ovr_2 := GetFuncOrNil&<procedure(value: DummyEnum; index: UInt32; result: IntPtr)>(z_GetIntegerui64i_vNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetIntegerui64i_vNV(value: DummyEnum; index: UInt32; result: IntPtr);
begin
z_GetIntegerui64i_vNV_ovr_2(value, index, result);
end;
end;
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);
public z_AreProgramsResidentNV_adr := GetFuncAdr('glAreProgramsResidentNV');
public z_AreProgramsResidentNV_ovr_0 := GetFuncOrNil&<function(n: Int32; var programs: UInt32; var residences: boolean): boolean>(z_AreProgramsResidentNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreProgramsResidentNV(n: Int32; programs: array of UInt32; residences: array of boolean): boolean;
begin
Result := z_AreProgramsResidentNV_ovr_0(n, programs[0], residences[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreProgramsResidentNV(n: Int32; programs: array of UInt32; var residences: boolean): boolean;
begin
Result := z_AreProgramsResidentNV_ovr_0(n, programs[0], residences);
end;
public z_AreProgramsResidentNV_ovr_2 := GetFuncOrNil&<function(n: Int32; var programs: UInt32; residences: IntPtr): boolean>(z_AreProgramsResidentNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreProgramsResidentNV(n: Int32; programs: array of UInt32; residences: IntPtr): boolean;
begin
Result := z_AreProgramsResidentNV_ovr_2(n, programs[0], residences);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreProgramsResidentNV(n: Int32; var programs: UInt32; residences: array of boolean): boolean;
begin
Result := z_AreProgramsResidentNV_ovr_0(n, programs, residences[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreProgramsResidentNV(n: Int32; var programs: UInt32; var residences: boolean): boolean;
begin
Result := z_AreProgramsResidentNV_ovr_0(n, programs, residences);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreProgramsResidentNV(n: Int32; var programs: UInt32; residences: IntPtr): boolean;
begin
Result := z_AreProgramsResidentNV_ovr_2(n, programs, residences);
end;
public z_AreProgramsResidentNV_ovr_6 := GetFuncOrNil&<function(n: Int32; programs: IntPtr; var residences: boolean): boolean>(z_AreProgramsResidentNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreProgramsResidentNV(n: Int32; programs: IntPtr; residences: array of boolean): boolean;
begin
Result := z_AreProgramsResidentNV_ovr_6(n, programs, residences[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreProgramsResidentNV(n: Int32; programs: IntPtr; var residences: boolean): boolean;
begin
Result := z_AreProgramsResidentNV_ovr_6(n, programs, residences);
end;
public z_AreProgramsResidentNV_ovr_8 := GetFuncOrNil&<function(n: Int32; programs: IntPtr; residences: IntPtr): boolean>(z_AreProgramsResidentNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function AreProgramsResidentNV(n: Int32; programs: IntPtr; residences: IntPtr): boolean;
begin
Result := z_AreProgramsResidentNV_ovr_8(n, programs, residences);
end;
public z_BindProgramNV_adr := GetFuncAdr('glBindProgramNV');
public z_BindProgramNV_ovr_0 := GetFuncOrNil&<procedure(target: VertexAttribEnumNV; id: UInt32)>(z_BindProgramNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindProgramNV(target: VertexAttribEnumNV; id: UInt32);
begin
z_BindProgramNV_ovr_0(target, id);
end;
public z_DeleteProgramsNV_adr := GetFuncAdr('glDeleteProgramsNV');
public z_DeleteProgramsNV_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var programs: UInt32)>(z_DeleteProgramsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgramsNV(n: Int32; programs: array of UInt32);
begin
z_DeleteProgramsNV_ovr_0(n, programs[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgramsNV(n: Int32; var programs: UInt32);
begin
z_DeleteProgramsNV_ovr_0(n, programs);
end;
public z_DeleteProgramsNV_ovr_2 := GetFuncOrNil&<procedure(n: Int32; programs: IntPtr)>(z_DeleteProgramsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteProgramsNV(n: Int32; programs: IntPtr);
begin
z_DeleteProgramsNV_ovr_2(n, programs);
end;
public z_ExecuteProgramNV_adr := GetFuncAdr('glExecuteProgramNV');
public z_ExecuteProgramNV_ovr_0 := GetFuncOrNil&<procedure(target: VertexAttribEnumNV; id: UInt32; var ¶ms: single)>(z_ExecuteProgramNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ExecuteProgramNV(target: VertexAttribEnumNV; id: UInt32; ¶ms: array of single);
begin
z_ExecuteProgramNV_ovr_0(target, id, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ExecuteProgramNV(target: VertexAttribEnumNV; id: UInt32; var ¶ms: single);
begin
z_ExecuteProgramNV_ovr_0(target, id, ¶ms);
end;
public z_ExecuteProgramNV_ovr_2 := GetFuncOrNil&<procedure(target: VertexAttribEnumNV; id: UInt32; ¶ms: IntPtr)>(z_ExecuteProgramNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ExecuteProgramNV(target: VertexAttribEnumNV; id: UInt32; ¶ms: IntPtr);
begin
z_ExecuteProgramNV_ovr_2(target, id, ¶ms);
end;
public z_GenProgramsNV_adr := GetFuncAdr('glGenProgramsNV');
public z_GenProgramsNV_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var programs: UInt32)>(z_GenProgramsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenProgramsNV(n: Int32; programs: array of UInt32);
begin
z_GenProgramsNV_ovr_0(n, programs[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenProgramsNV(n: Int32; var programs: UInt32);
begin
z_GenProgramsNV_ovr_0(n, programs);
end;
public z_GenProgramsNV_ovr_2 := GetFuncOrNil&<procedure(n: Int32; programs: IntPtr)>(z_GenProgramsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GenProgramsNV(n: Int32; programs: IntPtr);
begin
z_GenProgramsNV_ovr_2(n, programs);
end;
public z_GetProgramParameterdvNV_adr := GetFuncAdr('glGetProgramParameterdvNV');
public z_GetProgramParameterdvNV_ovr_0 := GetFuncOrNil&<procedure(target: VertexAttribEnumNV; index: UInt32; pname: VertexAttribEnumNV; var ¶ms: real)>(z_GetProgramParameterdvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramParameterdvNV(target: VertexAttribEnumNV; index: UInt32; pname: VertexAttribEnumNV; ¶ms: array of real);
begin
z_GetProgramParameterdvNV_ovr_0(target, index, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramParameterdvNV(target: VertexAttribEnumNV; index: UInt32; pname: VertexAttribEnumNV; var ¶ms: real);
begin
z_GetProgramParameterdvNV_ovr_0(target, index, pname, ¶ms);
end;
public z_GetProgramParameterdvNV_ovr_2 := GetFuncOrNil&<procedure(target: VertexAttribEnumNV; index: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr)>(z_GetProgramParameterdvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramParameterdvNV(target: VertexAttribEnumNV; index: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr);
begin
z_GetProgramParameterdvNV_ovr_2(target, index, pname, ¶ms);
end;
public z_GetProgramParameterfvNV_adr := GetFuncAdr('glGetProgramParameterfvNV');
public z_GetProgramParameterfvNV_ovr_0 := GetFuncOrNil&<procedure(target: VertexAttribEnumNV; index: UInt32; pname: VertexAttribEnumNV; var ¶ms: single)>(z_GetProgramParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramParameterfvNV(target: VertexAttribEnumNV; index: UInt32; pname: VertexAttribEnumNV; ¶ms: array of single);
begin
z_GetProgramParameterfvNV_ovr_0(target, index, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramParameterfvNV(target: VertexAttribEnumNV; index: UInt32; pname: VertexAttribEnumNV; var ¶ms: single);
begin
z_GetProgramParameterfvNV_ovr_0(target, index, pname, ¶ms);
end;
public z_GetProgramParameterfvNV_ovr_2 := GetFuncOrNil&<procedure(target: VertexAttribEnumNV; index: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr)>(z_GetProgramParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramParameterfvNV(target: VertexAttribEnumNV; index: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr);
begin
z_GetProgramParameterfvNV_ovr_2(target, index, pname, ¶ms);
end;
public z_GetProgramivNV_adr := GetFuncAdr('glGetProgramivNV');
public z_GetProgramivNV_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; pname: VertexAttribEnumNV; var ¶ms: Int32)>(z_GetProgramivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramivNV(id: UInt32; pname: VertexAttribEnumNV; ¶ms: array of Int32);
begin
z_GetProgramivNV_ovr_0(id, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramivNV(id: UInt32; pname: VertexAttribEnumNV; var ¶ms: Int32);
begin
z_GetProgramivNV_ovr_0(id, pname, ¶ms);
end;
public z_GetProgramivNV_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr)>(z_GetProgramivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramivNV(id: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr);
begin
z_GetProgramivNV_ovr_2(id, pname, ¶ms);
end;
public z_GetProgramStringNV_adr := GetFuncAdr('glGetProgramStringNV');
public z_GetProgramStringNV_ovr_0 := GetFuncOrNil&<procedure(id: UInt32; pname: VertexAttribEnumNV; var &program: Byte)>(z_GetProgramStringNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramStringNV(id: UInt32; pname: VertexAttribEnumNV; &program: array of Byte);
begin
z_GetProgramStringNV_ovr_0(id, pname, &program[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramStringNV(id: UInt32; pname: VertexAttribEnumNV; var &program: Byte);
begin
z_GetProgramStringNV_ovr_0(id, pname, &program);
end;
public z_GetProgramStringNV_ovr_2 := GetFuncOrNil&<procedure(id: UInt32; pname: VertexAttribEnumNV; &program: IntPtr)>(z_GetProgramStringNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetProgramStringNV(id: UInt32; pname: VertexAttribEnumNV; &program: IntPtr);
begin
z_GetProgramStringNV_ovr_2(id, pname, &program);
end;
public z_GetTrackMatrixivNV_adr := GetFuncAdr('glGetTrackMatrixivNV');
public z_GetTrackMatrixivNV_ovr_0 := GetFuncOrNil&<procedure(target: VertexAttribEnumNV; address: UInt32; pname: VertexAttribEnumNV; var ¶ms: Int32)>(z_GetTrackMatrixivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTrackMatrixivNV(target: VertexAttribEnumNV; address: UInt32; pname: VertexAttribEnumNV; ¶ms: array of Int32);
begin
z_GetTrackMatrixivNV_ovr_0(target, address, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTrackMatrixivNV(target: VertexAttribEnumNV; address: UInt32; pname: VertexAttribEnumNV; var ¶ms: Int32);
begin
z_GetTrackMatrixivNV_ovr_0(target, address, pname, ¶ms);
end;
public z_GetTrackMatrixivNV_ovr_2 := GetFuncOrNil&<procedure(target: VertexAttribEnumNV; address: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr)>(z_GetTrackMatrixivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTrackMatrixivNV(target: VertexAttribEnumNV; address: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr);
begin
z_GetTrackMatrixivNV_ovr_2(target, address, pname, ¶ms);
end;
public z_GetVertexAttribdvNV_adr := GetFuncAdr('glGetVertexAttribdvNV');
public z_GetVertexAttribdvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnumNV; var ¶ms: real)>(z_GetVertexAttribdvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribdvNV(index: UInt32; pname: VertexAttribEnumNV; ¶ms: array of real);
begin
z_GetVertexAttribdvNV_ovr_0(index, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribdvNV(index: UInt32; pname: VertexAttribEnumNV; var ¶ms: real);
begin
z_GetVertexAttribdvNV_ovr_0(index, pname, ¶ms);
end;
public z_GetVertexAttribdvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr)>(z_GetVertexAttribdvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribdvNV(index: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr);
begin
z_GetVertexAttribdvNV_ovr_2(index, pname, ¶ms);
end;
public z_GetVertexAttribfvNV_adr := GetFuncAdr('glGetVertexAttribfvNV');
public z_GetVertexAttribfvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnumNV; var ¶ms: single)>(z_GetVertexAttribfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribfvNV(index: UInt32; pname: VertexAttribEnumNV; ¶ms: array of single);
begin
z_GetVertexAttribfvNV_ovr_0(index, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribfvNV(index: UInt32; pname: VertexAttribEnumNV; var ¶ms: single);
begin
z_GetVertexAttribfvNV_ovr_0(index, pname, ¶ms);
end;
public z_GetVertexAttribfvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr)>(z_GetVertexAttribfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribfvNV(index: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr);
begin
z_GetVertexAttribfvNV_ovr_2(index, pname, ¶ms);
end;
public z_GetVertexAttribivNV_adr := GetFuncAdr('glGetVertexAttribivNV');
public z_GetVertexAttribivNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnumNV; var ¶ms: Int32)>(z_GetVertexAttribivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribivNV(index: UInt32; pname: VertexAttribEnumNV; ¶ms: array of Int32);
begin
z_GetVertexAttribivNV_ovr_0(index, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribivNV(index: UInt32; pname: VertexAttribEnumNV; var ¶ms: Int32);
begin
z_GetVertexAttribivNV_ovr_0(index, pname, ¶ms);
end;
public z_GetVertexAttribivNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr)>(z_GetVertexAttribivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribivNV(index: UInt32; pname: VertexAttribEnumNV; ¶ms: IntPtr);
begin
z_GetVertexAttribivNV_ovr_2(index, pname, ¶ms);
end;
public z_GetVertexAttribPointervNV_adr := GetFuncAdr('glGetVertexAttribPointervNV');
public z_GetVertexAttribPointervNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnumNV; var _pointer: IntPtr)>(z_GetVertexAttribPointervNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribPointervNV(index: UInt32; pname: VertexAttribEnumNV; _pointer: array of IntPtr);
begin
z_GetVertexAttribPointervNV_ovr_0(index, pname, _pointer[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribPointervNV(index: UInt32; pname: VertexAttribEnumNV; var _pointer: IntPtr);
begin
z_GetVertexAttribPointervNV_ovr_0(index, pname, _pointer);
end;
public z_GetVertexAttribPointervNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; pname: VertexAttribEnumNV; _pointer: pointer)>(z_GetVertexAttribPointervNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVertexAttribPointervNV(index: UInt32; pname: VertexAttribEnumNV; _pointer: pointer);
begin
z_GetVertexAttribPointervNV_ovr_2(index, pname, _pointer);
end;
public z_IsProgramNV_adr := GetFuncAdr('glIsProgramNV');
public z_IsProgramNV_ovr_0 := GetFuncOrNil&<function(id: UInt32): boolean>(z_IsProgramNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsProgramNV(id: UInt32): boolean;
begin
Result := z_IsProgramNV_ovr_0(id);
end;
public z_LoadProgramNV_adr := GetFuncAdr('glLoadProgramNV');
public z_LoadProgramNV_ovr_0 := GetFuncOrNil&<procedure(target: VertexAttribEnumNV; id: UInt32; len: Int32; var &program: Byte)>(z_LoadProgramNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadProgramNV(target: VertexAttribEnumNV; id: UInt32; len: Int32; &program: array of Byte);
begin
z_LoadProgramNV_ovr_0(target, id, len, &program[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadProgramNV(target: VertexAttribEnumNV; id: UInt32; len: Int32; var &program: Byte);
begin
z_LoadProgramNV_ovr_0(target, id, len, &program);
end;
public z_LoadProgramNV_ovr_2 := GetFuncOrNil&<procedure(target: VertexAttribEnumNV; id: UInt32; len: Int32; &program: IntPtr)>(z_LoadProgramNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadProgramNV(target: VertexAttribEnumNV; id: UInt32; len: Int32; &program: IntPtr);
begin
z_LoadProgramNV_ovr_2(target, id, len, &program);
end;
public z_ProgramParameter4dNV_adr := GetFuncAdr('glProgramParameter4dNV');
public z_ProgramParameter4dNV_ovr_0 := GetFuncOrNil&<procedure(target: VertexAttribEnumNV; index: UInt32; x: real; y: real; z: real; w: real)>(z_ProgramParameter4dNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameter4dNV(target: VertexAttribEnumNV; index: UInt32; x: real; y: real; z: real; w: real);
begin
z_ProgramParameter4dNV_ovr_0(target, index, x, y, z, w);
end;
public z_ProgramParameter4dvNV_adr := GetFuncAdr('glProgramParameter4dvNV');
public z_ProgramParameter4dvNV_ovr_0 := GetFuncOrNil&<procedure(target: VertexAttribEnumNV; index: UInt32; var v: real)>(z_ProgramParameter4dvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameter4dvNV(target: VertexAttribEnumNV; index: UInt32; v: array of real);
begin
z_ProgramParameter4dvNV_ovr_0(target, index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameter4dvNV(target: VertexAttribEnumNV; index: UInt32; var v: real);
begin
z_ProgramParameter4dvNV_ovr_0(target, index, v);
end;
public z_ProgramParameter4dvNV_ovr_2 := GetFuncOrNil&<procedure(target: VertexAttribEnumNV; index: UInt32; v: IntPtr)>(z_ProgramParameter4dvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameter4dvNV(target: VertexAttribEnumNV; index: UInt32; v: IntPtr);
begin
z_ProgramParameter4dvNV_ovr_2(target, index, v);
end;
public z_ProgramParameter4fNV_adr := GetFuncAdr('glProgramParameter4fNV');
public z_ProgramParameter4fNV_ovr_0 := GetFuncOrNil&<procedure(target: VertexAttribEnumNV; index: UInt32; x: single; y: single; z: single; w: single)>(z_ProgramParameter4fNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameter4fNV(target: VertexAttribEnumNV; index: UInt32; x: single; y: single; z: single; w: single);
begin
z_ProgramParameter4fNV_ovr_0(target, index, x, y, z, w);
end;
public z_ProgramParameter4fvNV_adr := GetFuncAdr('glProgramParameter4fvNV');
public z_ProgramParameter4fvNV_ovr_0 := GetFuncOrNil&<procedure(target: VertexAttribEnumNV; index: UInt32; var v: single)>(z_ProgramParameter4fvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameter4fvNV(target: VertexAttribEnumNV; index: UInt32; v: array of single);
begin
z_ProgramParameter4fvNV_ovr_0(target, index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameter4fvNV(target: VertexAttribEnumNV; index: UInt32; var v: single);
begin
z_ProgramParameter4fvNV_ovr_0(target, index, v);
end;
public z_ProgramParameter4fvNV_ovr_2 := GetFuncOrNil&<procedure(target: VertexAttribEnumNV; index: UInt32; v: IntPtr)>(z_ProgramParameter4fvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameter4fvNV(target: VertexAttribEnumNV; index: UInt32; v: IntPtr);
begin
z_ProgramParameter4fvNV_ovr_2(target, index, v);
end;
public z_ProgramParameters4dvNV_adr := GetFuncAdr('glProgramParameters4dvNV');
public z_ProgramParameters4dvNV_ovr_0 := GetFuncOrNil&<procedure(target: VertexAttribEnumNV; index: UInt32; count: Int32; var v: real)>(z_ProgramParameters4dvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameters4dvNV(target: VertexAttribEnumNV; index: UInt32; count: Int32; v: array of real);
begin
z_ProgramParameters4dvNV_ovr_0(target, index, count, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameters4dvNV(target: VertexAttribEnumNV; index: UInt32; count: Int32; var v: real);
begin
z_ProgramParameters4dvNV_ovr_0(target, index, count, v);
end;
public z_ProgramParameters4dvNV_ovr_2 := GetFuncOrNil&<procedure(target: VertexAttribEnumNV; index: UInt32; count: Int32; v: IntPtr)>(z_ProgramParameters4dvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameters4dvNV(target: VertexAttribEnumNV; index: UInt32; count: Int32; v: IntPtr);
begin
z_ProgramParameters4dvNV_ovr_2(target, index, count, v);
end;
public z_ProgramParameters4fvNV_adr := GetFuncAdr('glProgramParameters4fvNV');
public z_ProgramParameters4fvNV_ovr_0 := GetFuncOrNil&<procedure(target: VertexAttribEnumNV; index: UInt32; count: Int32; var v: single)>(z_ProgramParameters4fvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameters4fvNV(target: VertexAttribEnumNV; index: UInt32; count: Int32; v: array of single);
begin
z_ProgramParameters4fvNV_ovr_0(target, index, count, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameters4fvNV(target: VertexAttribEnumNV; index: UInt32; count: Int32; var v: single);
begin
z_ProgramParameters4fvNV_ovr_0(target, index, count, v);
end;
public z_ProgramParameters4fvNV_ovr_2 := GetFuncOrNil&<procedure(target: VertexAttribEnumNV; index: UInt32; count: Int32; v: IntPtr)>(z_ProgramParameters4fvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ProgramParameters4fvNV(target: VertexAttribEnumNV; index: UInt32; count: Int32; v: IntPtr);
begin
z_ProgramParameters4fvNV_ovr_2(target, index, count, v);
end;
public z_RequestResidentProgramsNV_adr := GetFuncAdr('glRequestResidentProgramsNV');
public z_RequestResidentProgramsNV_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var programs: UInt32)>(z_RequestResidentProgramsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RequestResidentProgramsNV(n: Int32; programs: array of UInt32);
begin
z_RequestResidentProgramsNV_ovr_0(n, programs[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RequestResidentProgramsNV(n: Int32; var programs: UInt32);
begin
z_RequestResidentProgramsNV_ovr_0(n, programs);
end;
public z_RequestResidentProgramsNV_ovr_2 := GetFuncOrNil&<procedure(n: Int32; programs: IntPtr)>(z_RequestResidentProgramsNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RequestResidentProgramsNV(n: Int32; programs: IntPtr);
begin
z_RequestResidentProgramsNV_ovr_2(n, programs);
end;
public z_TrackMatrixNV_adr := GetFuncAdr('glTrackMatrixNV');
public z_TrackMatrixNV_ovr_0 := GetFuncOrNil&<procedure(target: VertexAttribEnumNV; address: UInt32; matrix: VertexAttribEnumNV; transform: VertexAttribEnumNV)>(z_TrackMatrixNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TrackMatrixNV(target: VertexAttribEnumNV; address: UInt32; matrix: VertexAttribEnumNV; transform: VertexAttribEnumNV);
begin
z_TrackMatrixNV_ovr_0(target, address, matrix, transform);
end;
public z_VertexAttribPointerNV_adr := GetFuncAdr('glVertexAttribPointerNV');
public z_VertexAttribPointerNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; fsize: Int32; &type: VertexAttribEnumNV; stride: Int32; pointer: IntPtr)>(z_VertexAttribPointerNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribPointerNV(index: UInt32; fsize: Int32; &type: VertexAttribEnumNV; stride: Int32; pointer: IntPtr);
begin
z_VertexAttribPointerNV_ovr_0(index, fsize, &type, stride, pointer);
end;
public z_VertexAttrib1dNV_adr := GetFuncAdr('glVertexAttrib1dNV');
public z_VertexAttrib1dNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: real)>(z_VertexAttrib1dNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dNV(index: UInt32; x: real);
begin
z_VertexAttrib1dNV_ovr_0(index, x);
end;
public z_VertexAttrib1dvNV_adr := GetFuncAdr('glVertexAttrib1dvNV');
public z_VertexAttrib1dvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttrib1dvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dvNV(index: UInt32; v: array of real);
begin
z_VertexAttrib1dvNV_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dvNV(index: UInt32; var v: real);
begin
z_VertexAttrib1dvNV_ovr_0(index, v);
end;
public z_VertexAttrib1dvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib1dvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1dvNV(index: UInt32; v: IntPtr);
begin
z_VertexAttrib1dvNV_ovr_2(index, v);
end;
public z_VertexAttrib1fNV_adr := GetFuncAdr('glVertexAttrib1fNV');
public z_VertexAttrib1fNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: single)>(z_VertexAttrib1fNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fNV(index: UInt32; x: single);
begin
z_VertexAttrib1fNV_ovr_0(index, x);
end;
public z_VertexAttrib1fvNV_adr := GetFuncAdr('glVertexAttrib1fvNV');
public z_VertexAttrib1fvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: single)>(z_VertexAttrib1fvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fvNV(index: UInt32; v: array of single);
begin
z_VertexAttrib1fvNV_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fvNV(index: UInt32; var v: single);
begin
z_VertexAttrib1fvNV_ovr_0(index, v);
end;
public z_VertexAttrib1fvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib1fvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1fvNV(index: UInt32; v: IntPtr);
begin
z_VertexAttrib1fvNV_ovr_2(index, v);
end;
public z_VertexAttrib1sNV_adr := GetFuncAdr('glVertexAttrib1sNV');
public z_VertexAttrib1sNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Int16)>(z_VertexAttrib1sNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1sNV(index: UInt32; x: Int16);
begin
z_VertexAttrib1sNV_ovr_0(index, x);
end;
public z_VertexAttrib1svNV_adr := GetFuncAdr('glVertexAttrib1svNV');
public z_VertexAttrib1svNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int16)>(z_VertexAttrib1svNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1svNV(index: UInt32; v: array of Int16);
begin
z_VertexAttrib1svNV_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1svNV(index: UInt32; var v: Int16);
begin
z_VertexAttrib1svNV_ovr_0(index, v);
end;
public z_VertexAttrib1svNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib1svNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib1svNV(index: UInt32; v: IntPtr);
begin
z_VertexAttrib1svNV_ovr_2(index, v);
end;
public z_VertexAttrib2dNV_adr := GetFuncAdr('glVertexAttrib2dNV');
public z_VertexAttrib2dNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: real; y: real)>(z_VertexAttrib2dNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dNV(index: UInt32; x: real; y: real);
begin
z_VertexAttrib2dNV_ovr_0(index, x, y);
end;
public z_VertexAttrib2dvNV_adr := GetFuncAdr('glVertexAttrib2dvNV');
public z_VertexAttrib2dvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttrib2dvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dvNV(index: UInt32; v: array of real);
begin
z_VertexAttrib2dvNV_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dvNV(index: UInt32; var v: real);
begin
z_VertexAttrib2dvNV_ovr_0(index, v);
end;
public z_VertexAttrib2dvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib2dvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2dvNV(index: UInt32; v: IntPtr);
begin
z_VertexAttrib2dvNV_ovr_2(index, v);
end;
public z_VertexAttrib2fNV_adr := GetFuncAdr('glVertexAttrib2fNV');
public z_VertexAttrib2fNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: single; y: single)>(z_VertexAttrib2fNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fNV(index: UInt32; x: single; y: single);
begin
z_VertexAttrib2fNV_ovr_0(index, x, y);
end;
public z_VertexAttrib2fvNV_adr := GetFuncAdr('glVertexAttrib2fvNV');
public z_VertexAttrib2fvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: single)>(z_VertexAttrib2fvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fvNV(index: UInt32; v: array of single);
begin
z_VertexAttrib2fvNV_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fvNV(index: UInt32; var v: single);
begin
z_VertexAttrib2fvNV_ovr_0(index, v);
end;
public z_VertexAttrib2fvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib2fvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2fvNV(index: UInt32; v: IntPtr);
begin
z_VertexAttrib2fvNV_ovr_2(index, v);
end;
public z_VertexAttrib2sNV_adr := GetFuncAdr('glVertexAttrib2sNV');
public z_VertexAttrib2sNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Int16; y: Int16)>(z_VertexAttrib2sNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2sNV(index: UInt32; x: Int16; y: Int16);
begin
z_VertexAttrib2sNV_ovr_0(index, x, y);
end;
public z_VertexAttrib2svNV_adr := GetFuncAdr('glVertexAttrib2svNV');
public z_VertexAttrib2svNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int16)>(z_VertexAttrib2svNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2svNV(index: UInt32; v: array of Int16);
begin
z_VertexAttrib2svNV_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2svNV(index: UInt32; var v: Int16);
begin
z_VertexAttrib2svNV_ovr_0(index, v);
end;
public z_VertexAttrib2svNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib2svNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib2svNV(index: UInt32; v: IntPtr);
begin
z_VertexAttrib2svNV_ovr_2(index, v);
end;
public z_VertexAttrib3dNV_adr := GetFuncAdr('glVertexAttrib3dNV');
public z_VertexAttrib3dNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: real; y: real; z: real)>(z_VertexAttrib3dNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dNV(index: UInt32; x: real; y: real; z: real);
begin
z_VertexAttrib3dNV_ovr_0(index, x, y, z);
end;
public z_VertexAttrib3dvNV_adr := GetFuncAdr('glVertexAttrib3dvNV');
public z_VertexAttrib3dvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttrib3dvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dvNV(index: UInt32; v: array of real);
begin
z_VertexAttrib3dvNV_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dvNV(index: UInt32; var v: real);
begin
z_VertexAttrib3dvNV_ovr_0(index, v);
end;
public z_VertexAttrib3dvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib3dvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3dvNV(index: UInt32; v: IntPtr);
begin
z_VertexAttrib3dvNV_ovr_2(index, v);
end;
public z_VertexAttrib3fNV_adr := GetFuncAdr('glVertexAttrib3fNV');
public z_VertexAttrib3fNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: single; y: single; z: single)>(z_VertexAttrib3fNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fNV(index: UInt32; x: single; y: single; z: single);
begin
z_VertexAttrib3fNV_ovr_0(index, x, y, z);
end;
public z_VertexAttrib3fvNV_adr := GetFuncAdr('glVertexAttrib3fvNV');
public z_VertexAttrib3fvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: single)>(z_VertexAttrib3fvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fvNV(index: UInt32; v: array of single);
begin
z_VertexAttrib3fvNV_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fvNV(index: UInt32; var v: single);
begin
z_VertexAttrib3fvNV_ovr_0(index, v);
end;
public z_VertexAttrib3fvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib3fvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3fvNV(index: UInt32; v: IntPtr);
begin
z_VertexAttrib3fvNV_ovr_2(index, v);
end;
public z_VertexAttrib3sNV_adr := GetFuncAdr('glVertexAttrib3sNV');
public z_VertexAttrib3sNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Int16; y: Int16; z: Int16)>(z_VertexAttrib3sNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3sNV(index: UInt32; x: Int16; y: Int16; z: Int16);
begin
z_VertexAttrib3sNV_ovr_0(index, x, y, z);
end;
public z_VertexAttrib3svNV_adr := GetFuncAdr('glVertexAttrib3svNV');
public z_VertexAttrib3svNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int16)>(z_VertexAttrib3svNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3svNV(index: UInt32; v: array of Int16);
begin
z_VertexAttrib3svNV_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3svNV(index: UInt32; var v: Int16);
begin
z_VertexAttrib3svNV_ovr_0(index, v);
end;
public z_VertexAttrib3svNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib3svNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib3svNV(index: UInt32; v: IntPtr);
begin
z_VertexAttrib3svNV_ovr_2(index, v);
end;
public z_VertexAttrib4dNV_adr := GetFuncAdr('glVertexAttrib4dNV');
public z_VertexAttrib4dNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: real; y: real; z: real; w: real)>(z_VertexAttrib4dNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dNV(index: UInt32; x: real; y: real; z: real; w: real);
begin
z_VertexAttrib4dNV_ovr_0(index, x, y, z, w);
end;
public z_VertexAttrib4dvNV_adr := GetFuncAdr('glVertexAttrib4dvNV');
public z_VertexAttrib4dvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: real)>(z_VertexAttrib4dvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dvNV(index: UInt32; v: array of real);
begin
z_VertexAttrib4dvNV_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dvNV(index: UInt32; var v: real);
begin
z_VertexAttrib4dvNV_ovr_0(index, v);
end;
public z_VertexAttrib4dvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4dvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4dvNV(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4dvNV_ovr_2(index, v);
end;
public z_VertexAttrib4fNV_adr := GetFuncAdr('glVertexAttrib4fNV');
public z_VertexAttrib4fNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: single; y: single; z: single; w: single)>(z_VertexAttrib4fNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fNV(index: UInt32; x: single; y: single; z: single; w: single);
begin
z_VertexAttrib4fNV_ovr_0(index, x, y, z, w);
end;
public z_VertexAttrib4fvNV_adr := GetFuncAdr('glVertexAttrib4fvNV');
public z_VertexAttrib4fvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: single)>(z_VertexAttrib4fvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fvNV(index: UInt32; v: array of single);
begin
z_VertexAttrib4fvNV_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fvNV(index: UInt32; var v: single);
begin
z_VertexAttrib4fvNV_ovr_0(index, v);
end;
public z_VertexAttrib4fvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4fvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4fvNV(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4fvNV_ovr_2(index, v);
end;
public z_VertexAttrib4sNV_adr := GetFuncAdr('glVertexAttrib4sNV');
public z_VertexAttrib4sNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Int16; y: Int16; z: Int16; w: Int16)>(z_VertexAttrib4sNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4sNV(index: UInt32; x: Int16; y: Int16; z: Int16; w: Int16);
begin
z_VertexAttrib4sNV_ovr_0(index, x, y, z, w);
end;
public z_VertexAttrib4svNV_adr := GetFuncAdr('glVertexAttrib4svNV');
public z_VertexAttrib4svNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Int16)>(z_VertexAttrib4svNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4svNV(index: UInt32; v: array of Int16);
begin
z_VertexAttrib4svNV_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4svNV(index: UInt32; var v: Int16);
begin
z_VertexAttrib4svNV_ovr_0(index, v);
end;
public z_VertexAttrib4svNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4svNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4svNV(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4svNV_ovr_2(index, v);
end;
public z_VertexAttrib4ubNV_adr := GetFuncAdr('glVertexAttrib4ubNV');
public z_VertexAttrib4ubNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; x: Byte; y: Byte; z: Byte; w: Byte)>(z_VertexAttrib4ubNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ubNV(index: UInt32; x: Byte; y: Byte; z: Byte; w: Byte);
begin
z_VertexAttrib4ubNV_ovr_0(index, x, y, z, w);
end;
public z_VertexAttrib4ubvNV_adr := GetFuncAdr('glVertexAttrib4ubvNV');
public z_VertexAttrib4ubvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; var v: Byte)>(z_VertexAttrib4ubvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ubvNV(index: UInt32; v: array of Byte);
begin
z_VertexAttrib4ubvNV_ovr_0(index, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ubvNV(index: UInt32; var v: Byte);
begin
z_VertexAttrib4ubvNV_ovr_0(index, v);
end;
public z_VertexAttrib4ubvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; v: IntPtr)>(z_VertexAttrib4ubvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttrib4ubvNV(index: UInt32; v: IntPtr);
begin
z_VertexAttrib4ubvNV_ovr_2(index, v);
end;
public z_VertexAttribs1dvNV_adr := GetFuncAdr('glVertexAttribs1dvNV');
public z_VertexAttribs1dvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; count: Int32; var v: real)>(z_VertexAttribs1dvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs1dvNV(index: UInt32; count: Int32; v: array of real);
begin
z_VertexAttribs1dvNV_ovr_0(index, count, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs1dvNV(index: UInt32; count: Int32; var v: real);
begin
z_VertexAttribs1dvNV_ovr_0(index, count, v);
end;
public z_VertexAttribs1dvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; count: Int32; v: IntPtr)>(z_VertexAttribs1dvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs1dvNV(index: UInt32; count: Int32; v: IntPtr);
begin
z_VertexAttribs1dvNV_ovr_2(index, count, v);
end;
public z_VertexAttribs1fvNV_adr := GetFuncAdr('glVertexAttribs1fvNV');
public z_VertexAttribs1fvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; count: Int32; var v: single)>(z_VertexAttribs1fvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs1fvNV(index: UInt32; count: Int32; v: array of single);
begin
z_VertexAttribs1fvNV_ovr_0(index, count, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs1fvNV(index: UInt32; count: Int32; var v: single);
begin
z_VertexAttribs1fvNV_ovr_0(index, count, v);
end;
public z_VertexAttribs1fvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; count: Int32; v: IntPtr)>(z_VertexAttribs1fvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs1fvNV(index: UInt32; count: Int32; v: IntPtr);
begin
z_VertexAttribs1fvNV_ovr_2(index, count, v);
end;
public z_VertexAttribs1svNV_adr := GetFuncAdr('glVertexAttribs1svNV');
public z_VertexAttribs1svNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; count: Int32; var v: Int16)>(z_VertexAttribs1svNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs1svNV(index: UInt32; count: Int32; v: array of Int16);
begin
z_VertexAttribs1svNV_ovr_0(index, count, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs1svNV(index: UInt32; count: Int32; var v: Int16);
begin
z_VertexAttribs1svNV_ovr_0(index, count, v);
end;
public z_VertexAttribs1svNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; count: Int32; v: IntPtr)>(z_VertexAttribs1svNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs1svNV(index: UInt32; count: Int32; v: IntPtr);
begin
z_VertexAttribs1svNV_ovr_2(index, count, v);
end;
public z_VertexAttribs2dvNV_adr := GetFuncAdr('glVertexAttribs2dvNV');
public z_VertexAttribs2dvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; count: Int32; var v: real)>(z_VertexAttribs2dvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs2dvNV(index: UInt32; count: Int32; v: array of real);
begin
z_VertexAttribs2dvNV_ovr_0(index, count, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs2dvNV(index: UInt32; count: Int32; var v: real);
begin
z_VertexAttribs2dvNV_ovr_0(index, count, v);
end;
public z_VertexAttribs2dvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; count: Int32; v: IntPtr)>(z_VertexAttribs2dvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs2dvNV(index: UInt32; count: Int32; v: IntPtr);
begin
z_VertexAttribs2dvNV_ovr_2(index, count, v);
end;
public z_VertexAttribs2fvNV_adr := GetFuncAdr('glVertexAttribs2fvNV');
public z_VertexAttribs2fvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; count: Int32; var v: single)>(z_VertexAttribs2fvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs2fvNV(index: UInt32; count: Int32; v: array of single);
begin
z_VertexAttribs2fvNV_ovr_0(index, count, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs2fvNV(index: UInt32; count: Int32; var v: single);
begin
z_VertexAttribs2fvNV_ovr_0(index, count, v);
end;
public z_VertexAttribs2fvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; count: Int32; v: IntPtr)>(z_VertexAttribs2fvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs2fvNV(index: UInt32; count: Int32; v: IntPtr);
begin
z_VertexAttribs2fvNV_ovr_2(index, count, v);
end;
public z_VertexAttribs2svNV_adr := GetFuncAdr('glVertexAttribs2svNV');
public z_VertexAttribs2svNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; count: Int32; var v: Int16)>(z_VertexAttribs2svNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs2svNV(index: UInt32; count: Int32; v: array of Int16);
begin
z_VertexAttribs2svNV_ovr_0(index, count, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs2svNV(index: UInt32; count: Int32; var v: Int16);
begin
z_VertexAttribs2svNV_ovr_0(index, count, v);
end;
public z_VertexAttribs2svNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; count: Int32; v: IntPtr)>(z_VertexAttribs2svNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs2svNV(index: UInt32; count: Int32; v: IntPtr);
begin
z_VertexAttribs2svNV_ovr_2(index, count, v);
end;
public z_VertexAttribs3dvNV_adr := GetFuncAdr('glVertexAttribs3dvNV');
public z_VertexAttribs3dvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; count: Int32; var v: real)>(z_VertexAttribs3dvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs3dvNV(index: UInt32; count: Int32; v: array of real);
begin
z_VertexAttribs3dvNV_ovr_0(index, count, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs3dvNV(index: UInt32; count: Int32; var v: real);
begin
z_VertexAttribs3dvNV_ovr_0(index, count, v);
end;
public z_VertexAttribs3dvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; count: Int32; v: IntPtr)>(z_VertexAttribs3dvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs3dvNV(index: UInt32; count: Int32; v: IntPtr);
begin
z_VertexAttribs3dvNV_ovr_2(index, count, v);
end;
public z_VertexAttribs3fvNV_adr := GetFuncAdr('glVertexAttribs3fvNV');
public z_VertexAttribs3fvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; count: Int32; var v: single)>(z_VertexAttribs3fvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs3fvNV(index: UInt32; count: Int32; v: array of single);
begin
z_VertexAttribs3fvNV_ovr_0(index, count, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs3fvNV(index: UInt32; count: Int32; var v: single);
begin
z_VertexAttribs3fvNV_ovr_0(index, count, v);
end;
public z_VertexAttribs3fvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; count: Int32; v: IntPtr)>(z_VertexAttribs3fvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs3fvNV(index: UInt32; count: Int32; v: IntPtr);
begin
z_VertexAttribs3fvNV_ovr_2(index, count, v);
end;
public z_VertexAttribs3svNV_adr := GetFuncAdr('glVertexAttribs3svNV');
public z_VertexAttribs3svNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; count: Int32; var v: Int16)>(z_VertexAttribs3svNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs3svNV(index: UInt32; count: Int32; v: array of Int16);
begin
z_VertexAttribs3svNV_ovr_0(index, count, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs3svNV(index: UInt32; count: Int32; var v: Int16);
begin
z_VertexAttribs3svNV_ovr_0(index, count, v);
end;
public z_VertexAttribs3svNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; count: Int32; v: IntPtr)>(z_VertexAttribs3svNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs3svNV(index: UInt32; count: Int32; v: IntPtr);
begin
z_VertexAttribs3svNV_ovr_2(index, count, v);
end;
public z_VertexAttribs4dvNV_adr := GetFuncAdr('glVertexAttribs4dvNV');
public z_VertexAttribs4dvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; count: Int32; var v: real)>(z_VertexAttribs4dvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4dvNV(index: UInt32; count: Int32; v: array of real);
begin
z_VertexAttribs4dvNV_ovr_0(index, count, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4dvNV(index: UInt32; count: Int32; var v: real);
begin
z_VertexAttribs4dvNV_ovr_0(index, count, v);
end;
public z_VertexAttribs4dvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; count: Int32; v: IntPtr)>(z_VertexAttribs4dvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4dvNV(index: UInt32; count: Int32; v: IntPtr);
begin
z_VertexAttribs4dvNV_ovr_2(index, count, v);
end;
public z_VertexAttribs4fvNV_adr := GetFuncAdr('glVertexAttribs4fvNV');
public z_VertexAttribs4fvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; count: Int32; var v: single)>(z_VertexAttribs4fvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4fvNV(index: UInt32; count: Int32; v: array of single);
begin
z_VertexAttribs4fvNV_ovr_0(index, count, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4fvNV(index: UInt32; count: Int32; var v: single);
begin
z_VertexAttribs4fvNV_ovr_0(index, count, v);
end;
public z_VertexAttribs4fvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; count: Int32; v: IntPtr)>(z_VertexAttribs4fvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4fvNV(index: UInt32; count: Int32; v: IntPtr);
begin
z_VertexAttribs4fvNV_ovr_2(index, count, v);
end;
public z_VertexAttribs4svNV_adr := GetFuncAdr('glVertexAttribs4svNV');
public z_VertexAttribs4svNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; count: Int32; var v: Int16)>(z_VertexAttribs4svNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4svNV(index: UInt32; count: Int32; v: array of Int16);
begin
z_VertexAttribs4svNV_ovr_0(index, count, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4svNV(index: UInt32; count: Int32; var v: Int16);
begin
z_VertexAttribs4svNV_ovr_0(index, count, v);
end;
public z_VertexAttribs4svNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; count: Int32; v: IntPtr)>(z_VertexAttribs4svNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4svNV(index: UInt32; count: Int32; v: IntPtr);
begin
z_VertexAttribs4svNV_ovr_2(index, count, v);
end;
public z_VertexAttribs4ubvNV_adr := GetFuncAdr('glVertexAttribs4ubvNV');
public z_VertexAttribs4ubvNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; count: Int32; var v: Byte)>(z_VertexAttribs4ubvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4ubvNV(index: UInt32; count: Int32; v: array of Byte);
begin
z_VertexAttribs4ubvNV_ovr_0(index, count, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4ubvNV(index: UInt32; count: Int32; var v: Byte);
begin
z_VertexAttribs4ubvNV_ovr_0(index, count, v);
end;
public z_VertexAttribs4ubvNV_ovr_2 := GetFuncOrNil&<procedure(index: UInt32; count: Int32; v: IntPtr)>(z_VertexAttribs4ubvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VertexAttribs4ubvNV(index: UInt32; count: Int32; v: IntPtr);
begin
z_VertexAttribs4ubvNV_ovr_2(index, count, v);
end;
end;
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);
end;
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);
public z_BeginVideoCaptureNV_adr := GetFuncAdr('glBeginVideoCaptureNV');
public z_BeginVideoCaptureNV_ovr_0 := GetFuncOrNil&<procedure(video_capture_slot: UInt32)>(z_BeginVideoCaptureNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BeginVideoCaptureNV(video_capture_slot: UInt32);
begin
z_BeginVideoCaptureNV_ovr_0(video_capture_slot);
end;
public z_BindVideoCaptureStreamBufferNV_adr := GetFuncAdr('glBindVideoCaptureStreamBufferNV');
public z_BindVideoCaptureStreamBufferNV_ovr_0 := GetFuncOrNil&<procedure(video_capture_slot: UInt32; stream: UInt32; frame_region: DummyEnum; offset: IntPtr)>(z_BindVideoCaptureStreamBufferNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVideoCaptureStreamBufferNV(video_capture_slot: UInt32; stream: UInt32; frame_region: DummyEnum; offset: IntPtr);
begin
z_BindVideoCaptureStreamBufferNV_ovr_0(video_capture_slot, stream, frame_region, offset);
end;
public z_BindVideoCaptureStreamTextureNV_adr := GetFuncAdr('glBindVideoCaptureStreamTextureNV');
public z_BindVideoCaptureStreamTextureNV_ovr_0 := GetFuncOrNil&<procedure(video_capture_slot: UInt32; stream: UInt32; frame_region: DummyEnum; target: DummyEnum; texture: UInt32)>(z_BindVideoCaptureStreamTextureNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindVideoCaptureStreamTextureNV(video_capture_slot: UInt32; stream: UInt32; frame_region: DummyEnum; target: DummyEnum; texture: UInt32);
begin
z_BindVideoCaptureStreamTextureNV_ovr_0(video_capture_slot, stream, frame_region, target, texture);
end;
public z_EndVideoCaptureNV_adr := GetFuncAdr('glEndVideoCaptureNV');
public z_EndVideoCaptureNV_ovr_0 := GetFuncOrNil&<procedure(video_capture_slot: UInt32)>(z_EndVideoCaptureNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EndVideoCaptureNV(video_capture_slot: UInt32);
begin
z_EndVideoCaptureNV_ovr_0(video_capture_slot);
end;
public z_GetVideoCaptureivNV_adr := GetFuncAdr('glGetVideoCaptureivNV');
public z_GetVideoCaptureivNV_ovr_0 := GetFuncOrNil&<procedure(video_capture_slot: UInt32; pname: DummyEnum; var ¶ms: Int32)>(z_GetVideoCaptureivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoCaptureivNV(video_capture_slot: UInt32; pname: DummyEnum; ¶ms: array of Int32);
begin
z_GetVideoCaptureivNV_ovr_0(video_capture_slot, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoCaptureivNV(video_capture_slot: UInt32; pname: DummyEnum; var ¶ms: Int32);
begin
z_GetVideoCaptureivNV_ovr_0(video_capture_slot, pname, ¶ms);
end;
public z_GetVideoCaptureivNV_ovr_2 := GetFuncOrNil&<procedure(video_capture_slot: UInt32; pname: DummyEnum; ¶ms: IntPtr)>(z_GetVideoCaptureivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoCaptureivNV(video_capture_slot: UInt32; pname: DummyEnum; ¶ms: IntPtr);
begin
z_GetVideoCaptureivNV_ovr_2(video_capture_slot, pname, ¶ms);
end;
public z_GetVideoCaptureStreamivNV_adr := GetFuncAdr('glGetVideoCaptureStreamivNV');
public z_GetVideoCaptureStreamivNV_ovr_0 := GetFuncOrNil&<procedure(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; var ¶ms: Int32)>(z_GetVideoCaptureStreamivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoCaptureStreamivNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: array of Int32);
begin
z_GetVideoCaptureStreamivNV_ovr_0(video_capture_slot, stream, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoCaptureStreamivNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; var ¶ms: Int32);
begin
z_GetVideoCaptureStreamivNV_ovr_0(video_capture_slot, stream, pname, ¶ms);
end;
public z_GetVideoCaptureStreamivNV_ovr_2 := GetFuncOrNil&<procedure(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr)>(z_GetVideoCaptureStreamivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoCaptureStreamivNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr);
begin
z_GetVideoCaptureStreamivNV_ovr_2(video_capture_slot, stream, pname, ¶ms);
end;
public z_GetVideoCaptureStreamfvNV_adr := GetFuncAdr('glGetVideoCaptureStreamfvNV');
public z_GetVideoCaptureStreamfvNV_ovr_0 := GetFuncOrNil&<procedure(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; var ¶ms: single)>(z_GetVideoCaptureStreamfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoCaptureStreamfvNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: array of single);
begin
z_GetVideoCaptureStreamfvNV_ovr_0(video_capture_slot, stream, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoCaptureStreamfvNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; var ¶ms: single);
begin
z_GetVideoCaptureStreamfvNV_ovr_0(video_capture_slot, stream, pname, ¶ms);
end;
public z_GetVideoCaptureStreamfvNV_ovr_2 := GetFuncOrNil&<procedure(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr)>(z_GetVideoCaptureStreamfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoCaptureStreamfvNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr);
begin
z_GetVideoCaptureStreamfvNV_ovr_2(video_capture_slot, stream, pname, ¶ms);
end;
public z_GetVideoCaptureStreamdvNV_adr := GetFuncAdr('glGetVideoCaptureStreamdvNV');
public z_GetVideoCaptureStreamdvNV_ovr_0 := GetFuncOrNil&<procedure(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; var ¶ms: real)>(z_GetVideoCaptureStreamdvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoCaptureStreamdvNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: array of real);
begin
z_GetVideoCaptureStreamdvNV_ovr_0(video_capture_slot, stream, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoCaptureStreamdvNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; var ¶ms: real);
begin
z_GetVideoCaptureStreamdvNV_ovr_0(video_capture_slot, stream, pname, ¶ms);
end;
public z_GetVideoCaptureStreamdvNV_ovr_2 := GetFuncOrNil&<procedure(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr)>(z_GetVideoCaptureStreamdvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetVideoCaptureStreamdvNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr);
begin
z_GetVideoCaptureStreamdvNV_ovr_2(video_capture_slot, stream, pname, ¶ms);
end;
public z_VideoCaptureNV_adr := GetFuncAdr('glVideoCaptureNV');
public z_VideoCaptureNV_ovr_0 := GetFuncOrNil&<function(video_capture_slot: UInt32; var sequence_num: UInt32; var capture_time: UInt64): DummyEnum>(z_VideoCaptureNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VideoCaptureNV(video_capture_slot: UInt32; sequence_num: array of UInt32; capture_time: array of UInt64): DummyEnum;
begin
Result := z_VideoCaptureNV_ovr_0(video_capture_slot, sequence_num[0], capture_time[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VideoCaptureNV(video_capture_slot: UInt32; sequence_num: array of UInt32; var capture_time: UInt64): DummyEnum;
begin
Result := z_VideoCaptureNV_ovr_0(video_capture_slot, sequence_num[0], capture_time);
end;
public z_VideoCaptureNV_ovr_2 := GetFuncOrNil&<function(video_capture_slot: UInt32; var sequence_num: UInt32; capture_time: IntPtr): DummyEnum>(z_VideoCaptureNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VideoCaptureNV(video_capture_slot: UInt32; sequence_num: array of UInt32; capture_time: IntPtr): DummyEnum;
begin
Result := z_VideoCaptureNV_ovr_2(video_capture_slot, sequence_num[0], capture_time);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VideoCaptureNV(video_capture_slot: UInt32; var sequence_num: UInt32; capture_time: array of UInt64): DummyEnum;
begin
Result := z_VideoCaptureNV_ovr_0(video_capture_slot, sequence_num, capture_time[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VideoCaptureNV(video_capture_slot: UInt32; var sequence_num: UInt32; var capture_time: UInt64): DummyEnum;
begin
Result := z_VideoCaptureNV_ovr_0(video_capture_slot, sequence_num, capture_time);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VideoCaptureNV(video_capture_slot: UInt32; var sequence_num: UInt32; capture_time: IntPtr): DummyEnum;
begin
Result := z_VideoCaptureNV_ovr_2(video_capture_slot, sequence_num, capture_time);
end;
public z_VideoCaptureNV_ovr_6 := GetFuncOrNil&<function(video_capture_slot: UInt32; sequence_num: IntPtr; var capture_time: UInt64): DummyEnum>(z_VideoCaptureNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VideoCaptureNV(video_capture_slot: UInt32; sequence_num: IntPtr; capture_time: array of UInt64): DummyEnum;
begin
Result := z_VideoCaptureNV_ovr_6(video_capture_slot, sequence_num, capture_time[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VideoCaptureNV(video_capture_slot: UInt32; sequence_num: IntPtr; var capture_time: UInt64): DummyEnum;
begin
Result := z_VideoCaptureNV_ovr_6(video_capture_slot, sequence_num, capture_time);
end;
public z_VideoCaptureNV_ovr_8 := GetFuncOrNil&<function(video_capture_slot: UInt32; sequence_num: IntPtr; capture_time: IntPtr): DummyEnum>(z_VideoCaptureNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function VideoCaptureNV(video_capture_slot: UInt32; sequence_num: IntPtr; capture_time: IntPtr): DummyEnum;
begin
Result := z_VideoCaptureNV_ovr_8(video_capture_slot, sequence_num, capture_time);
end;
public z_VideoCaptureStreamParameterivNV_adr := GetFuncAdr('glVideoCaptureStreamParameterivNV');
public z_VideoCaptureStreamParameterivNV_ovr_0 := GetFuncOrNil&<procedure(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; var ¶ms: Int32)>(z_VideoCaptureStreamParameterivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VideoCaptureStreamParameterivNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: array of Int32);
begin
z_VideoCaptureStreamParameterivNV_ovr_0(video_capture_slot, stream, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VideoCaptureStreamParameterivNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; var ¶ms: Int32);
begin
z_VideoCaptureStreamParameterivNV_ovr_0(video_capture_slot, stream, pname, ¶ms);
end;
public z_VideoCaptureStreamParameterivNV_ovr_2 := GetFuncOrNil&<procedure(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr)>(z_VideoCaptureStreamParameterivNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VideoCaptureStreamParameterivNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr);
begin
z_VideoCaptureStreamParameterivNV_ovr_2(video_capture_slot, stream, pname, ¶ms);
end;
public z_VideoCaptureStreamParameterfvNV_adr := GetFuncAdr('glVideoCaptureStreamParameterfvNV');
public z_VideoCaptureStreamParameterfvNV_ovr_0 := GetFuncOrNil&<procedure(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; var ¶ms: single)>(z_VideoCaptureStreamParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VideoCaptureStreamParameterfvNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: array of single);
begin
z_VideoCaptureStreamParameterfvNV_ovr_0(video_capture_slot, stream, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VideoCaptureStreamParameterfvNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; var ¶ms: single);
begin
z_VideoCaptureStreamParameterfvNV_ovr_0(video_capture_slot, stream, pname, ¶ms);
end;
public z_VideoCaptureStreamParameterfvNV_ovr_2 := GetFuncOrNil&<procedure(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr)>(z_VideoCaptureStreamParameterfvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VideoCaptureStreamParameterfvNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr);
begin
z_VideoCaptureStreamParameterfvNV_ovr_2(video_capture_slot, stream, pname, ¶ms);
end;
public z_VideoCaptureStreamParameterdvNV_adr := GetFuncAdr('glVideoCaptureStreamParameterdvNV');
public z_VideoCaptureStreamParameterdvNV_ovr_0 := GetFuncOrNil&<procedure(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; var ¶ms: real)>(z_VideoCaptureStreamParameterdvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VideoCaptureStreamParameterdvNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: array of real);
begin
z_VideoCaptureStreamParameterdvNV_ovr_0(video_capture_slot, stream, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VideoCaptureStreamParameterdvNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; var ¶ms: real);
begin
z_VideoCaptureStreamParameterdvNV_ovr_0(video_capture_slot, stream, pname, ¶ms);
end;
public z_VideoCaptureStreamParameterdvNV_ovr_2 := GetFuncOrNil&<procedure(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr)>(z_VideoCaptureStreamParameterdvNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure VideoCaptureStreamParameterdvNV(video_capture_slot: UInt32; stream: UInt32; pname: DummyEnum; ¶ms: IntPtr);
begin
z_VideoCaptureStreamParameterdvNV_ovr_2(video_capture_slot, stream, pname, ¶ms);
end;
end;
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);
public z_ViewportSwizzleNV_adr := GetFuncAdr('glViewportSwizzleNV');
public z_ViewportSwizzleNV_ovr_0 := GetFuncOrNil&<procedure(index: UInt32; swizzlex: DummyEnum; swizzley: DummyEnum; swizzlez: DummyEnum; swizzlew: DummyEnum)>(z_ViewportSwizzleNV_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ViewportSwizzleNV(index: UInt32; swizzlex: DummyEnum; swizzley: DummyEnum; swizzlez: DummyEnum; swizzlew: DummyEnum);
begin
z_ViewportSwizzleNV_ovr_0(index, swizzlex, swizzley, swizzlez, swizzlew);
end;
end;
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);
public z_MultiTexCoord1bOES_adr := GetFuncAdr('glMultiTexCoord1bOES');
public z_MultiTexCoord1bOES_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; s: SByte)>(z_MultiTexCoord1bOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1bOES(texture: TextureUnit; s: SByte);
begin
z_MultiTexCoord1bOES_ovr_0(texture, s);
end;
public z_MultiTexCoord1bvOES_adr := GetFuncAdr('glMultiTexCoord1bvOES');
public z_MultiTexCoord1bvOES_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; var coords: SByte)>(z_MultiTexCoord1bvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1bvOES(texture: TextureUnit; coords: array of SByte);
begin
z_MultiTexCoord1bvOES_ovr_0(texture, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1bvOES(texture: TextureUnit; var coords: SByte);
begin
z_MultiTexCoord1bvOES_ovr_0(texture, coords);
end;
public z_MultiTexCoord1bvOES_ovr_2 := GetFuncOrNil&<procedure(texture: TextureUnit; coords: IntPtr)>(z_MultiTexCoord1bvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1bvOES(texture: TextureUnit; coords: IntPtr);
begin
z_MultiTexCoord1bvOES_ovr_2(texture, coords);
end;
public z_MultiTexCoord2bOES_adr := GetFuncAdr('glMultiTexCoord2bOES');
public z_MultiTexCoord2bOES_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; s: SByte; t: SByte)>(z_MultiTexCoord2bOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2bOES(texture: TextureUnit; s: SByte; t: SByte);
begin
z_MultiTexCoord2bOES_ovr_0(texture, s, t);
end;
public z_MultiTexCoord2bvOES_adr := GetFuncAdr('glMultiTexCoord2bvOES');
public z_MultiTexCoord2bvOES_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; var coords: SByte)>(z_MultiTexCoord2bvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2bvOES(texture: TextureUnit; coords: array of SByte);
begin
z_MultiTexCoord2bvOES_ovr_0(texture, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2bvOES(texture: TextureUnit; var coords: SByte);
begin
z_MultiTexCoord2bvOES_ovr_0(texture, coords);
end;
public z_MultiTexCoord2bvOES_ovr_2 := GetFuncOrNil&<procedure(texture: TextureUnit; coords: IntPtr)>(z_MultiTexCoord2bvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2bvOES(texture: TextureUnit; coords: IntPtr);
begin
z_MultiTexCoord2bvOES_ovr_2(texture, coords);
end;
public z_MultiTexCoord3bOES_adr := GetFuncAdr('glMultiTexCoord3bOES');
public z_MultiTexCoord3bOES_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; s: SByte; t: SByte; r: SByte)>(z_MultiTexCoord3bOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3bOES(texture: TextureUnit; s: SByte; t: SByte; r: SByte);
begin
z_MultiTexCoord3bOES_ovr_0(texture, s, t, r);
end;
public z_MultiTexCoord3bvOES_adr := GetFuncAdr('glMultiTexCoord3bvOES');
public z_MultiTexCoord3bvOES_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; var coords: SByte)>(z_MultiTexCoord3bvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3bvOES(texture: TextureUnit; coords: array of SByte);
begin
z_MultiTexCoord3bvOES_ovr_0(texture, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3bvOES(texture: TextureUnit; var coords: SByte);
begin
z_MultiTexCoord3bvOES_ovr_0(texture, coords);
end;
public z_MultiTexCoord3bvOES_ovr_2 := GetFuncOrNil&<procedure(texture: TextureUnit; coords: IntPtr)>(z_MultiTexCoord3bvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3bvOES(texture: TextureUnit; coords: IntPtr);
begin
z_MultiTexCoord3bvOES_ovr_2(texture, coords);
end;
public z_MultiTexCoord4bOES_adr := GetFuncAdr('glMultiTexCoord4bOES');
public z_MultiTexCoord4bOES_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; s: SByte; t: SByte; r: SByte; q: SByte)>(z_MultiTexCoord4bOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4bOES(texture: TextureUnit; s: SByte; t: SByte; r: SByte; q: SByte);
begin
z_MultiTexCoord4bOES_ovr_0(texture, s, t, r, q);
end;
public z_MultiTexCoord4bvOES_adr := GetFuncAdr('glMultiTexCoord4bvOES');
public z_MultiTexCoord4bvOES_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; var coords: SByte)>(z_MultiTexCoord4bvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4bvOES(texture: TextureUnit; coords: array of SByte);
begin
z_MultiTexCoord4bvOES_ovr_0(texture, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4bvOES(texture: TextureUnit; var coords: SByte);
begin
z_MultiTexCoord4bvOES_ovr_0(texture, coords);
end;
public z_MultiTexCoord4bvOES_ovr_2 := GetFuncOrNil&<procedure(texture: TextureUnit; coords: IntPtr)>(z_MultiTexCoord4bvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4bvOES(texture: TextureUnit; coords: IntPtr);
begin
z_MultiTexCoord4bvOES_ovr_2(texture, coords);
end;
public z_TexCoord1bOES_adr := GetFuncAdr('glTexCoord1bOES');
public z_TexCoord1bOES_ovr_0 := GetFuncOrNil&<procedure(s: SByte)>(z_TexCoord1bOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1bOES(s: SByte);
begin
z_TexCoord1bOES_ovr_0(s);
end;
public z_TexCoord1bvOES_adr := GetFuncAdr('glTexCoord1bvOES');
public z_TexCoord1bvOES_ovr_0 := GetFuncOrNil&<procedure(var coords: SByte)>(z_TexCoord1bvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1bvOES(coords: array of SByte);
begin
z_TexCoord1bvOES_ovr_0(coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1bvOES(var coords: SByte);
begin
z_TexCoord1bvOES_ovr_0(coords);
end;
public z_TexCoord1bvOES_ovr_2 := GetFuncOrNil&<procedure(coords: IntPtr)>(z_TexCoord1bvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1bvOES(coords: IntPtr);
begin
z_TexCoord1bvOES_ovr_2(coords);
end;
public z_TexCoord2bOES_adr := GetFuncAdr('glTexCoord2bOES');
public z_TexCoord2bOES_ovr_0 := GetFuncOrNil&<procedure(s: SByte; t: SByte)>(z_TexCoord2bOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2bOES(s: SByte; t: SByte);
begin
z_TexCoord2bOES_ovr_0(s, t);
end;
public z_TexCoord2bvOES_adr := GetFuncAdr('glTexCoord2bvOES');
public z_TexCoord2bvOES_ovr_0 := GetFuncOrNil&<procedure(var coords: SByte)>(z_TexCoord2bvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2bvOES(coords: array of SByte);
begin
z_TexCoord2bvOES_ovr_0(coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2bvOES(var coords: SByte);
begin
z_TexCoord2bvOES_ovr_0(coords);
end;
public z_TexCoord2bvOES_ovr_2 := GetFuncOrNil&<procedure(coords: IntPtr)>(z_TexCoord2bvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2bvOES(coords: IntPtr);
begin
z_TexCoord2bvOES_ovr_2(coords);
end;
public z_TexCoord3bOES_adr := GetFuncAdr('glTexCoord3bOES');
public z_TexCoord3bOES_ovr_0 := GetFuncOrNil&<procedure(s: SByte; t: SByte; r: SByte)>(z_TexCoord3bOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3bOES(s: SByte; t: SByte; r: SByte);
begin
z_TexCoord3bOES_ovr_0(s, t, r);
end;
public z_TexCoord3bvOES_adr := GetFuncAdr('glTexCoord3bvOES');
public z_TexCoord3bvOES_ovr_0 := GetFuncOrNil&<procedure(var coords: SByte)>(z_TexCoord3bvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3bvOES(coords: array of SByte);
begin
z_TexCoord3bvOES_ovr_0(coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3bvOES(var coords: SByte);
begin
z_TexCoord3bvOES_ovr_0(coords);
end;
public z_TexCoord3bvOES_ovr_2 := GetFuncOrNil&<procedure(coords: IntPtr)>(z_TexCoord3bvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3bvOES(coords: IntPtr);
begin
z_TexCoord3bvOES_ovr_2(coords);
end;
public z_TexCoord4bOES_adr := GetFuncAdr('glTexCoord4bOES');
public z_TexCoord4bOES_ovr_0 := GetFuncOrNil&<procedure(s: SByte; t: SByte; r: SByte; q: SByte)>(z_TexCoord4bOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4bOES(s: SByte; t: SByte; r: SByte; q: SByte);
begin
z_TexCoord4bOES_ovr_0(s, t, r, q);
end;
public z_TexCoord4bvOES_adr := GetFuncAdr('glTexCoord4bvOES');
public z_TexCoord4bvOES_ovr_0 := GetFuncOrNil&<procedure(var coords: SByte)>(z_TexCoord4bvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4bvOES(coords: array of SByte);
begin
z_TexCoord4bvOES_ovr_0(coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4bvOES(var coords: SByte);
begin
z_TexCoord4bvOES_ovr_0(coords);
end;
public z_TexCoord4bvOES_ovr_2 := GetFuncOrNil&<procedure(coords: IntPtr)>(z_TexCoord4bvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4bvOES(coords: IntPtr);
begin
z_TexCoord4bvOES_ovr_2(coords);
end;
public z_Vertex2bOES_adr := GetFuncAdr('glVertex2bOES');
public z_Vertex2bOES_ovr_0 := GetFuncOrNil&<procedure(x: SByte; y: SByte)>(z_Vertex2bOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2bOES(x: SByte; y: SByte);
begin
z_Vertex2bOES_ovr_0(x, y);
end;
public z_Vertex2bvOES_adr := GetFuncAdr('glVertex2bvOES');
public z_Vertex2bvOES_ovr_0 := GetFuncOrNil&<procedure(var coords: SByte)>(z_Vertex2bvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2bvOES(coords: array of SByte);
begin
z_Vertex2bvOES_ovr_0(coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2bvOES(var coords: SByte);
begin
z_Vertex2bvOES_ovr_0(coords);
end;
public z_Vertex2bvOES_ovr_2 := GetFuncOrNil&<procedure(coords: IntPtr)>(z_Vertex2bvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2bvOES(coords: IntPtr);
begin
z_Vertex2bvOES_ovr_2(coords);
end;
public z_Vertex3bOES_adr := GetFuncAdr('glVertex3bOES');
public z_Vertex3bOES_ovr_0 := GetFuncOrNil&<procedure(x: SByte; y: SByte; z: SByte)>(z_Vertex3bOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3bOES(x: SByte; y: SByte; z: SByte);
begin
z_Vertex3bOES_ovr_0(x, y, z);
end;
public z_Vertex3bvOES_adr := GetFuncAdr('glVertex3bvOES');
public z_Vertex3bvOES_ovr_0 := GetFuncOrNil&<procedure(var coords: SByte)>(z_Vertex3bvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3bvOES(coords: array of SByte);
begin
z_Vertex3bvOES_ovr_0(coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3bvOES(var coords: SByte);
begin
z_Vertex3bvOES_ovr_0(coords);
end;
public z_Vertex3bvOES_ovr_2 := GetFuncOrNil&<procedure(coords: IntPtr)>(z_Vertex3bvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3bvOES(coords: IntPtr);
begin
z_Vertex3bvOES_ovr_2(coords);
end;
public z_Vertex4bOES_adr := GetFuncAdr('glVertex4bOES');
public z_Vertex4bOES_ovr_0 := GetFuncOrNil&<procedure(x: SByte; y: SByte; z: SByte; w: SByte)>(z_Vertex4bOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4bOES(x: SByte; y: SByte; z: SByte; w: SByte);
begin
z_Vertex4bOES_ovr_0(x, y, z, w);
end;
public z_Vertex4bvOES_adr := GetFuncAdr('glVertex4bvOES');
public z_Vertex4bvOES_ovr_0 := GetFuncOrNil&<procedure(var coords: SByte)>(z_Vertex4bvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4bvOES(coords: array of SByte);
begin
z_Vertex4bvOES_ovr_0(coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4bvOES(var coords: SByte);
begin
z_Vertex4bvOES_ovr_0(coords);
end;
public z_Vertex4bvOES_ovr_2 := GetFuncOrNil&<procedure(coords: IntPtr)>(z_Vertex4bvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4bvOES(coords: IntPtr);
begin
z_Vertex4bvOES_ovr_2(coords);
end;
end;
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);
public z_AlphaFuncxOES_adr := GetFuncAdr('glAlphaFuncxOES');
public z_AlphaFuncxOES_ovr_0 := GetFuncOrNil&<procedure(func: AlphaFunction; ref: Fixed)>(z_AlphaFuncxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure AlphaFuncxOES(func: AlphaFunction; ref: Fixed);
begin
z_AlphaFuncxOES_ovr_0(func, ref);
end;
public z_ClearColorxOES_adr := GetFuncAdr('glClearColorxOES');
public z_ClearColorxOES_ovr_0 := GetFuncOrNil&<procedure(red: Fixed; green: Fixed; blue: Fixed; alpha: Fixed)>(z_ClearColorxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearColorxOES(red: Fixed; green: Fixed; blue: Fixed; alpha: Fixed);
begin
z_ClearColorxOES_ovr_0(red, green, blue, alpha);
end;
public z_ClearDepthxOES_adr := GetFuncAdr('glClearDepthxOES');
public z_ClearDepthxOES_ovr_0 := GetFuncOrNil&<procedure(depth: Fixed)>(z_ClearDepthxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearDepthxOES(depth: Fixed);
begin
z_ClearDepthxOES_ovr_0(depth);
end;
public z_ClipPlanexOES_adr := GetFuncAdr('glClipPlanexOES');
public z_ClipPlanexOES_ovr_0 := GetFuncOrNil&<procedure(plane: ClipPlaneName; var equation: Fixed)>(z_ClipPlanexOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClipPlanexOES(plane: ClipPlaneName; equation: array of Fixed);
begin
z_ClipPlanexOES_ovr_0(plane, equation[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClipPlanexOES(plane: ClipPlaneName; var equation: Fixed);
begin
z_ClipPlanexOES_ovr_0(plane, equation);
end;
public z_ClipPlanexOES_ovr_2 := GetFuncOrNil&<procedure(plane: ClipPlaneName; equation: IntPtr)>(z_ClipPlanexOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClipPlanexOES(plane: ClipPlaneName; equation: IntPtr);
begin
z_ClipPlanexOES_ovr_2(plane, equation);
end;
public z_Color4xOES_adr := GetFuncAdr('glColor4xOES');
public z_Color4xOES_ovr_0 := GetFuncOrNil&<procedure(red: Fixed; green: Fixed; blue: Fixed; alpha: Fixed)>(z_Color4xOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4xOES(red: Fixed; green: Fixed; blue: Fixed; alpha: Fixed);
begin
z_Color4xOES_ovr_0(red, green, blue, alpha);
end;
public z_DepthRangexOES_adr := GetFuncAdr('glDepthRangexOES');
public z_DepthRangexOES_ovr_0 := GetFuncOrNil&<procedure(n: Fixed; f: Fixed)>(z_DepthRangexOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthRangexOES(n: Fixed; f: Fixed);
begin
z_DepthRangexOES_ovr_0(n, f);
end;
public z_FogxOES_adr := GetFuncAdr('glFogxOES');
public z_FogxOES_ovr_0 := GetFuncOrNil&<procedure(pname: FogPName; param: Fixed)>(z_FogxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogxOES(pname: FogPName; param: Fixed);
begin
z_FogxOES_ovr_0(pname, param);
end;
public z_FogxvOES_adr := GetFuncAdr('glFogxvOES');
public z_FogxvOES_ovr_0 := GetFuncOrNil&<procedure(pname: FogPName; var param: Fixed)>(z_FogxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogxvOES(pname: FogPName; param: array of Fixed);
begin
z_FogxvOES_ovr_0(pname, param[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogxvOES(pname: FogPName; var param: Fixed);
begin
z_FogxvOES_ovr_0(pname, param);
end;
public z_FogxvOES_ovr_2 := GetFuncOrNil&<procedure(pname: FogPName; param: IntPtr)>(z_FogxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogxvOES(pname: FogPName; param: IntPtr);
begin
z_FogxvOES_ovr_2(pname, param);
end;
public z_FrustumxOES_adr := GetFuncAdr('glFrustumxOES');
public z_FrustumxOES_ovr_0 := GetFuncOrNil&<procedure(l: Fixed; r: Fixed; b: Fixed; t: Fixed; n: Fixed; f: Fixed)>(z_FrustumxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FrustumxOES(l: Fixed; r: Fixed; b: Fixed; t: Fixed; n: Fixed; f: Fixed);
begin
z_FrustumxOES_ovr_0(l, r, b, t, n, f);
end;
public z_GetClipPlanexOES_adr := GetFuncAdr('glGetClipPlanexOES');
public z_GetClipPlanexOES_ovr_0 := GetFuncOrNil&<procedure(plane: ClipPlaneName; var equation: Fixed)>(z_GetClipPlanexOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetClipPlanexOES(plane: ClipPlaneName; equation: array of Fixed);
begin
z_GetClipPlanexOES_ovr_0(plane, equation[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetClipPlanexOES(plane: ClipPlaneName; var equation: Fixed);
begin
z_GetClipPlanexOES_ovr_0(plane, equation);
end;
public z_GetClipPlanexOES_ovr_2 := GetFuncOrNil&<procedure(plane: ClipPlaneName; equation: IntPtr)>(z_GetClipPlanexOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetClipPlanexOES(plane: ClipPlaneName; equation: IntPtr);
begin
z_GetClipPlanexOES_ovr_2(plane, equation);
end;
public z_GetFixedvOES_adr := GetFuncAdr('glGetFixedvOES');
public z_GetFixedvOES_ovr_0 := GetFuncOrNil&<procedure(pname: GetPName; var ¶ms: Fixed)>(z_GetFixedvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFixedvOES(pname: GetPName; ¶ms: array of Fixed);
begin
z_GetFixedvOES_ovr_0(pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFixedvOES(pname: GetPName; var ¶ms: Fixed);
begin
z_GetFixedvOES_ovr_0(pname, ¶ms);
end;
public z_GetFixedvOES_ovr_2 := GetFuncOrNil&<procedure(pname: GetPName; ¶ms: IntPtr)>(z_GetFixedvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFixedvOES(pname: GetPName; ¶ms: IntPtr);
begin
z_GetFixedvOES_ovr_2(pname, ¶ms);
end;
public z_GetTexEnvxvOES_adr := GetFuncAdr('glGetTexEnvxvOES');
public z_GetTexEnvxvOES_ovr_0 := GetFuncOrNil&<procedure(target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: Fixed)>(z_GetTexEnvxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexEnvxvOES(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: array of Fixed);
begin
z_GetTexEnvxvOES_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexEnvxvOES(target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: Fixed);
begin
z_GetTexEnvxvOES_ovr_0(target, pname, ¶ms);
end;
public z_GetTexEnvxvOES_ovr_2 := GetFuncOrNil&<procedure(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr)>(z_GetTexEnvxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexEnvxvOES(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
begin
z_GetTexEnvxvOES_ovr_2(target, pname, ¶ms);
end;
public z_GetTexParameterxvOES_adr := GetFuncAdr('glGetTexParameterxvOES');
public z_GetTexParameterxvOES_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; pname: GetTextureParameter; var ¶ms: Fixed)>(z_GetTexParameterxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterxvOES(target: TextureTarget; pname: GetTextureParameter; ¶ms: array of Fixed);
begin
z_GetTexParameterxvOES_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterxvOES(target: TextureTarget; pname: GetTextureParameter; var ¶ms: Fixed);
begin
z_GetTexParameterxvOES_ovr_0(target, pname, ¶ms);
end;
public z_GetTexParameterxvOES_ovr_2 := GetFuncOrNil&<procedure(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetTexParameterxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexParameterxvOES(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
begin
z_GetTexParameterxvOES_ovr_2(target, pname, ¶ms);
end;
public z_LightModelxOES_adr := GetFuncAdr('glLightModelxOES');
public z_LightModelxOES_ovr_0 := GetFuncOrNil&<procedure(pname: LightModelParameter; param: Fixed)>(z_LightModelxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightModelxOES(pname: LightModelParameter; param: Fixed);
begin
z_LightModelxOES_ovr_0(pname, param);
end;
public z_LightModelxvOES_adr := GetFuncAdr('glLightModelxvOES');
public z_LightModelxvOES_ovr_0 := GetFuncOrNil&<procedure(pname: LightModelParameter; var param: Fixed)>(z_LightModelxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightModelxvOES(pname: LightModelParameter; param: array of Fixed);
begin
z_LightModelxvOES_ovr_0(pname, param[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightModelxvOES(pname: LightModelParameter; var param: Fixed);
begin
z_LightModelxvOES_ovr_0(pname, param);
end;
public z_LightModelxvOES_ovr_2 := GetFuncOrNil&<procedure(pname: LightModelParameter; param: IntPtr)>(z_LightModelxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightModelxvOES(pname: LightModelParameter; param: IntPtr);
begin
z_LightModelxvOES_ovr_2(pname, param);
end;
public z_LightxOES_adr := GetFuncAdr('glLightxOES');
public z_LightxOES_ovr_0 := GetFuncOrNil&<procedure(light: LightName; pname: LightParameter; param: Fixed)>(z_LightxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightxOES(light: LightName; pname: LightParameter; param: Fixed);
begin
z_LightxOES_ovr_0(light, pname, param);
end;
public z_LightxvOES_adr := GetFuncAdr('glLightxvOES');
public z_LightxvOES_ovr_0 := GetFuncOrNil&<procedure(light: LightName; pname: LightParameter; var ¶ms: Fixed)>(z_LightxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightxvOES(light: LightName; pname: LightParameter; ¶ms: array of Fixed);
begin
z_LightxvOES_ovr_0(light, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightxvOES(light: LightName; pname: LightParameter; var ¶ms: Fixed);
begin
z_LightxvOES_ovr_0(light, pname, ¶ms);
end;
public z_LightxvOES_ovr_2 := GetFuncOrNil&<procedure(light: LightName; pname: LightParameter; ¶ms: IntPtr)>(z_LightxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightxvOES(light: LightName; pname: LightParameter; ¶ms: IntPtr);
begin
z_LightxvOES_ovr_2(light, pname, ¶ms);
end;
public z_LineWidthxOES_adr := GetFuncAdr('glLineWidthxOES');
public z_LineWidthxOES_ovr_0 := GetFuncOrNil&<procedure(width: Fixed)>(z_LineWidthxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LineWidthxOES(width: Fixed);
begin
z_LineWidthxOES_ovr_0(width);
end;
public z_LoadMatrixxOES_adr := GetFuncAdr('glLoadMatrixxOES');
public z_LoadMatrixxOES_ovr_0 := GetFuncOrNil&<procedure(var m: Fixed)>(z_LoadMatrixxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadMatrixxOES(m: array of Fixed);
begin
z_LoadMatrixxOES_ovr_0(m[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadMatrixxOES(var m: Fixed);
begin
z_LoadMatrixxOES_ovr_0(m);
end;
public z_LoadMatrixxOES_ovr_2 := GetFuncOrNil&<procedure(m: IntPtr)>(z_LoadMatrixxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadMatrixxOES(m: IntPtr);
begin
z_LoadMatrixxOES_ovr_2(m);
end;
public z_MaterialxOES_adr := GetFuncAdr('glMaterialxOES');
public z_MaterialxOES_ovr_0 := GetFuncOrNil&<procedure(face: DummyEnum; pname: MaterialParameter; param: Fixed)>(z_MaterialxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MaterialxOES(face: DummyEnum; pname: MaterialParameter; param: Fixed);
begin
z_MaterialxOES_ovr_0(face, pname, param);
end;
public z_MaterialxvOES_adr := GetFuncAdr('glMaterialxvOES');
public z_MaterialxvOES_ovr_0 := GetFuncOrNil&<procedure(face: DummyEnum; pname: MaterialParameter; var param: Fixed)>(z_MaterialxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MaterialxvOES(face: DummyEnum; pname: MaterialParameter; param: array of Fixed);
begin
z_MaterialxvOES_ovr_0(face, pname, param[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MaterialxvOES(face: DummyEnum; pname: MaterialParameter; var param: Fixed);
begin
z_MaterialxvOES_ovr_0(face, pname, param);
end;
public z_MaterialxvOES_ovr_2 := GetFuncOrNil&<procedure(face: DummyEnum; pname: MaterialParameter; param: IntPtr)>(z_MaterialxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MaterialxvOES(face: DummyEnum; pname: MaterialParameter; param: IntPtr);
begin
z_MaterialxvOES_ovr_2(face, pname, param);
end;
public z_MultMatrixxOES_adr := GetFuncAdr('glMultMatrixxOES');
public z_MultMatrixxOES_ovr_0 := GetFuncOrNil&<procedure(var m: Fixed)>(z_MultMatrixxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultMatrixxOES(m: array of Fixed);
begin
z_MultMatrixxOES_ovr_0(m[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultMatrixxOES(var m: Fixed);
begin
z_MultMatrixxOES_ovr_0(m);
end;
public z_MultMatrixxOES_ovr_2 := GetFuncOrNil&<procedure(m: IntPtr)>(z_MultMatrixxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultMatrixxOES(m: IntPtr);
begin
z_MultMatrixxOES_ovr_2(m);
end;
public z_MultiTexCoord4xOES_adr := GetFuncAdr('glMultiTexCoord4xOES');
public z_MultiTexCoord4xOES_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; s: Fixed; t: Fixed; r: Fixed; q: Fixed)>(z_MultiTexCoord4xOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4xOES(texture: TextureUnit; s: Fixed; t: Fixed; r: Fixed; q: Fixed);
begin
z_MultiTexCoord4xOES_ovr_0(texture, s, t, r, q);
end;
public z_Normal3xOES_adr := GetFuncAdr('glNormal3xOES');
public z_Normal3xOES_ovr_0 := GetFuncOrNil&<procedure(nx: Fixed; ny: Fixed; nz: Fixed)>(z_Normal3xOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3xOES(nx: Fixed; ny: Fixed; nz: Fixed);
begin
z_Normal3xOES_ovr_0(nx, ny, nz);
end;
public z_OrthoxOES_adr := GetFuncAdr('glOrthoxOES');
public z_OrthoxOES_ovr_0 := GetFuncOrNil&<procedure(l: Fixed; r: Fixed; b: Fixed; t: Fixed; n: Fixed; f: Fixed)>(z_OrthoxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure OrthoxOES(l: Fixed; r: Fixed; b: Fixed; t: Fixed; n: Fixed; f: Fixed);
begin
z_OrthoxOES_ovr_0(l, r, b, t, n, f);
end;
public z_PointParameterxvOES_adr := GetFuncAdr('glPointParameterxvOES');
public z_PointParameterxvOES_ovr_0 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; var ¶ms: Fixed)>(z_PointParameterxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterxvOES(pname: PointParameterNameARB; ¶ms: array of Fixed);
begin
z_PointParameterxvOES_ovr_0(pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterxvOES(pname: PointParameterNameARB; var ¶ms: Fixed);
begin
z_PointParameterxvOES_ovr_0(pname, ¶ms);
end;
public z_PointParameterxvOES_ovr_2 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; ¶ms: IntPtr)>(z_PointParameterxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterxvOES(pname: PointParameterNameARB; ¶ms: IntPtr);
begin
z_PointParameterxvOES_ovr_2(pname, ¶ms);
end;
public z_PointSizexOES_adr := GetFuncAdr('glPointSizexOES');
public z_PointSizexOES_ovr_0 := GetFuncOrNil&<procedure(size: Fixed)>(z_PointSizexOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointSizexOES(size: Fixed);
begin
z_PointSizexOES_ovr_0(size);
end;
public z_PolygonOffsetxOES_adr := GetFuncAdr('glPolygonOffsetxOES');
public z_PolygonOffsetxOES_ovr_0 := GetFuncOrNil&<procedure(factor: Fixed; units: Fixed)>(z_PolygonOffsetxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PolygonOffsetxOES(factor: Fixed; units: Fixed);
begin
z_PolygonOffsetxOES_ovr_0(factor, units);
end;
public z_RotatexOES_adr := GetFuncAdr('glRotatexOES');
public z_RotatexOES_ovr_0 := GetFuncOrNil&<procedure(angle: Fixed; x: Fixed; y: Fixed; z: Fixed)>(z_RotatexOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RotatexOES(angle: Fixed; x: Fixed; y: Fixed; z: Fixed);
begin
z_RotatexOES_ovr_0(angle, x, y, z);
end;
public z_ScalexOES_adr := GetFuncAdr('glScalexOES');
public z_ScalexOES_ovr_0 := GetFuncOrNil&<procedure(x: Fixed; y: Fixed; z: Fixed)>(z_ScalexOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ScalexOES(x: Fixed; y: Fixed; z: Fixed);
begin
z_ScalexOES_ovr_0(x, y, z);
end;
public z_TexEnvxOES_adr := GetFuncAdr('glTexEnvxOES');
public z_TexEnvxOES_ovr_0 := GetFuncOrNil&<procedure(target: TextureEnvTarget; pname: TextureEnvParameter; param: Fixed)>(z_TexEnvxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexEnvxOES(target: TextureEnvTarget; pname: TextureEnvParameter; param: Fixed);
begin
z_TexEnvxOES_ovr_0(target, pname, param);
end;
public z_TexEnvxvOES_adr := GetFuncAdr('glTexEnvxvOES');
public z_TexEnvxvOES_ovr_0 := GetFuncOrNil&<procedure(target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: Fixed)>(z_TexEnvxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexEnvxvOES(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: array of Fixed);
begin
z_TexEnvxvOES_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexEnvxvOES(target: TextureEnvTarget; pname: TextureEnvParameter; var ¶ms: Fixed);
begin
z_TexEnvxvOES_ovr_0(target, pname, ¶ms);
end;
public z_TexEnvxvOES_ovr_2 := GetFuncOrNil&<procedure(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr)>(z_TexEnvxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexEnvxvOES(target: TextureEnvTarget; pname: TextureEnvParameter; ¶ms: IntPtr);
begin
z_TexEnvxvOES_ovr_2(target, pname, ¶ms);
end;
public z_TexParameterxOES_adr := GetFuncAdr('glTexParameterxOES');
public z_TexParameterxOES_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; pname: GetTextureParameter; param: Fixed)>(z_TexParameterxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterxOES(target: TextureTarget; pname: GetTextureParameter; param: Fixed);
begin
z_TexParameterxOES_ovr_0(target, pname, param);
end;
public z_TexParameterxvOES_adr := GetFuncAdr('glTexParameterxvOES');
public z_TexParameterxvOES_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; pname: GetTextureParameter; var ¶ms: Fixed)>(z_TexParameterxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterxvOES(target: TextureTarget; pname: GetTextureParameter; ¶ms: array of Fixed);
begin
z_TexParameterxvOES_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterxvOES(target: TextureTarget; pname: GetTextureParameter; var ¶ms: Fixed);
begin
z_TexParameterxvOES_ovr_0(target, pname, ¶ms);
end;
public z_TexParameterxvOES_ovr_2 := GetFuncOrNil&<procedure(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr)>(z_TexParameterxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexParameterxvOES(target: TextureTarget; pname: GetTextureParameter; ¶ms: IntPtr);
begin
z_TexParameterxvOES_ovr_2(target, pname, ¶ms);
end;
public z_TranslatexOES_adr := GetFuncAdr('glTranslatexOES');
public z_TranslatexOES_ovr_0 := GetFuncOrNil&<procedure(x: Fixed; y: Fixed; z: Fixed)>(z_TranslatexOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TranslatexOES(x: Fixed; y: Fixed; z: Fixed);
begin
z_TranslatexOES_ovr_0(x, y, z);
end;
public z_AccumxOES_adr := GetFuncAdr('glAccumxOES');
public z_AccumxOES_ovr_0 := GetFuncOrNil&<procedure(op: DummyEnum; value: Fixed)>(z_AccumxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure AccumxOES(op: DummyEnum; value: Fixed);
begin
z_AccumxOES_ovr_0(op, value);
end;
public z_BitmapxOES_adr := GetFuncAdr('glBitmapxOES');
public z_BitmapxOES_ovr_0 := GetFuncOrNil&<procedure(width: Int32; height: Int32; xorig: Fixed; yorig: Fixed; xmove: Fixed; ymove: Fixed; var bitmap: Byte)>(z_BitmapxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BitmapxOES(width: Int32; height: Int32; xorig: Fixed; yorig: Fixed; xmove: Fixed; ymove: Fixed; bitmap: array of Byte);
begin
z_BitmapxOES_ovr_0(width, height, xorig, yorig, xmove, ymove, bitmap[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BitmapxOES(width: Int32; height: Int32; xorig: Fixed; yorig: Fixed; xmove: Fixed; ymove: Fixed; var bitmap: Byte);
begin
z_BitmapxOES_ovr_0(width, height, xorig, yorig, xmove, ymove, bitmap);
end;
public z_BitmapxOES_ovr_2 := GetFuncOrNil&<procedure(width: Int32; height: Int32; xorig: Fixed; yorig: Fixed; xmove: Fixed; ymove: Fixed; bitmap: IntPtr)>(z_BitmapxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BitmapxOES(width: Int32; height: Int32; xorig: Fixed; yorig: Fixed; xmove: Fixed; ymove: Fixed; bitmap: IntPtr);
begin
z_BitmapxOES_ovr_2(width, height, xorig, yorig, xmove, ymove, bitmap);
end;
public z_BlendColorxOES_adr := GetFuncAdr('glBlendColorxOES');
public z_BlendColorxOES_ovr_0 := GetFuncOrNil&<procedure(red: Fixed; green: Fixed; blue: Fixed; alpha: Fixed)>(z_BlendColorxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BlendColorxOES(red: Fixed; green: Fixed; blue: Fixed; alpha: Fixed);
begin
z_BlendColorxOES_ovr_0(red, green, blue, alpha);
end;
public z_ClearAccumxOES_adr := GetFuncAdr('glClearAccumxOES');
public z_ClearAccumxOES_ovr_0 := GetFuncOrNil&<procedure(red: Fixed; green: Fixed; blue: Fixed; alpha: Fixed)>(z_ClearAccumxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearAccumxOES(red: Fixed; green: Fixed; blue: Fixed; alpha: Fixed);
begin
z_ClearAccumxOES_ovr_0(red, green, blue, alpha);
end;
public z_Color3xOES_adr := GetFuncAdr('glColor3xOES');
public z_Color3xOES_ovr_0 := GetFuncOrNil&<procedure(red: Fixed; green: Fixed; blue: Fixed)>(z_Color3xOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3xOES(red: Fixed; green: Fixed; blue: Fixed);
begin
z_Color3xOES_ovr_0(red, green, blue);
end;
public z_Color3xvOES_adr := GetFuncAdr('glColor3xvOES');
public z_Color3xvOES_ovr_0 := GetFuncOrNil&<procedure(var components: Fixed)>(z_Color3xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3xvOES(components: array of Fixed);
begin
z_Color3xvOES_ovr_0(components[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3xvOES(var components: Fixed);
begin
z_Color3xvOES_ovr_0(components);
end;
public z_Color3xvOES_ovr_2 := GetFuncOrNil&<procedure(components: IntPtr)>(z_Color3xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3xvOES(components: IntPtr);
begin
z_Color3xvOES_ovr_2(components);
end;
public z_Color4xvOES_adr := GetFuncAdr('glColor4xvOES');
public z_Color4xvOES_ovr_0 := GetFuncOrNil&<procedure(var components: Fixed)>(z_Color4xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4xvOES(components: array of Fixed);
begin
z_Color4xvOES_ovr_0(components[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4xvOES(var components: Fixed);
begin
z_Color4xvOES_ovr_0(components);
end;
public z_Color4xvOES_ovr_2 := GetFuncOrNil&<procedure(components: IntPtr)>(z_Color4xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4xvOES(components: IntPtr);
begin
z_Color4xvOES_ovr_2(components);
end;
public z_ConvolutionParameterxOES_adr := GetFuncAdr('glConvolutionParameterxOES');
public z_ConvolutionParameterxOES_ovr_0 := GetFuncOrNil&<procedure(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; param: Fixed)>(z_ConvolutionParameterxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameterxOES(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; param: Fixed);
begin
z_ConvolutionParameterxOES_ovr_0(target, pname, param);
end;
public z_ConvolutionParameterxvOES_adr := GetFuncAdr('glConvolutionParameterxvOES');
public z_ConvolutionParameterxvOES_ovr_0 := GetFuncOrNil&<procedure(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; var ¶ms: Fixed)>(z_ConvolutionParameterxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameterxvOES(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: array of Fixed);
begin
z_ConvolutionParameterxvOES_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameterxvOES(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; var ¶ms: Fixed);
begin
z_ConvolutionParameterxvOES_ovr_0(target, pname, ¶ms);
end;
public z_ConvolutionParameterxvOES_ovr_2 := GetFuncOrNil&<procedure(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: IntPtr)>(z_ConvolutionParameterxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ConvolutionParameterxvOES(target: ConvolutionTargetEXT; pname: ConvolutionParameterEXT; ¶ms: IntPtr);
begin
z_ConvolutionParameterxvOES_ovr_2(target, pname, ¶ms);
end;
public z_EvalCoord1xOES_adr := GetFuncAdr('glEvalCoord1xOES');
public z_EvalCoord1xOES_ovr_0 := GetFuncOrNil&<procedure(u: Fixed)>(z_EvalCoord1xOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord1xOES(u: Fixed);
begin
z_EvalCoord1xOES_ovr_0(u);
end;
public z_EvalCoord1xvOES_adr := GetFuncAdr('glEvalCoord1xvOES');
public z_EvalCoord1xvOES_ovr_0 := GetFuncOrNil&<procedure(var coords: Fixed)>(z_EvalCoord1xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord1xvOES(coords: array of Fixed);
begin
z_EvalCoord1xvOES_ovr_0(coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord1xvOES(var coords: Fixed);
begin
z_EvalCoord1xvOES_ovr_0(coords);
end;
public z_EvalCoord1xvOES_ovr_2 := GetFuncOrNil&<procedure(coords: IntPtr)>(z_EvalCoord1xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord1xvOES(coords: IntPtr);
begin
z_EvalCoord1xvOES_ovr_2(coords);
end;
public z_EvalCoord2xOES_adr := GetFuncAdr('glEvalCoord2xOES');
public z_EvalCoord2xOES_ovr_0 := GetFuncOrNil&<procedure(u: Fixed; v: Fixed)>(z_EvalCoord2xOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord2xOES(u: Fixed; v: Fixed);
begin
z_EvalCoord2xOES_ovr_0(u, v);
end;
public z_EvalCoord2xvOES_adr := GetFuncAdr('glEvalCoord2xvOES');
public z_EvalCoord2xvOES_ovr_0 := GetFuncOrNil&<procedure(var coords: Fixed)>(z_EvalCoord2xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord2xvOES(coords: array of Fixed);
begin
z_EvalCoord2xvOES_ovr_0(coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord2xvOES(var coords: Fixed);
begin
z_EvalCoord2xvOES_ovr_0(coords);
end;
public z_EvalCoord2xvOES_ovr_2 := GetFuncOrNil&<procedure(coords: IntPtr)>(z_EvalCoord2xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure EvalCoord2xvOES(coords: IntPtr);
begin
z_EvalCoord2xvOES_ovr_2(coords);
end;
public z_FeedbackBufferxOES_adr := GetFuncAdr('glFeedbackBufferxOES');
public z_FeedbackBufferxOES_ovr_0 := GetFuncOrNil&<procedure(n: Int32; &type: DummyEnum; var buffer: Fixed)>(z_FeedbackBufferxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FeedbackBufferxOES(n: Int32; &type: DummyEnum; buffer: array of Fixed);
begin
z_FeedbackBufferxOES_ovr_0(n, &type, buffer[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FeedbackBufferxOES(n: Int32; &type: DummyEnum; var buffer: Fixed);
begin
z_FeedbackBufferxOES_ovr_0(n, &type, buffer);
end;
public z_FeedbackBufferxOES_ovr_2 := GetFuncOrNil&<procedure(n: Int32; &type: DummyEnum; buffer: IntPtr)>(z_FeedbackBufferxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FeedbackBufferxOES(n: Int32; &type: DummyEnum; buffer: IntPtr);
begin
z_FeedbackBufferxOES_ovr_2(n, &type, buffer);
end;
public z_GetConvolutionParameterxvOES_adr := GetFuncAdr('glGetConvolutionParameterxvOES');
public z_GetConvolutionParameterxvOES_ovr_0 := GetFuncOrNil&<procedure(target: DummyEnum; pname: DummyEnum; var ¶ms: Fixed)>(z_GetConvolutionParameterxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetConvolutionParameterxvOES(target: DummyEnum; pname: DummyEnum; ¶ms: array of Fixed);
begin
z_GetConvolutionParameterxvOES_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetConvolutionParameterxvOES(target: DummyEnum; pname: DummyEnum; var ¶ms: Fixed);
begin
z_GetConvolutionParameterxvOES_ovr_0(target, pname, ¶ms);
end;
public z_GetConvolutionParameterxvOES_ovr_2 := GetFuncOrNil&<procedure(target: DummyEnum; pname: DummyEnum; ¶ms: IntPtr)>(z_GetConvolutionParameterxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetConvolutionParameterxvOES(target: DummyEnum; pname: DummyEnum; ¶ms: IntPtr);
begin
z_GetConvolutionParameterxvOES_ovr_2(target, pname, ¶ms);
end;
public z_GetHistogramParameterxvOES_adr := GetFuncAdr('glGetHistogramParameterxvOES');
public z_GetHistogramParameterxvOES_ovr_0 := GetFuncOrNil&<procedure(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; var ¶ms: Fixed)>(z_GetHistogramParameterxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetHistogramParameterxvOES(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: array of Fixed);
begin
z_GetHistogramParameterxvOES_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetHistogramParameterxvOES(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; var ¶ms: Fixed);
begin
z_GetHistogramParameterxvOES_ovr_0(target, pname, ¶ms);
end;
public z_GetHistogramParameterxvOES_ovr_2 := GetFuncOrNil&<procedure(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: IntPtr)>(z_GetHistogramParameterxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetHistogramParameterxvOES(target: HistogramTargetEXT; pname: GetHistogramParameterPNameEXT; ¶ms: IntPtr);
begin
z_GetHistogramParameterxvOES_ovr_2(target, pname, ¶ms);
end;
public z_GetLightxOES_adr := GetFuncAdr('glGetLightxOES');
public z_GetLightxOES_ovr_0 := GetFuncOrNil&<procedure(light: LightName; pname: LightParameter; var ¶ms: Fixed)>(z_GetLightxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLightxOES(light: LightName; pname: LightParameter; ¶ms: array of Fixed);
begin
z_GetLightxOES_ovr_0(light, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLightxOES(light: LightName; pname: LightParameter; var ¶ms: Fixed);
begin
z_GetLightxOES_ovr_0(light, pname, ¶ms);
end;
public z_GetLightxOES_ovr_2 := GetFuncOrNil&<procedure(light: LightName; pname: LightParameter; ¶ms: IntPtr)>(z_GetLightxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetLightxOES(light: LightName; pname: LightParameter; ¶ms: IntPtr);
begin
z_GetLightxOES_ovr_2(light, pname, ¶ms);
end;
public z_GetMapxvOES_adr := GetFuncAdr('glGetMapxvOES');
public z_GetMapxvOES_ovr_0 := GetFuncOrNil&<procedure(target: MapTarget; query: GetMapQuery; var v: Fixed)>(z_GetMapxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapxvOES(target: MapTarget; query: GetMapQuery; v: array of Fixed);
begin
z_GetMapxvOES_ovr_0(target, query, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapxvOES(target: MapTarget; query: GetMapQuery; var v: Fixed);
begin
z_GetMapxvOES_ovr_0(target, query, v);
end;
public z_GetMapxvOES_ovr_2 := GetFuncOrNil&<procedure(target: MapTarget; query: GetMapQuery; v: IntPtr)>(z_GetMapxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMapxvOES(target: MapTarget; query: GetMapQuery; v: IntPtr);
begin
z_GetMapxvOES_ovr_2(target, query, v);
end;
public z_GetMaterialxOES_adr := GetFuncAdr('glGetMaterialxOES');
public z_GetMaterialxOES_ovr_0 := GetFuncOrNil&<procedure(face: DummyEnum; pname: MaterialParameter; param: Fixed)>(z_GetMaterialxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetMaterialxOES(face: DummyEnum; pname: MaterialParameter; param: Fixed);
begin
z_GetMaterialxOES_ovr_0(face, pname, param);
end;
public z_GetTexGenxvOES_adr := GetFuncAdr('glGetTexGenxvOES');
public z_GetTexGenxvOES_ovr_0 := GetFuncOrNil&<procedure(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: Fixed)>(z_GetTexGenxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexGenxvOES(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of Fixed);
begin
z_GetTexGenxvOES_ovr_0(coord, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexGenxvOES(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: Fixed);
begin
z_GetTexGenxvOES_ovr_0(coord, pname, ¶ms);
end;
public z_GetTexGenxvOES_ovr_2 := GetFuncOrNil&<procedure(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr)>(z_GetTexGenxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexGenxvOES(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
begin
z_GetTexGenxvOES_ovr_2(coord, pname, ¶ms);
end;
public z_GetTexLevelParameterxvOES_adr := GetFuncAdr('glGetTexLevelParameterxvOES');
public z_GetTexLevelParameterxvOES_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: Fixed)>(z_GetTexLevelParameterxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexLevelParameterxvOES(target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: array of Fixed);
begin
z_GetTexLevelParameterxvOES_ovr_0(target, level, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexLevelParameterxvOES(target: TextureTarget; level: Int32; pname: GetTextureParameter; var ¶ms: Fixed);
begin
z_GetTexLevelParameterxvOES_ovr_0(target, level, pname, ¶ms);
end;
public z_GetTexLevelParameterxvOES_ovr_2 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr)>(z_GetTexLevelParameterxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexLevelParameterxvOES(target: TextureTarget; level: Int32; pname: GetTextureParameter; ¶ms: IntPtr);
begin
z_GetTexLevelParameterxvOES_ovr_2(target, level, pname, ¶ms);
end;
public z_IndexxOES_adr := GetFuncAdr('glIndexxOES');
public z_IndexxOES_ovr_0 := GetFuncOrNil&<procedure(component: Fixed)>(z_IndexxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IndexxOES(component: Fixed);
begin
z_IndexxOES_ovr_0(component);
end;
public z_IndexxvOES_adr := GetFuncAdr('glIndexxvOES');
public z_IndexxvOES_ovr_0 := GetFuncOrNil&<procedure(var component: Fixed)>(z_IndexxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IndexxvOES(component: array of Fixed);
begin
z_IndexxvOES_ovr_0(component[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IndexxvOES(var component: Fixed);
begin
z_IndexxvOES_ovr_0(component);
end;
public z_IndexxvOES_ovr_2 := GetFuncOrNil&<procedure(component: IntPtr)>(z_IndexxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IndexxvOES(component: IntPtr);
begin
z_IndexxvOES_ovr_2(component);
end;
public z_LoadTransposeMatrixxOES_adr := GetFuncAdr('glLoadTransposeMatrixxOES');
public z_LoadTransposeMatrixxOES_ovr_0 := GetFuncOrNil&<procedure(var m: Fixed)>(z_LoadTransposeMatrixxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixxOES(m: array of Fixed);
begin
z_LoadTransposeMatrixxOES_ovr_0(m[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixxOES(var m: Fixed);
begin
z_LoadTransposeMatrixxOES_ovr_0(m);
end;
public z_LoadTransposeMatrixxOES_ovr_2 := GetFuncOrNil&<procedure(m: IntPtr)>(z_LoadTransposeMatrixxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadTransposeMatrixxOES(m: IntPtr);
begin
z_LoadTransposeMatrixxOES_ovr_2(m);
end;
public z_Map1xOES_adr := GetFuncAdr('glMap1xOES');
public z_Map1xOES_ovr_0 := GetFuncOrNil&<procedure(target: MapTarget; u1: Fixed; u2: Fixed; stride: Int32; order: Int32; points: Fixed)>(z_Map1xOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Map1xOES(target: MapTarget; u1: Fixed; u2: Fixed; stride: Int32; order: Int32; points: Fixed);
begin
z_Map1xOES_ovr_0(target, u1, u2, stride, order, points);
end;
public z_Map2xOES_adr := GetFuncAdr('glMap2xOES');
public z_Map2xOES_ovr_0 := GetFuncOrNil&<procedure(target: MapTarget; u1: Fixed; u2: Fixed; ustride: Int32; uorder: Int32; v1: Fixed; v2: Fixed; vstride: Int32; vorder: Int32; points: Fixed)>(z_Map2xOES_adr);
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);
begin
z_Map2xOES_ovr_0(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
end;
public z_MapGrid1xOES_adr := GetFuncAdr('glMapGrid1xOES');
public z_MapGrid1xOES_ovr_0 := GetFuncOrNil&<procedure(n: Int32; u1: Fixed; u2: Fixed)>(z_MapGrid1xOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapGrid1xOES(n: Int32; u1: Fixed; u2: Fixed);
begin
z_MapGrid1xOES_ovr_0(n, u1, u2);
end;
public z_MapGrid2xOES_adr := GetFuncAdr('glMapGrid2xOES');
public z_MapGrid2xOES_ovr_0 := GetFuncOrNil&<procedure(n: Int32; u1: Fixed; u2: Fixed; v1: Fixed; v2: Fixed)>(z_MapGrid2xOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MapGrid2xOES(n: Int32; u1: Fixed; u2: Fixed; v1: Fixed; v2: Fixed);
begin
z_MapGrid2xOES_ovr_0(n, u1, u2, v1, v2);
end;
public z_MultTransposeMatrixxOES_adr := GetFuncAdr('glMultTransposeMatrixxOES');
public z_MultTransposeMatrixxOES_ovr_0 := GetFuncOrNil&<procedure(var m: Fixed)>(z_MultTransposeMatrixxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixxOES(m: array of Fixed);
begin
z_MultTransposeMatrixxOES_ovr_0(m[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixxOES(var m: Fixed);
begin
z_MultTransposeMatrixxOES_ovr_0(m);
end;
public z_MultTransposeMatrixxOES_ovr_2 := GetFuncOrNil&<procedure(m: IntPtr)>(z_MultTransposeMatrixxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultTransposeMatrixxOES(m: IntPtr);
begin
z_MultTransposeMatrixxOES_ovr_2(m);
end;
public z_MultiTexCoord1xOES_adr := GetFuncAdr('glMultiTexCoord1xOES');
public z_MultiTexCoord1xOES_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; s: Fixed)>(z_MultiTexCoord1xOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1xOES(texture: TextureUnit; s: Fixed);
begin
z_MultiTexCoord1xOES_ovr_0(texture, s);
end;
public z_MultiTexCoord1xvOES_adr := GetFuncAdr('glMultiTexCoord1xvOES');
public z_MultiTexCoord1xvOES_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; var coords: Fixed)>(z_MultiTexCoord1xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1xvOES(texture: TextureUnit; coords: array of Fixed);
begin
z_MultiTexCoord1xvOES_ovr_0(texture, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1xvOES(texture: TextureUnit; var coords: Fixed);
begin
z_MultiTexCoord1xvOES_ovr_0(texture, coords);
end;
public z_MultiTexCoord1xvOES_ovr_2 := GetFuncOrNil&<procedure(texture: TextureUnit; coords: IntPtr)>(z_MultiTexCoord1xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord1xvOES(texture: TextureUnit; coords: IntPtr);
begin
z_MultiTexCoord1xvOES_ovr_2(texture, coords);
end;
public z_MultiTexCoord2xOES_adr := GetFuncAdr('glMultiTexCoord2xOES');
public z_MultiTexCoord2xOES_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; s: Fixed; t: Fixed)>(z_MultiTexCoord2xOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2xOES(texture: TextureUnit; s: Fixed; t: Fixed);
begin
z_MultiTexCoord2xOES_ovr_0(texture, s, t);
end;
public z_MultiTexCoord2xvOES_adr := GetFuncAdr('glMultiTexCoord2xvOES');
public z_MultiTexCoord2xvOES_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; var coords: Fixed)>(z_MultiTexCoord2xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2xvOES(texture: TextureUnit; coords: array of Fixed);
begin
z_MultiTexCoord2xvOES_ovr_0(texture, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2xvOES(texture: TextureUnit; var coords: Fixed);
begin
z_MultiTexCoord2xvOES_ovr_0(texture, coords);
end;
public z_MultiTexCoord2xvOES_ovr_2 := GetFuncOrNil&<procedure(texture: TextureUnit; coords: IntPtr)>(z_MultiTexCoord2xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord2xvOES(texture: TextureUnit; coords: IntPtr);
begin
z_MultiTexCoord2xvOES_ovr_2(texture, coords);
end;
public z_MultiTexCoord3xOES_adr := GetFuncAdr('glMultiTexCoord3xOES');
public z_MultiTexCoord3xOES_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; s: Fixed; t: Fixed; r: Fixed)>(z_MultiTexCoord3xOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3xOES(texture: TextureUnit; s: Fixed; t: Fixed; r: Fixed);
begin
z_MultiTexCoord3xOES_ovr_0(texture, s, t, r);
end;
public z_MultiTexCoord3xvOES_adr := GetFuncAdr('glMultiTexCoord3xvOES');
public z_MultiTexCoord3xvOES_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; var coords: Fixed)>(z_MultiTexCoord3xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3xvOES(texture: TextureUnit; coords: array of Fixed);
begin
z_MultiTexCoord3xvOES_ovr_0(texture, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3xvOES(texture: TextureUnit; var coords: Fixed);
begin
z_MultiTexCoord3xvOES_ovr_0(texture, coords);
end;
public z_MultiTexCoord3xvOES_ovr_2 := GetFuncOrNil&<procedure(texture: TextureUnit; coords: IntPtr)>(z_MultiTexCoord3xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord3xvOES(texture: TextureUnit; coords: IntPtr);
begin
z_MultiTexCoord3xvOES_ovr_2(texture, coords);
end;
public z_MultiTexCoord4xvOES_adr := GetFuncAdr('glMultiTexCoord4xvOES');
public z_MultiTexCoord4xvOES_ovr_0 := GetFuncOrNil&<procedure(texture: TextureUnit; var coords: Fixed)>(z_MultiTexCoord4xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4xvOES(texture: TextureUnit; coords: array of Fixed);
begin
z_MultiTexCoord4xvOES_ovr_0(texture, coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4xvOES(texture: TextureUnit; var coords: Fixed);
begin
z_MultiTexCoord4xvOES_ovr_0(texture, coords);
end;
public z_MultiTexCoord4xvOES_ovr_2 := GetFuncOrNil&<procedure(texture: TextureUnit; coords: IntPtr)>(z_MultiTexCoord4xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure MultiTexCoord4xvOES(texture: TextureUnit; coords: IntPtr);
begin
z_MultiTexCoord4xvOES_ovr_2(texture, coords);
end;
public z_Normal3xvOES_adr := GetFuncAdr('glNormal3xvOES');
public z_Normal3xvOES_ovr_0 := GetFuncOrNil&<procedure(var coords: Fixed)>(z_Normal3xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3xvOES(coords: array of Fixed);
begin
z_Normal3xvOES_ovr_0(coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3xvOES(var coords: Fixed);
begin
z_Normal3xvOES_ovr_0(coords);
end;
public z_Normal3xvOES_ovr_2 := GetFuncOrNil&<procedure(coords: IntPtr)>(z_Normal3xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3xvOES(coords: IntPtr);
begin
z_Normal3xvOES_ovr_2(coords);
end;
public z_PassThroughxOES_adr := GetFuncAdr('glPassThroughxOES');
public z_PassThroughxOES_ovr_0 := GetFuncOrNil&<procedure(token: Fixed)>(z_PassThroughxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PassThroughxOES(token: Fixed);
begin
z_PassThroughxOES_ovr_0(token);
end;
public z_PixelTransferxOES_adr := GetFuncAdr('glPixelTransferxOES');
public z_PixelTransferxOES_ovr_0 := GetFuncOrNil&<procedure(pname: PixelTransferParameter; param: Fixed)>(z_PixelTransferxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTransferxOES(pname: PixelTransferParameter; param: Fixed);
begin
z_PixelTransferxOES_ovr_0(pname, param);
end;
public z_PixelZoomxOES_adr := GetFuncAdr('glPixelZoomxOES');
public z_PixelZoomxOES_ovr_0 := GetFuncOrNil&<procedure(xfactor: Fixed; yfactor: Fixed)>(z_PixelZoomxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelZoomxOES(xfactor: Fixed; yfactor: Fixed);
begin
z_PixelZoomxOES_ovr_0(xfactor, yfactor);
end;
public z_PrioritizeTexturesxOES_adr := GetFuncAdr('glPrioritizeTexturesxOES');
public z_PrioritizeTexturesxOES_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var textures: UInt32; var priorities: Fixed)>(z_PrioritizeTexturesxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesxOES(n: Int32; textures: array of UInt32; priorities: array of Fixed);
begin
z_PrioritizeTexturesxOES_ovr_0(n, textures[0], priorities[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesxOES(n: Int32; textures: array of UInt32; var priorities: Fixed);
begin
z_PrioritizeTexturesxOES_ovr_0(n, textures[0], priorities);
end;
public z_PrioritizeTexturesxOES_ovr_2 := GetFuncOrNil&<procedure(n: Int32; var textures: UInt32; priorities: IntPtr)>(z_PrioritizeTexturesxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesxOES(n: Int32; textures: array of UInt32; priorities: IntPtr);
begin
z_PrioritizeTexturesxOES_ovr_2(n, textures[0], priorities);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesxOES(n: Int32; var textures: UInt32; priorities: array of Fixed);
begin
z_PrioritizeTexturesxOES_ovr_0(n, textures, priorities[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesxOES(n: Int32; var textures: UInt32; var priorities: Fixed);
begin
z_PrioritizeTexturesxOES_ovr_0(n, textures, priorities);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesxOES(n: Int32; var textures: UInt32; priorities: IntPtr);
begin
z_PrioritizeTexturesxOES_ovr_2(n, textures, priorities);
end;
public z_PrioritizeTexturesxOES_ovr_6 := GetFuncOrNil&<procedure(n: Int32; textures: IntPtr; var priorities: Fixed)>(z_PrioritizeTexturesxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesxOES(n: Int32; textures: IntPtr; priorities: array of Fixed);
begin
z_PrioritizeTexturesxOES_ovr_6(n, textures, priorities[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesxOES(n: Int32; textures: IntPtr; var priorities: Fixed);
begin
z_PrioritizeTexturesxOES_ovr_6(n, textures, priorities);
end;
public z_PrioritizeTexturesxOES_ovr_8 := GetFuncOrNil&<procedure(n: Int32; textures: IntPtr; priorities: IntPtr)>(z_PrioritizeTexturesxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PrioritizeTexturesxOES(n: Int32; textures: IntPtr; priorities: IntPtr);
begin
z_PrioritizeTexturesxOES_ovr_8(n, textures, priorities);
end;
public z_RasterPos2xOES_adr := GetFuncAdr('glRasterPos2xOES');
public z_RasterPos2xOES_ovr_0 := GetFuncOrNil&<procedure(x: Fixed; y: Fixed)>(z_RasterPos2xOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2xOES(x: Fixed; y: Fixed);
begin
z_RasterPos2xOES_ovr_0(x, y);
end;
public z_RasterPos2xvOES_adr := GetFuncAdr('glRasterPos2xvOES');
public z_RasterPos2xvOES_ovr_0 := GetFuncOrNil&<procedure(var coords: Fixed)>(z_RasterPos2xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2xvOES(coords: array of Fixed);
begin
z_RasterPos2xvOES_ovr_0(coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2xvOES(var coords: Fixed);
begin
z_RasterPos2xvOES_ovr_0(coords);
end;
public z_RasterPos2xvOES_ovr_2 := GetFuncOrNil&<procedure(coords: IntPtr)>(z_RasterPos2xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos2xvOES(coords: IntPtr);
begin
z_RasterPos2xvOES_ovr_2(coords);
end;
public z_RasterPos3xOES_adr := GetFuncAdr('glRasterPos3xOES');
public z_RasterPos3xOES_ovr_0 := GetFuncOrNil&<procedure(x: Fixed; y: Fixed; z: Fixed)>(z_RasterPos3xOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3xOES(x: Fixed; y: Fixed; z: Fixed);
begin
z_RasterPos3xOES_ovr_0(x, y, z);
end;
public z_RasterPos3xvOES_adr := GetFuncAdr('glRasterPos3xvOES');
public z_RasterPos3xvOES_ovr_0 := GetFuncOrNil&<procedure(var coords: Fixed)>(z_RasterPos3xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3xvOES(coords: array of Fixed);
begin
z_RasterPos3xvOES_ovr_0(coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3xvOES(var coords: Fixed);
begin
z_RasterPos3xvOES_ovr_0(coords);
end;
public z_RasterPos3xvOES_ovr_2 := GetFuncOrNil&<procedure(coords: IntPtr)>(z_RasterPos3xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos3xvOES(coords: IntPtr);
begin
z_RasterPos3xvOES_ovr_2(coords);
end;
public z_RasterPos4xOES_adr := GetFuncAdr('glRasterPos4xOES');
public z_RasterPos4xOES_ovr_0 := GetFuncOrNil&<procedure(x: Fixed; y: Fixed; z: Fixed; w: Fixed)>(z_RasterPos4xOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4xOES(x: Fixed; y: Fixed; z: Fixed; w: Fixed);
begin
z_RasterPos4xOES_ovr_0(x, y, z, w);
end;
public z_RasterPos4xvOES_adr := GetFuncAdr('glRasterPos4xvOES');
public z_RasterPos4xvOES_ovr_0 := GetFuncOrNil&<procedure(var coords: Fixed)>(z_RasterPos4xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4xvOES(coords: array of Fixed);
begin
z_RasterPos4xvOES_ovr_0(coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4xvOES(var coords: Fixed);
begin
z_RasterPos4xvOES_ovr_0(coords);
end;
public z_RasterPos4xvOES_ovr_2 := GetFuncOrNil&<procedure(coords: IntPtr)>(z_RasterPos4xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RasterPos4xvOES(coords: IntPtr);
begin
z_RasterPos4xvOES_ovr_2(coords);
end;
public z_RectxOES_adr := GetFuncAdr('glRectxOES');
public z_RectxOES_ovr_0 := GetFuncOrNil&<procedure(x1: Fixed; y1: Fixed; x2: Fixed; y2: Fixed)>(z_RectxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RectxOES(x1: Fixed; y1: Fixed; x2: Fixed; y2: Fixed);
begin
z_RectxOES_ovr_0(x1, y1, x2, y2);
end;
public z_RectxvOES_adr := GetFuncAdr('glRectxvOES');
public z_RectxvOES_ovr_0 := GetFuncOrNil&<procedure(var v1: Fixed; var v2: Fixed)>(z_RectxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RectxvOES(v1: array of Fixed; v2: array of Fixed);
begin
z_RectxvOES_ovr_0(v1[0], v2[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RectxvOES(v1: array of Fixed; var v2: Fixed);
begin
z_RectxvOES_ovr_0(v1[0], v2);
end;
public z_RectxvOES_ovr_2 := GetFuncOrNil&<procedure(var v1: Fixed; v2: IntPtr)>(z_RectxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RectxvOES(v1: array of Fixed; v2: IntPtr);
begin
z_RectxvOES_ovr_2(v1[0], v2);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RectxvOES(var v1: Fixed; v2: array of Fixed);
begin
z_RectxvOES_ovr_0(v1, v2[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RectxvOES(var v1: Fixed; var v2: Fixed);
begin
z_RectxvOES_ovr_0(v1, v2);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RectxvOES(var v1: Fixed; v2: IntPtr);
begin
z_RectxvOES_ovr_2(v1, v2);
end;
public z_RectxvOES_ovr_6 := GetFuncOrNil&<procedure(v1: IntPtr; var v2: Fixed)>(z_RectxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RectxvOES(v1: IntPtr; v2: array of Fixed);
begin
z_RectxvOES_ovr_6(v1, v2[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RectxvOES(v1: IntPtr; var v2: Fixed);
begin
z_RectxvOES_ovr_6(v1, v2);
end;
public z_RectxvOES_ovr_8 := GetFuncOrNil&<procedure(v1: IntPtr; v2: IntPtr)>(z_RectxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure RectxvOES(v1: IntPtr; v2: IntPtr);
begin
z_RectxvOES_ovr_8(v1, v2);
end;
public z_TexCoord1xOES_adr := GetFuncAdr('glTexCoord1xOES');
public z_TexCoord1xOES_ovr_0 := GetFuncOrNil&<procedure(s: Fixed)>(z_TexCoord1xOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1xOES(s: Fixed);
begin
z_TexCoord1xOES_ovr_0(s);
end;
public z_TexCoord1xvOES_adr := GetFuncAdr('glTexCoord1xvOES');
public z_TexCoord1xvOES_ovr_0 := GetFuncOrNil&<procedure(var coords: Fixed)>(z_TexCoord1xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1xvOES(coords: array of Fixed);
begin
z_TexCoord1xvOES_ovr_0(coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1xvOES(var coords: Fixed);
begin
z_TexCoord1xvOES_ovr_0(coords);
end;
public z_TexCoord1xvOES_ovr_2 := GetFuncOrNil&<procedure(coords: IntPtr)>(z_TexCoord1xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord1xvOES(coords: IntPtr);
begin
z_TexCoord1xvOES_ovr_2(coords);
end;
public z_TexCoord2xOES_adr := GetFuncAdr('glTexCoord2xOES');
public z_TexCoord2xOES_ovr_0 := GetFuncOrNil&<procedure(s: Fixed; t: Fixed)>(z_TexCoord2xOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2xOES(s: Fixed; t: Fixed);
begin
z_TexCoord2xOES_ovr_0(s, t);
end;
public z_TexCoord2xvOES_adr := GetFuncAdr('glTexCoord2xvOES');
public z_TexCoord2xvOES_ovr_0 := GetFuncOrNil&<procedure(var coords: Fixed)>(z_TexCoord2xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2xvOES(coords: array of Fixed);
begin
z_TexCoord2xvOES_ovr_0(coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2xvOES(var coords: Fixed);
begin
z_TexCoord2xvOES_ovr_0(coords);
end;
public z_TexCoord2xvOES_ovr_2 := GetFuncOrNil&<procedure(coords: IntPtr)>(z_TexCoord2xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2xvOES(coords: IntPtr);
begin
z_TexCoord2xvOES_ovr_2(coords);
end;
public z_TexCoord3xOES_adr := GetFuncAdr('glTexCoord3xOES');
public z_TexCoord3xOES_ovr_0 := GetFuncOrNil&<procedure(s: Fixed; t: Fixed; r: Fixed)>(z_TexCoord3xOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3xOES(s: Fixed; t: Fixed; r: Fixed);
begin
z_TexCoord3xOES_ovr_0(s, t, r);
end;
public z_TexCoord3xvOES_adr := GetFuncAdr('glTexCoord3xvOES');
public z_TexCoord3xvOES_ovr_0 := GetFuncOrNil&<procedure(var coords: Fixed)>(z_TexCoord3xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3xvOES(coords: array of Fixed);
begin
z_TexCoord3xvOES_ovr_0(coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3xvOES(var coords: Fixed);
begin
z_TexCoord3xvOES_ovr_0(coords);
end;
public z_TexCoord3xvOES_ovr_2 := GetFuncOrNil&<procedure(coords: IntPtr)>(z_TexCoord3xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord3xvOES(coords: IntPtr);
begin
z_TexCoord3xvOES_ovr_2(coords);
end;
public z_TexCoord4xOES_adr := GetFuncAdr('glTexCoord4xOES');
public z_TexCoord4xOES_ovr_0 := GetFuncOrNil&<procedure(s: Fixed; t: Fixed; r: Fixed; q: Fixed)>(z_TexCoord4xOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4xOES(s: Fixed; t: Fixed; r: Fixed; q: Fixed);
begin
z_TexCoord4xOES_ovr_0(s, t, r, q);
end;
public z_TexCoord4xvOES_adr := GetFuncAdr('glTexCoord4xvOES');
public z_TexCoord4xvOES_ovr_0 := GetFuncOrNil&<procedure(var coords: Fixed)>(z_TexCoord4xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4xvOES(coords: array of Fixed);
begin
z_TexCoord4xvOES_ovr_0(coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4xvOES(var coords: Fixed);
begin
z_TexCoord4xvOES_ovr_0(coords);
end;
public z_TexCoord4xvOES_ovr_2 := GetFuncOrNil&<procedure(coords: IntPtr)>(z_TexCoord4xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4xvOES(coords: IntPtr);
begin
z_TexCoord4xvOES_ovr_2(coords);
end;
public z_TexGenxOES_adr := GetFuncAdr('glTexGenxOES');
public z_TexGenxOES_ovr_0 := GetFuncOrNil&<procedure(coord: TextureCoordName; pname: TextureGenParameter; param: Fixed)>(z_TexGenxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGenxOES(coord: TextureCoordName; pname: TextureGenParameter; param: Fixed);
begin
z_TexGenxOES_ovr_0(coord, pname, param);
end;
public z_TexGenxvOES_adr := GetFuncAdr('glTexGenxvOES');
public z_TexGenxvOES_ovr_0 := GetFuncOrNil&<procedure(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: Fixed)>(z_TexGenxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGenxvOES(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: array of Fixed);
begin
z_TexGenxvOES_ovr_0(coord, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGenxvOES(coord: TextureCoordName; pname: TextureGenParameter; var ¶ms: Fixed);
begin
z_TexGenxvOES_ovr_0(coord, pname, ¶ms);
end;
public z_TexGenxvOES_ovr_2 := GetFuncOrNil&<procedure(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr)>(z_TexGenxvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexGenxvOES(coord: TextureCoordName; pname: TextureGenParameter; ¶ms: IntPtr);
begin
z_TexGenxvOES_ovr_2(coord, pname, ¶ms);
end;
public z_Vertex2xOES_adr := GetFuncAdr('glVertex2xOES');
public z_Vertex2xOES_ovr_0 := GetFuncOrNil&<procedure(x: Fixed)>(z_Vertex2xOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2xOES(x: Fixed);
begin
z_Vertex2xOES_ovr_0(x);
end;
public z_Vertex2xvOES_adr := GetFuncAdr('glVertex2xvOES');
public z_Vertex2xvOES_ovr_0 := GetFuncOrNil&<procedure(var coords: Fixed)>(z_Vertex2xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2xvOES(coords: array of Fixed);
begin
z_Vertex2xvOES_ovr_0(coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2xvOES(var coords: Fixed);
begin
z_Vertex2xvOES_ovr_0(coords);
end;
public z_Vertex2xvOES_ovr_2 := GetFuncOrNil&<procedure(coords: IntPtr)>(z_Vertex2xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex2xvOES(coords: IntPtr);
begin
z_Vertex2xvOES_ovr_2(coords);
end;
public z_Vertex3xOES_adr := GetFuncAdr('glVertex3xOES');
public z_Vertex3xOES_ovr_0 := GetFuncOrNil&<procedure(x: Fixed; y: Fixed)>(z_Vertex3xOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3xOES(x: Fixed; y: Fixed);
begin
z_Vertex3xOES_ovr_0(x, y);
end;
public z_Vertex3xvOES_adr := GetFuncAdr('glVertex3xvOES');
public z_Vertex3xvOES_ovr_0 := GetFuncOrNil&<procedure(var coords: Fixed)>(z_Vertex3xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3xvOES(coords: array of Fixed);
begin
z_Vertex3xvOES_ovr_0(coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3xvOES(var coords: Fixed);
begin
z_Vertex3xvOES_ovr_0(coords);
end;
public z_Vertex3xvOES_ovr_2 := GetFuncOrNil&<procedure(coords: IntPtr)>(z_Vertex3xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex3xvOES(coords: IntPtr);
begin
z_Vertex3xvOES_ovr_2(coords);
end;
public z_Vertex4xOES_adr := GetFuncAdr('glVertex4xOES');
public z_Vertex4xOES_ovr_0 := GetFuncOrNil&<procedure(x: Fixed; y: Fixed; z: Fixed)>(z_Vertex4xOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4xOES(x: Fixed; y: Fixed; z: Fixed);
begin
z_Vertex4xOES_ovr_0(x, y, z);
end;
public z_Vertex4xvOES_adr := GetFuncAdr('glVertex4xvOES');
public z_Vertex4xvOES_ovr_0 := GetFuncOrNil&<procedure(var coords: Fixed)>(z_Vertex4xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4xvOES(coords: array of Fixed);
begin
z_Vertex4xvOES_ovr_0(coords[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4xvOES(var coords: Fixed);
begin
z_Vertex4xvOES_ovr_0(coords);
end;
public z_Vertex4xvOES_ovr_2 := GetFuncOrNil&<procedure(coords: IntPtr)>(z_Vertex4xvOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Vertex4xvOES(coords: IntPtr);
begin
z_Vertex4xvOES_ovr_2(coords);
end;
end;
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);
public z_QueryMatrixxOES_adr := GetFuncAdr('glQueryMatrixxOES');
public z_QueryMatrixxOES_ovr_0 := GetFuncOrNil&<function(var mantissa: Fixed; var exponent: Int32): DummyFlags>(z_QueryMatrixxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function QueryMatrixxOES(mantissa: array of Fixed; exponent: array of Int32): DummyFlags;
begin
Result := z_QueryMatrixxOES_ovr_0(mantissa[0], exponent[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function QueryMatrixxOES(mantissa: array of Fixed; var exponent: Int32): DummyFlags;
begin
Result := z_QueryMatrixxOES_ovr_0(mantissa[0], exponent);
end;
public z_QueryMatrixxOES_ovr_2 := GetFuncOrNil&<function(var mantissa: Fixed; exponent: IntPtr): DummyFlags>(z_QueryMatrixxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function QueryMatrixxOES(mantissa: array of Fixed; exponent: IntPtr): DummyFlags;
begin
Result := z_QueryMatrixxOES_ovr_2(mantissa[0], exponent);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function QueryMatrixxOES(var mantissa: Fixed; exponent: array of Int32): DummyFlags;
begin
Result := z_QueryMatrixxOES_ovr_0(mantissa, exponent[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function QueryMatrixxOES(var mantissa: Fixed; var exponent: Int32): DummyFlags;
begin
Result := z_QueryMatrixxOES_ovr_0(mantissa, exponent);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function QueryMatrixxOES(var mantissa: Fixed; exponent: IntPtr): DummyFlags;
begin
Result := z_QueryMatrixxOES_ovr_2(mantissa, exponent);
end;
public z_QueryMatrixxOES_ovr_6 := GetFuncOrNil&<function(mantissa: IntPtr; var exponent: Int32): DummyFlags>(z_QueryMatrixxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function QueryMatrixxOES(mantissa: IntPtr; exponent: array of Int32): DummyFlags;
begin
Result := z_QueryMatrixxOES_ovr_6(mantissa, exponent[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function QueryMatrixxOES(mantissa: IntPtr; var exponent: Int32): DummyFlags;
begin
Result := z_QueryMatrixxOES_ovr_6(mantissa, exponent);
end;
public z_QueryMatrixxOES_ovr_8 := GetFuncOrNil&<function(mantissa: IntPtr; exponent: IntPtr): DummyFlags>(z_QueryMatrixxOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function QueryMatrixxOES(mantissa: IntPtr; exponent: IntPtr): DummyFlags;
begin
Result := z_QueryMatrixxOES_ovr_8(mantissa, exponent);
end;
end;
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);
public z_ClearDepthfOES_adr := GetFuncAdr('glClearDepthfOES');
public z_ClearDepthfOES_ovr_0 := GetFuncOrNil&<procedure(depth: single)>(z_ClearDepthfOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearDepthfOES(depth: single);
begin
z_ClearDepthfOES_ovr_0(depth);
end;
public z_ClipPlanefOES_adr := GetFuncAdr('glClipPlanefOES');
public z_ClipPlanefOES_ovr_0 := GetFuncOrNil&<procedure(plane: ClipPlaneName; var equation: single)>(z_ClipPlanefOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClipPlanefOES(plane: ClipPlaneName; equation: array of single);
begin
z_ClipPlanefOES_ovr_0(plane, equation[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClipPlanefOES(plane: ClipPlaneName; var equation: single);
begin
z_ClipPlanefOES_ovr_0(plane, equation);
end;
public z_ClipPlanefOES_ovr_2 := GetFuncOrNil&<procedure(plane: ClipPlaneName; equation: IntPtr)>(z_ClipPlanefOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClipPlanefOES(plane: ClipPlaneName; equation: IntPtr);
begin
z_ClipPlanefOES_ovr_2(plane, equation);
end;
public z_DepthRangefOES_adr := GetFuncAdr('glDepthRangefOES');
public z_DepthRangefOES_ovr_0 := GetFuncOrNil&<procedure(n: single; f: single)>(z_DepthRangefOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DepthRangefOES(n: single; f: single);
begin
z_DepthRangefOES_ovr_0(n, f);
end;
public z_FrustumfOES_adr := GetFuncAdr('glFrustumfOES');
public z_FrustumfOES_ovr_0 := GetFuncOrNil&<procedure(l: single; r: single; b: single; t: single; n: single; f: single)>(z_FrustumfOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FrustumfOES(l: single; r: single; b: single; t: single; n: single; f: single);
begin
z_FrustumfOES_ovr_0(l, r, b, t, n, f);
end;
public z_GetClipPlanefOES_adr := GetFuncAdr('glGetClipPlanefOES');
public z_GetClipPlanefOES_ovr_0 := GetFuncOrNil&<procedure(plane: ClipPlaneName; var equation: single)>(z_GetClipPlanefOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetClipPlanefOES(plane: ClipPlaneName; equation: array of single);
begin
z_GetClipPlanefOES_ovr_0(plane, equation[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetClipPlanefOES(plane: ClipPlaneName; var equation: single);
begin
z_GetClipPlanefOES_ovr_0(plane, equation);
end;
public z_GetClipPlanefOES_ovr_2 := GetFuncOrNil&<procedure(plane: ClipPlaneName; equation: IntPtr)>(z_GetClipPlanefOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetClipPlanefOES(plane: ClipPlaneName; equation: IntPtr);
begin
z_GetClipPlanefOES_ovr_2(plane, equation);
end;
public z_OrthofOES_adr := GetFuncAdr('glOrthofOES');
public z_OrthofOES_ovr_0 := GetFuncOrNil&<procedure(l: single; r: single; b: single; t: single; n: single; f: single)>(z_OrthofOES_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure OrthofOES(l: single; r: single; b: single; t: single; n: single; f: single);
begin
z_OrthofOES_ovr_0(l, r, b, t, n, f);
end;
end;
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);
public z_FramebufferTextureMultiviewOVR_adr := GetFuncAdr('glFramebufferTextureMultiviewOVR');
public z_FramebufferTextureMultiviewOVR_ovr_0 := GetFuncOrNil&<procedure(target: FramebufferTarget; attachment: FramebufferAttachment; texture: UInt32; level: Int32; baseViewIndex: Int32; numViews: Int32)>(z_FramebufferTextureMultiviewOVR_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FramebufferTextureMultiviewOVR(target: FramebufferTarget; attachment: FramebufferAttachment; texture: UInt32; level: Int32; baseViewIndex: Int32; numViews: Int32);
begin
z_FramebufferTextureMultiviewOVR_ovr_0(target, attachment, texture, level, baseViewIndex, numViews);
end;
end;
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);
public z_HintPGI_adr := GetFuncAdr('glHintPGI');
public z_HintPGI_ovr_0 := GetFuncOrNil&<procedure(target: HintTargetPGI; mode: Int32)>(z_HintPGI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure HintPGI(target: HintTargetPGI; mode: Int32);
begin
z_HintPGI_ovr_0(target, mode);
end;
end;
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);
public z_DetailTexFuncSGIS_adr := GetFuncAdr('glDetailTexFuncSGIS');
public z_DetailTexFuncSGIS_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; n: Int32; var points: single)>(z_DetailTexFuncSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DetailTexFuncSGIS(target: TextureTarget; n: Int32; points: array of single);
begin
z_DetailTexFuncSGIS_ovr_0(target, n, points[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DetailTexFuncSGIS(target: TextureTarget; n: Int32; var points: single);
begin
z_DetailTexFuncSGIS_ovr_0(target, n, points);
end;
public z_DetailTexFuncSGIS_ovr_2 := GetFuncOrNil&<procedure(target: TextureTarget; n: Int32; points: IntPtr)>(z_DetailTexFuncSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DetailTexFuncSGIS(target: TextureTarget; n: Int32; points: IntPtr);
begin
z_DetailTexFuncSGIS_ovr_2(target, n, points);
end;
public z_GetDetailTexFuncSGIS_adr := GetFuncAdr('glGetDetailTexFuncSGIS');
public z_GetDetailTexFuncSGIS_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; var points: single)>(z_GetDetailTexFuncSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDetailTexFuncSGIS(target: TextureTarget; points: array of single);
begin
z_GetDetailTexFuncSGIS_ovr_0(target, points[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDetailTexFuncSGIS(target: TextureTarget; var points: single);
begin
z_GetDetailTexFuncSGIS_ovr_0(target, points);
end;
public z_GetDetailTexFuncSGIS_ovr_2 := GetFuncOrNil&<procedure(target: TextureTarget; points: IntPtr)>(z_GetDetailTexFuncSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetDetailTexFuncSGIS(target: TextureTarget; points: IntPtr);
begin
z_GetDetailTexFuncSGIS_ovr_2(target, points);
end;
end;
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);
public z_FogFuncSGIS_adr := GetFuncAdr('glFogFuncSGIS');
public z_FogFuncSGIS_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var points: single)>(z_FogFuncSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogFuncSGIS(n: Int32; points: array of single);
begin
z_FogFuncSGIS_ovr_0(n, points[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogFuncSGIS(n: Int32; var points: single);
begin
z_FogFuncSGIS_ovr_0(n, points);
end;
public z_FogFuncSGIS_ovr_2 := GetFuncOrNil&<procedure(n: Int32; points: IntPtr)>(z_FogFuncSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FogFuncSGIS(n: Int32; points: IntPtr);
begin
z_FogFuncSGIS_ovr_2(n, points);
end;
public z_GetFogFuncSGIS_adr := GetFuncAdr('glGetFogFuncSGIS');
public z_GetFogFuncSGIS_ovr_0 := GetFuncOrNil&<procedure(var points: single)>(z_GetFogFuncSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFogFuncSGIS(points: array of single);
begin
z_GetFogFuncSGIS_ovr_0(points[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFogFuncSGIS(var points: single);
begin
z_GetFogFuncSGIS_ovr_0(points);
end;
public z_GetFogFuncSGIS_ovr_2 := GetFuncOrNil&<procedure(points: IntPtr)>(z_GetFogFuncSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFogFuncSGIS(points: IntPtr);
begin
z_GetFogFuncSGIS_ovr_2(points);
end;
end;
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);
public z_SampleMaskSGIS_adr := GetFuncAdr('glSampleMaskSGIS');
public z_SampleMaskSGIS_ovr_0 := GetFuncOrNil&<procedure(value: single; invert: boolean)>(z_SampleMaskSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SampleMaskSGIS(value: single; invert: boolean);
begin
z_SampleMaskSGIS_ovr_0(value, invert);
end;
public z_SamplePatternSGIS_adr := GetFuncAdr('glSamplePatternSGIS');
public z_SamplePatternSGIS_ovr_0 := GetFuncOrNil&<procedure(pattern: OpenGL.SamplePatternSGIS)>(z_SamplePatternSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SamplePatternSGIS(pattern: OpenGL.SamplePatternSGIS);
begin
z_SamplePatternSGIS_ovr_0(pattern);
end;
end;
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);
public z_PixelTexGenParameteriSGIS_adr := GetFuncAdr('glPixelTexGenParameteriSGIS');
public z_PixelTexGenParameteriSGIS_ovr_0 := GetFuncOrNil&<procedure(pname: PixelTexGenParameterNameSGIS; param: Int32)>(z_PixelTexGenParameteriSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTexGenParameteriSGIS(pname: PixelTexGenParameterNameSGIS; param: Int32);
begin
z_PixelTexGenParameteriSGIS_ovr_0(pname, param);
end;
public z_PixelTexGenParameterivSGIS_adr := GetFuncAdr('glPixelTexGenParameterivSGIS');
public z_PixelTexGenParameterivSGIS_ovr_0 := GetFuncOrNil&<procedure(pname: PixelTexGenParameterNameSGIS; var ¶ms: Int32)>(z_PixelTexGenParameterivSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTexGenParameterivSGIS(pname: PixelTexGenParameterNameSGIS; ¶ms: array of Int32);
begin
z_PixelTexGenParameterivSGIS_ovr_0(pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTexGenParameterivSGIS(pname: PixelTexGenParameterNameSGIS; var ¶ms: Int32);
begin
z_PixelTexGenParameterivSGIS_ovr_0(pname, ¶ms);
end;
public z_PixelTexGenParameterivSGIS_ovr_2 := GetFuncOrNil&<procedure(pname: PixelTexGenParameterNameSGIS; ¶ms: IntPtr)>(z_PixelTexGenParameterivSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTexGenParameterivSGIS(pname: PixelTexGenParameterNameSGIS; ¶ms: IntPtr);
begin
z_PixelTexGenParameterivSGIS_ovr_2(pname, ¶ms);
end;
public z_PixelTexGenParameterfSGIS_adr := GetFuncAdr('glPixelTexGenParameterfSGIS');
public z_PixelTexGenParameterfSGIS_ovr_0 := GetFuncOrNil&<procedure(pname: PixelTexGenParameterNameSGIS; param: single)>(z_PixelTexGenParameterfSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTexGenParameterfSGIS(pname: PixelTexGenParameterNameSGIS; param: single);
begin
z_PixelTexGenParameterfSGIS_ovr_0(pname, param);
end;
public z_PixelTexGenParameterfvSGIS_adr := GetFuncAdr('glPixelTexGenParameterfvSGIS');
public z_PixelTexGenParameterfvSGIS_ovr_0 := GetFuncOrNil&<procedure(pname: PixelTexGenParameterNameSGIS; var ¶ms: single)>(z_PixelTexGenParameterfvSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTexGenParameterfvSGIS(pname: PixelTexGenParameterNameSGIS; ¶ms: array of single);
begin
z_PixelTexGenParameterfvSGIS_ovr_0(pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTexGenParameterfvSGIS(pname: PixelTexGenParameterNameSGIS; var ¶ms: single);
begin
z_PixelTexGenParameterfvSGIS_ovr_0(pname, ¶ms);
end;
public z_PixelTexGenParameterfvSGIS_ovr_2 := GetFuncOrNil&<procedure(pname: PixelTexGenParameterNameSGIS; ¶ms: IntPtr)>(z_PixelTexGenParameterfvSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTexGenParameterfvSGIS(pname: PixelTexGenParameterNameSGIS; ¶ms: IntPtr);
begin
z_PixelTexGenParameterfvSGIS_ovr_2(pname, ¶ms);
end;
public z_GetPixelTexGenParameterivSGIS_adr := GetFuncAdr('glGetPixelTexGenParameterivSGIS');
public z_GetPixelTexGenParameterivSGIS_ovr_0 := GetFuncOrNil&<procedure(pname: PixelTexGenParameterNameSGIS; var ¶ms: Int32)>(z_GetPixelTexGenParameterivSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelTexGenParameterivSGIS(pname: PixelTexGenParameterNameSGIS; ¶ms: array of Int32);
begin
z_GetPixelTexGenParameterivSGIS_ovr_0(pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelTexGenParameterivSGIS(pname: PixelTexGenParameterNameSGIS; var ¶ms: Int32);
begin
z_GetPixelTexGenParameterivSGIS_ovr_0(pname, ¶ms);
end;
public z_GetPixelTexGenParameterivSGIS_ovr_2 := GetFuncOrNil&<procedure(pname: PixelTexGenParameterNameSGIS; ¶ms: IntPtr)>(z_GetPixelTexGenParameterivSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelTexGenParameterivSGIS(pname: PixelTexGenParameterNameSGIS; ¶ms: IntPtr);
begin
z_GetPixelTexGenParameterivSGIS_ovr_2(pname, ¶ms);
end;
public z_GetPixelTexGenParameterfvSGIS_adr := GetFuncAdr('glGetPixelTexGenParameterfvSGIS');
public z_GetPixelTexGenParameterfvSGIS_ovr_0 := GetFuncOrNil&<procedure(pname: PixelTexGenParameterNameSGIS; var ¶ms: single)>(z_GetPixelTexGenParameterfvSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelTexGenParameterfvSGIS(pname: PixelTexGenParameterNameSGIS; ¶ms: array of single);
begin
z_GetPixelTexGenParameterfvSGIS_ovr_0(pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelTexGenParameterfvSGIS(pname: PixelTexGenParameterNameSGIS; var ¶ms: single);
begin
z_GetPixelTexGenParameterfvSGIS_ovr_0(pname, ¶ms);
end;
public z_GetPixelTexGenParameterfvSGIS_ovr_2 := GetFuncOrNil&<procedure(pname: PixelTexGenParameterNameSGIS; ¶ms: IntPtr)>(z_GetPixelTexGenParameterfvSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetPixelTexGenParameterfvSGIS(pname: PixelTexGenParameterNameSGIS; ¶ms: IntPtr);
begin
z_GetPixelTexGenParameterfvSGIS_ovr_2(pname, ¶ms);
end;
end;
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);
public z_PointParameterfSGIS_adr := GetFuncAdr('glPointParameterfSGIS');
public z_PointParameterfSGIS_ovr_0 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; param: single)>(z_PointParameterfSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfSGIS(pname: PointParameterNameARB; param: single);
begin
z_PointParameterfSGIS_ovr_0(pname, param);
end;
public z_PointParameterfvSGIS_adr := GetFuncAdr('glPointParameterfvSGIS');
public z_PointParameterfvSGIS_ovr_0 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; var ¶ms: single)>(z_PointParameterfvSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfvSGIS(pname: PointParameterNameARB; ¶ms: array of single);
begin
z_PointParameterfvSGIS_ovr_0(pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfvSGIS(pname: PointParameterNameARB; var ¶ms: single);
begin
z_PointParameterfvSGIS_ovr_0(pname, ¶ms);
end;
public z_PointParameterfvSGIS_ovr_2 := GetFuncOrNil&<procedure(pname: PointParameterNameARB; ¶ms: IntPtr)>(z_PointParameterfvSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PointParameterfvSGIS(pname: PointParameterNameARB; ¶ms: IntPtr);
begin
z_PointParameterfvSGIS_ovr_2(pname, ¶ms);
end;
end;
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);
public z_SharpenTexFuncSGIS_adr := GetFuncAdr('glSharpenTexFuncSGIS');
public z_SharpenTexFuncSGIS_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; n: Int32; var points: single)>(z_SharpenTexFuncSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SharpenTexFuncSGIS(target: TextureTarget; n: Int32; points: array of single);
begin
z_SharpenTexFuncSGIS_ovr_0(target, n, points[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SharpenTexFuncSGIS(target: TextureTarget; n: Int32; var points: single);
begin
z_SharpenTexFuncSGIS_ovr_0(target, n, points);
end;
public z_SharpenTexFuncSGIS_ovr_2 := GetFuncOrNil&<procedure(target: TextureTarget; n: Int32; points: IntPtr)>(z_SharpenTexFuncSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SharpenTexFuncSGIS(target: TextureTarget; n: Int32; points: IntPtr);
begin
z_SharpenTexFuncSGIS_ovr_2(target, n, points);
end;
public z_GetSharpenTexFuncSGIS_adr := GetFuncAdr('glGetSharpenTexFuncSGIS');
public z_GetSharpenTexFuncSGIS_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; var points: single)>(z_GetSharpenTexFuncSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSharpenTexFuncSGIS(target: TextureTarget; points: array of single);
begin
z_GetSharpenTexFuncSGIS_ovr_0(target, points[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSharpenTexFuncSGIS(target: TextureTarget; var points: single);
begin
z_GetSharpenTexFuncSGIS_ovr_0(target, points);
end;
public z_GetSharpenTexFuncSGIS_ovr_2 := GetFuncOrNil&<procedure(target: TextureTarget; points: IntPtr)>(z_GetSharpenTexFuncSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetSharpenTexFuncSGIS(target: TextureTarget; points: IntPtr);
begin
z_GetSharpenTexFuncSGIS_ovr_2(target, points);
end;
end;
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);
public z_TexImage4DSGIS_adr := GetFuncAdr('glTexImage4DSGIS');
public z_TexImage4DSGIS_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; level: Int32; _internalformat: InternalFormat; width: Int32; height: Int32; depth: Int32; size4d: Int32; border: Int32; format: PixelFormat; &type: PixelType; pixels: IntPtr)>(z_TexImage4DSGIS_adr);
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);
begin
z_TexImage4DSGIS_ovr_0(target, level, _internalformat, width, height, depth, size4d, border, format, &type, pixels);
end;
public z_TexSubImage4DSGIS_adr := GetFuncAdr('glTexSubImage4DSGIS');
public z_TexSubImage4DSGIS_ovr_0 := GetFuncOrNil&<procedure(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_adr);
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);
begin
z_TexSubImage4DSGIS_ovr_0(target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, &type, pixels);
end;
end;
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);
public z_TextureColorMaskSGIS_adr := GetFuncAdr('glTextureColorMaskSGIS');
public z_TextureColorMaskSGIS_ovr_0 := GetFuncOrNil&<procedure(red: boolean; green: boolean; blue: boolean; alpha: boolean)>(z_TextureColorMaskSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TextureColorMaskSGIS(red: boolean; green: boolean; blue: boolean; alpha: boolean);
begin
z_TextureColorMaskSGIS_ovr_0(red, green, blue, alpha);
end;
end;
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);
public z_GetTexFilterFuncSGIS_adr := GetFuncAdr('glGetTexFilterFuncSGIS');
public z_GetTexFilterFuncSGIS_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; filter: TextureFilterSGIS; var weights: single)>(z_GetTexFilterFuncSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexFilterFuncSGIS(target: TextureTarget; filter: TextureFilterSGIS; weights: array of single);
begin
z_GetTexFilterFuncSGIS_ovr_0(target, filter, weights[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexFilterFuncSGIS(target: TextureTarget; filter: TextureFilterSGIS; var weights: single);
begin
z_GetTexFilterFuncSGIS_ovr_0(target, filter, weights);
end;
public z_GetTexFilterFuncSGIS_ovr_2 := GetFuncOrNil&<procedure(target: TextureTarget; filter: TextureFilterSGIS; weights: IntPtr)>(z_GetTexFilterFuncSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetTexFilterFuncSGIS(target: TextureTarget; filter: TextureFilterSGIS; weights: IntPtr);
begin
z_GetTexFilterFuncSGIS_ovr_2(target, filter, weights);
end;
public z_TexFilterFuncSGIS_adr := GetFuncAdr('glTexFilterFuncSGIS');
public z_TexFilterFuncSGIS_ovr_0 := GetFuncOrNil&<procedure(target: TextureTarget; filter: TextureFilterSGIS; n: Int32; var weights: single)>(z_TexFilterFuncSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexFilterFuncSGIS(target: TextureTarget; filter: TextureFilterSGIS; n: Int32; weights: array of single);
begin
z_TexFilterFuncSGIS_ovr_0(target, filter, n, weights[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexFilterFuncSGIS(target: TextureTarget; filter: TextureFilterSGIS; n: Int32; var weights: single);
begin
z_TexFilterFuncSGIS_ovr_0(target, filter, n, weights);
end;
public z_TexFilterFuncSGIS_ovr_2 := GetFuncOrNil&<procedure(target: TextureTarget; filter: TextureFilterSGIS; n: Int32; weights: IntPtr)>(z_TexFilterFuncSGIS_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexFilterFuncSGIS(target: TextureTarget; filter: TextureFilterSGIS; n: Int32; weights: IntPtr);
begin
z_TexFilterFuncSGIS_ovr_2(target, filter, n, weights);
end;
end;
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);
public z_AsyncMarkerSGIX_adr := GetFuncAdr('glAsyncMarkerSGIX');
public z_AsyncMarkerSGIX_ovr_0 := GetFuncOrNil&<procedure(marker: UInt32)>(z_AsyncMarkerSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure AsyncMarkerSGIX(marker: UInt32);
begin
z_AsyncMarkerSGIX_ovr_0(marker);
end;
public z_FinishAsyncSGIX_adr := GetFuncAdr('glFinishAsyncSGIX');
public z_FinishAsyncSGIX_ovr_0 := GetFuncOrNil&<function(var markerp: UInt32): Int32>(z_FinishAsyncSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function FinishAsyncSGIX(markerp: array of UInt32): Int32;
begin
Result := z_FinishAsyncSGIX_ovr_0(markerp[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function FinishAsyncSGIX(var markerp: UInt32): Int32;
begin
Result := z_FinishAsyncSGIX_ovr_0(markerp);
end;
public z_FinishAsyncSGIX_ovr_2 := GetFuncOrNil&<function(markerp: IntPtr): Int32>(z_FinishAsyncSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function FinishAsyncSGIX(markerp: IntPtr): Int32;
begin
Result := z_FinishAsyncSGIX_ovr_2(markerp);
end;
public z_PollAsyncSGIX_adr := GetFuncAdr('glPollAsyncSGIX');
public z_PollAsyncSGIX_ovr_0 := GetFuncOrNil&<function(var markerp: UInt32): Int32>(z_PollAsyncSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PollAsyncSGIX(markerp: array of UInt32): Int32;
begin
Result := z_PollAsyncSGIX_ovr_0(markerp[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PollAsyncSGIX(var markerp: UInt32): Int32;
begin
Result := z_PollAsyncSGIX_ovr_0(markerp);
end;
public z_PollAsyncSGIX_ovr_2 := GetFuncOrNil&<function(markerp: IntPtr): Int32>(z_PollAsyncSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PollAsyncSGIX(markerp: IntPtr): Int32;
begin
Result := z_PollAsyncSGIX_ovr_2(markerp);
end;
public z_GenAsyncMarkersSGIX_adr := GetFuncAdr('glGenAsyncMarkersSGIX');
public z_GenAsyncMarkersSGIX_ovr_0 := GetFuncOrNil&<function(range: Int32): UInt32>(z_GenAsyncMarkersSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GenAsyncMarkersSGIX(range: Int32): UInt32;
begin
Result := z_GenAsyncMarkersSGIX_ovr_0(range);
end;
public z_DeleteAsyncMarkersSGIX_adr := GetFuncAdr('glDeleteAsyncMarkersSGIX');
public z_DeleteAsyncMarkersSGIX_ovr_0 := GetFuncOrNil&<procedure(marker: UInt32; range: Int32)>(z_DeleteAsyncMarkersSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeleteAsyncMarkersSGIX(marker: UInt32; range: Int32);
begin
z_DeleteAsyncMarkersSGIX_ovr_0(marker, range);
end;
public z_IsAsyncMarkerSGIX_adr := GetFuncAdr('glIsAsyncMarkerSGIX');
public z_IsAsyncMarkerSGIX_ovr_0 := GetFuncOrNil&<function(marker: UInt32): boolean>(z_IsAsyncMarkerSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function IsAsyncMarkerSGIX(marker: UInt32): boolean;
begin
Result := z_IsAsyncMarkerSGIX_ovr_0(marker);
end;
end;
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);
public z_FlushRasterSGIX_adr := GetFuncAdr('glFlushRasterSGIX');
public z_FlushRasterSGIX_ovr_0 := GetFuncOrNil&<procedure>(z_FlushRasterSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FlushRasterSGIX;
begin
z_FlushRasterSGIX_ovr_0;
end;
end;
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);
public z_FragmentColorMaterialSGIX_adr := GetFuncAdr('glFragmentColorMaterialSGIX');
public z_FragmentColorMaterialSGIX_ovr_0 := GetFuncOrNil&<procedure(face: DummyEnum; mode: MaterialParameter)>(z_FragmentColorMaterialSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentColorMaterialSGIX(face: DummyEnum; mode: MaterialParameter);
begin
z_FragmentColorMaterialSGIX_ovr_0(face, mode);
end;
public z_FragmentLightfSGIX_adr := GetFuncAdr('glFragmentLightfSGIX');
public z_FragmentLightfSGIX_ovr_0 := GetFuncOrNil&<procedure(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; param: single)>(z_FragmentLightfSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightfSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; param: single);
begin
z_FragmentLightfSGIX_ovr_0(light, pname, param);
end;
public z_FragmentLightfvSGIX_adr := GetFuncAdr('glFragmentLightfvSGIX');
public z_FragmentLightfvSGIX_ovr_0 := GetFuncOrNil&<procedure(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; var ¶ms: single)>(z_FragmentLightfvSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightfvSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: array of single);
begin
z_FragmentLightfvSGIX_ovr_0(light, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightfvSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; var ¶ms: single);
begin
z_FragmentLightfvSGIX_ovr_0(light, pname, ¶ms);
end;
public z_FragmentLightfvSGIX_ovr_2 := GetFuncOrNil&<procedure(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: IntPtr)>(z_FragmentLightfvSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightfvSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: IntPtr);
begin
z_FragmentLightfvSGIX_ovr_2(light, pname, ¶ms);
end;
public z_FragmentLightiSGIX_adr := GetFuncAdr('glFragmentLightiSGIX');
public z_FragmentLightiSGIX_ovr_0 := GetFuncOrNil&<procedure(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; param: Int32)>(z_FragmentLightiSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightiSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; param: Int32);
begin
z_FragmentLightiSGIX_ovr_0(light, pname, param);
end;
public z_FragmentLightivSGIX_adr := GetFuncAdr('glFragmentLightivSGIX');
public z_FragmentLightivSGIX_ovr_0 := GetFuncOrNil&<procedure(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; var ¶ms: Int32)>(z_FragmentLightivSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightivSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: array of Int32);
begin
z_FragmentLightivSGIX_ovr_0(light, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightivSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; var ¶ms: Int32);
begin
z_FragmentLightivSGIX_ovr_0(light, pname, ¶ms);
end;
public z_FragmentLightivSGIX_ovr_2 := GetFuncOrNil&<procedure(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: IntPtr)>(z_FragmentLightivSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightivSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: IntPtr);
begin
z_FragmentLightivSGIX_ovr_2(light, pname, ¶ms);
end;
public z_FragmentLightModelfSGIX_adr := GetFuncAdr('glFragmentLightModelfSGIX');
public z_FragmentLightModelfSGIX_ovr_0 := GetFuncOrNil&<procedure(pname: FragmentLightModelParameterSGIX; param: single)>(z_FragmentLightModelfSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightModelfSGIX(pname: FragmentLightModelParameterSGIX; param: single);
begin
z_FragmentLightModelfSGIX_ovr_0(pname, param);
end;
public z_FragmentLightModelfvSGIX_adr := GetFuncAdr('glFragmentLightModelfvSGIX');
public z_FragmentLightModelfvSGIX_ovr_0 := GetFuncOrNil&<procedure(pname: FragmentLightModelParameterSGIX; var ¶ms: single)>(z_FragmentLightModelfvSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightModelfvSGIX(pname: FragmentLightModelParameterSGIX; ¶ms: array of single);
begin
z_FragmentLightModelfvSGIX_ovr_0(pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightModelfvSGIX(pname: FragmentLightModelParameterSGIX; var ¶ms: single);
begin
z_FragmentLightModelfvSGIX_ovr_0(pname, ¶ms);
end;
public z_FragmentLightModelfvSGIX_ovr_2 := GetFuncOrNil&<procedure(pname: FragmentLightModelParameterSGIX; ¶ms: IntPtr)>(z_FragmentLightModelfvSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightModelfvSGIX(pname: FragmentLightModelParameterSGIX; ¶ms: IntPtr);
begin
z_FragmentLightModelfvSGIX_ovr_2(pname, ¶ms);
end;
public z_FragmentLightModeliSGIX_adr := GetFuncAdr('glFragmentLightModeliSGIX');
public z_FragmentLightModeliSGIX_ovr_0 := GetFuncOrNil&<procedure(pname: FragmentLightModelParameterSGIX; param: Int32)>(z_FragmentLightModeliSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightModeliSGIX(pname: FragmentLightModelParameterSGIX; param: Int32);
begin
z_FragmentLightModeliSGIX_ovr_0(pname, param);
end;
public z_FragmentLightModelivSGIX_adr := GetFuncAdr('glFragmentLightModelivSGIX');
public z_FragmentLightModelivSGIX_ovr_0 := GetFuncOrNil&<procedure(pname: FragmentLightModelParameterSGIX; var ¶ms: Int32)>(z_FragmentLightModelivSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightModelivSGIX(pname: FragmentLightModelParameterSGIX; ¶ms: array of Int32);
begin
z_FragmentLightModelivSGIX_ovr_0(pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightModelivSGIX(pname: FragmentLightModelParameterSGIX; var ¶ms: Int32);
begin
z_FragmentLightModelivSGIX_ovr_0(pname, ¶ms);
end;
public z_FragmentLightModelivSGIX_ovr_2 := GetFuncOrNil&<procedure(pname: FragmentLightModelParameterSGIX; ¶ms: IntPtr)>(z_FragmentLightModelivSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentLightModelivSGIX(pname: FragmentLightModelParameterSGIX; ¶ms: IntPtr);
begin
z_FragmentLightModelivSGIX_ovr_2(pname, ¶ms);
end;
public z_FragmentMaterialfSGIX_adr := GetFuncAdr('glFragmentMaterialfSGIX');
public z_FragmentMaterialfSGIX_ovr_0 := GetFuncOrNil&<procedure(face: DummyEnum; pname: MaterialParameter; param: single)>(z_FragmentMaterialfSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentMaterialfSGIX(face: DummyEnum; pname: MaterialParameter; param: single);
begin
z_FragmentMaterialfSGIX_ovr_0(face, pname, param);
end;
public z_FragmentMaterialfvSGIX_adr := GetFuncAdr('glFragmentMaterialfvSGIX');
public z_FragmentMaterialfvSGIX_ovr_0 := GetFuncOrNil&<procedure(face: DummyEnum; pname: MaterialParameter; var ¶ms: single)>(z_FragmentMaterialfvSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentMaterialfvSGIX(face: DummyEnum; pname: MaterialParameter; ¶ms: array of single);
begin
z_FragmentMaterialfvSGIX_ovr_0(face, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentMaterialfvSGIX(face: DummyEnum; pname: MaterialParameter; var ¶ms: single);
begin
z_FragmentMaterialfvSGIX_ovr_0(face, pname, ¶ms);
end;
public z_FragmentMaterialfvSGIX_ovr_2 := GetFuncOrNil&<procedure(face: DummyEnum; pname: MaterialParameter; ¶ms: IntPtr)>(z_FragmentMaterialfvSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentMaterialfvSGIX(face: DummyEnum; pname: MaterialParameter; ¶ms: IntPtr);
begin
z_FragmentMaterialfvSGIX_ovr_2(face, pname, ¶ms);
end;
public z_FragmentMaterialiSGIX_adr := GetFuncAdr('glFragmentMaterialiSGIX');
public z_FragmentMaterialiSGIX_ovr_0 := GetFuncOrNil&<procedure(face: DummyEnum; pname: MaterialParameter; param: Int32)>(z_FragmentMaterialiSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentMaterialiSGIX(face: DummyEnum; pname: MaterialParameter; param: Int32);
begin
z_FragmentMaterialiSGIX_ovr_0(face, pname, param);
end;
public z_FragmentMaterialivSGIX_adr := GetFuncAdr('glFragmentMaterialivSGIX');
public z_FragmentMaterialivSGIX_ovr_0 := GetFuncOrNil&<procedure(face: DummyEnum; pname: MaterialParameter; var ¶ms: Int32)>(z_FragmentMaterialivSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentMaterialivSGIX(face: DummyEnum; pname: MaterialParameter; ¶ms: array of Int32);
begin
z_FragmentMaterialivSGIX_ovr_0(face, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentMaterialivSGIX(face: DummyEnum; pname: MaterialParameter; var ¶ms: Int32);
begin
z_FragmentMaterialivSGIX_ovr_0(face, pname, ¶ms);
end;
public z_FragmentMaterialivSGIX_ovr_2 := GetFuncOrNil&<procedure(face: DummyEnum; pname: MaterialParameter; ¶ms: IntPtr)>(z_FragmentMaterialivSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FragmentMaterialivSGIX(face: DummyEnum; pname: MaterialParameter; ¶ms: IntPtr);
begin
z_FragmentMaterialivSGIX_ovr_2(face, pname, ¶ms);
end;
public z_GetFragmentLightfvSGIX_adr := GetFuncAdr('glGetFragmentLightfvSGIX');
public z_GetFragmentLightfvSGIX_ovr_0 := GetFuncOrNil&<procedure(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; var ¶ms: single)>(z_GetFragmentLightfvSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFragmentLightfvSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: array of single);
begin
z_GetFragmentLightfvSGIX_ovr_0(light, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFragmentLightfvSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; var ¶ms: single);
begin
z_GetFragmentLightfvSGIX_ovr_0(light, pname, ¶ms);
end;
public z_GetFragmentLightfvSGIX_ovr_2 := GetFuncOrNil&<procedure(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: IntPtr)>(z_GetFragmentLightfvSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFragmentLightfvSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: IntPtr);
begin
z_GetFragmentLightfvSGIX_ovr_2(light, pname, ¶ms);
end;
public z_GetFragmentLightivSGIX_adr := GetFuncAdr('glGetFragmentLightivSGIX');
public z_GetFragmentLightivSGIX_ovr_0 := GetFuncOrNil&<procedure(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; var ¶ms: Int32)>(z_GetFragmentLightivSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFragmentLightivSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: array of Int32);
begin
z_GetFragmentLightivSGIX_ovr_0(light, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFragmentLightivSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; var ¶ms: Int32);
begin
z_GetFragmentLightivSGIX_ovr_0(light, pname, ¶ms);
end;
public z_GetFragmentLightivSGIX_ovr_2 := GetFuncOrNil&<procedure(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: IntPtr)>(z_GetFragmentLightivSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFragmentLightivSGIX(light: FragmentLightNameSGIX; pname: FragmentLightParameterSGIX; ¶ms: IntPtr);
begin
z_GetFragmentLightivSGIX_ovr_2(light, pname, ¶ms);
end;
public z_GetFragmentMaterialfvSGIX_adr := GetFuncAdr('glGetFragmentMaterialfvSGIX');
public z_GetFragmentMaterialfvSGIX_ovr_0 := GetFuncOrNil&<procedure(face: DummyEnum; pname: MaterialParameter; var ¶ms: single)>(z_GetFragmentMaterialfvSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFragmentMaterialfvSGIX(face: DummyEnum; pname: MaterialParameter; ¶ms: array of single);
begin
z_GetFragmentMaterialfvSGIX_ovr_0(face, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFragmentMaterialfvSGIX(face: DummyEnum; pname: MaterialParameter; var ¶ms: single);
begin
z_GetFragmentMaterialfvSGIX_ovr_0(face, pname, ¶ms);
end;
public z_GetFragmentMaterialfvSGIX_ovr_2 := GetFuncOrNil&<procedure(face: DummyEnum; pname: MaterialParameter; ¶ms: IntPtr)>(z_GetFragmentMaterialfvSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFragmentMaterialfvSGIX(face: DummyEnum; pname: MaterialParameter; ¶ms: IntPtr);
begin
z_GetFragmentMaterialfvSGIX_ovr_2(face, pname, ¶ms);
end;
public z_GetFragmentMaterialivSGIX_adr := GetFuncAdr('glGetFragmentMaterialivSGIX');
public z_GetFragmentMaterialivSGIX_ovr_0 := GetFuncOrNil&<procedure(face: DummyEnum; pname: MaterialParameter; var ¶ms: Int32)>(z_GetFragmentMaterialivSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFragmentMaterialivSGIX(face: DummyEnum; pname: MaterialParameter; ¶ms: array of Int32);
begin
z_GetFragmentMaterialivSGIX_ovr_0(face, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFragmentMaterialivSGIX(face: DummyEnum; pname: MaterialParameter; var ¶ms: Int32);
begin
z_GetFragmentMaterialivSGIX_ovr_0(face, pname, ¶ms);
end;
public z_GetFragmentMaterialivSGIX_ovr_2 := GetFuncOrNil&<procedure(face: DummyEnum; pname: MaterialParameter; ¶ms: IntPtr)>(z_GetFragmentMaterialivSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetFragmentMaterialivSGIX(face: DummyEnum; pname: MaterialParameter; ¶ms: IntPtr);
begin
z_GetFragmentMaterialivSGIX_ovr_2(face, pname, ¶ms);
end;
public z_LightEnviSGIX_adr := GetFuncAdr('glLightEnviSGIX');
public z_LightEnviSGIX_ovr_0 := GetFuncOrNil&<procedure(pname: LightEnvParameterSGIX; param: Int32)>(z_LightEnviSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LightEnviSGIX(pname: LightEnvParameterSGIX; param: Int32);
begin
z_LightEnviSGIX_ovr_0(pname, param);
end;
end;
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);
public z_FrameZoomSGIX_adr := GetFuncAdr('glFrameZoomSGIX');
public z_FrameZoomSGIX_ovr_0 := GetFuncOrNil&<procedure(factor: Int32)>(z_FrameZoomSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FrameZoomSGIX(factor: Int32);
begin
z_FrameZoomSGIX_ovr_0(factor);
end;
end;
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);
public z_IglooInterfaceSGIX_adr := GetFuncAdr('glIglooInterfaceSGIX');
public z_IglooInterfaceSGIX_ovr_0 := GetFuncOrNil&<procedure(pname: DummyEnum; ¶ms: IntPtr)>(z_IglooInterfaceSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure IglooInterfaceSGIX(pname: DummyEnum; ¶ms: IntPtr);
begin
z_IglooInterfaceSGIX_ovr_0(pname, ¶ms);
end;
end;
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);
public z_GetInstrumentsSGIX_adr := GetFuncAdr('glGetInstrumentsSGIX');
public z_GetInstrumentsSGIX_ovr_0 := GetFuncOrNil&<function: Int32>(z_GetInstrumentsSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function GetInstrumentsSGIX: Int32;
begin
Result := z_GetInstrumentsSGIX_ovr_0;
end;
public z_InstrumentsBufferSGIX_adr := GetFuncAdr('glInstrumentsBufferSGIX');
public z_InstrumentsBufferSGIX_ovr_0 := GetFuncOrNil&<procedure(size: Int32; var buffer: Int32)>(z_InstrumentsBufferSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InstrumentsBufferSGIX(size: Int32; buffer: array of Int32);
begin
z_InstrumentsBufferSGIX_ovr_0(size, buffer[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InstrumentsBufferSGIX(size: Int32; var buffer: Int32);
begin
z_InstrumentsBufferSGIX_ovr_0(size, buffer);
end;
public z_InstrumentsBufferSGIX_ovr_2 := GetFuncOrNil&<procedure(size: Int32; buffer: IntPtr)>(z_InstrumentsBufferSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure InstrumentsBufferSGIX(size: Int32; buffer: IntPtr);
begin
z_InstrumentsBufferSGIX_ovr_2(size, buffer);
end;
public z_PollInstrumentsSGIX_adr := GetFuncAdr('glPollInstrumentsSGIX');
public z_PollInstrumentsSGIX_ovr_0 := GetFuncOrNil&<function(var marker_p: Int32): Int32>(z_PollInstrumentsSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PollInstrumentsSGIX(marker_p: array of Int32): Int32;
begin
Result := z_PollInstrumentsSGIX_ovr_0(marker_p[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PollInstrumentsSGIX(var marker_p: Int32): Int32;
begin
Result := z_PollInstrumentsSGIX_ovr_0(marker_p);
end;
public z_PollInstrumentsSGIX_ovr_2 := GetFuncOrNil&<function(marker_p: IntPtr): Int32>(z_PollInstrumentsSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] function PollInstrumentsSGIX(marker_p: IntPtr): Int32;
begin
Result := z_PollInstrumentsSGIX_ovr_2(marker_p);
end;
public z_ReadInstrumentsSGIX_adr := GetFuncAdr('glReadInstrumentsSGIX');
public z_ReadInstrumentsSGIX_ovr_0 := GetFuncOrNil&<procedure(marker: Int32)>(z_ReadInstrumentsSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReadInstrumentsSGIX(marker: Int32);
begin
z_ReadInstrumentsSGIX_ovr_0(marker);
end;
public z_StartInstrumentsSGIX_adr := GetFuncAdr('glStartInstrumentsSGIX');
public z_StartInstrumentsSGIX_ovr_0 := GetFuncOrNil&<procedure>(z_StartInstrumentsSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StartInstrumentsSGIX;
begin
z_StartInstrumentsSGIX_ovr_0;
end;
public z_StopInstrumentsSGIX_adr := GetFuncAdr('glStopInstrumentsSGIX');
public z_StopInstrumentsSGIX_ovr_0 := GetFuncOrNil&<procedure(marker: Int32)>(z_StopInstrumentsSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure StopInstrumentsSGIX(marker: Int32);
begin
z_StopInstrumentsSGIX_ovr_0(marker);
end;
end;
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);
public z_GetListParameterfvSGIX_adr := GetFuncAdr('glGetListParameterfvSGIX');
public z_GetListParameterfvSGIX_ovr_0 := GetFuncOrNil&<procedure(list: UInt32; pname: ListParameterName; var ¶ms: single)>(z_GetListParameterfvSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetListParameterfvSGIX(list: UInt32; pname: ListParameterName; ¶ms: array of single);
begin
z_GetListParameterfvSGIX_ovr_0(list, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetListParameterfvSGIX(list: UInt32; pname: ListParameterName; var ¶ms: single);
begin
z_GetListParameterfvSGIX_ovr_0(list, pname, ¶ms);
end;
public z_GetListParameterfvSGIX_ovr_2 := GetFuncOrNil&<procedure(list: UInt32; pname: ListParameterName; ¶ms: IntPtr)>(z_GetListParameterfvSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetListParameterfvSGIX(list: UInt32; pname: ListParameterName; ¶ms: IntPtr);
begin
z_GetListParameterfvSGIX_ovr_2(list, pname, ¶ms);
end;
public z_GetListParameterivSGIX_adr := GetFuncAdr('glGetListParameterivSGIX');
public z_GetListParameterivSGIX_ovr_0 := GetFuncOrNil&<procedure(list: UInt32; pname: ListParameterName; var ¶ms: Int32)>(z_GetListParameterivSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetListParameterivSGIX(list: UInt32; pname: ListParameterName; ¶ms: array of Int32);
begin
z_GetListParameterivSGIX_ovr_0(list, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetListParameterivSGIX(list: UInt32; pname: ListParameterName; var ¶ms: Int32);
begin
z_GetListParameterivSGIX_ovr_0(list, pname, ¶ms);
end;
public z_GetListParameterivSGIX_ovr_2 := GetFuncOrNil&<procedure(list: UInt32; pname: ListParameterName; ¶ms: IntPtr)>(z_GetListParameterivSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetListParameterivSGIX(list: UInt32; pname: ListParameterName; ¶ms: IntPtr);
begin
z_GetListParameterivSGIX_ovr_2(list, pname, ¶ms);
end;
public z_ListParameterfSGIX_adr := GetFuncAdr('glListParameterfSGIX');
public z_ListParameterfSGIX_ovr_0 := GetFuncOrNil&<procedure(list: UInt32; pname: ListParameterName; param: single)>(z_ListParameterfSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListParameterfSGIX(list: UInt32; pname: ListParameterName; param: single);
begin
z_ListParameterfSGIX_ovr_0(list, pname, param);
end;
public z_ListParameterfvSGIX_adr := GetFuncAdr('glListParameterfvSGIX');
public z_ListParameterfvSGIX_ovr_0 := GetFuncOrNil&<procedure(list: UInt32; pname: ListParameterName; var ¶ms: single)>(z_ListParameterfvSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListParameterfvSGIX(list: UInt32; pname: ListParameterName; ¶ms: array of single);
begin
z_ListParameterfvSGIX_ovr_0(list, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListParameterfvSGIX(list: UInt32; pname: ListParameterName; var ¶ms: single);
begin
z_ListParameterfvSGIX_ovr_0(list, pname, ¶ms);
end;
public z_ListParameterfvSGIX_ovr_2 := GetFuncOrNil&<procedure(list: UInt32; pname: ListParameterName; ¶ms: IntPtr)>(z_ListParameterfvSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListParameterfvSGIX(list: UInt32; pname: ListParameterName; ¶ms: IntPtr);
begin
z_ListParameterfvSGIX_ovr_2(list, pname, ¶ms);
end;
public z_ListParameteriSGIX_adr := GetFuncAdr('glListParameteriSGIX');
public z_ListParameteriSGIX_ovr_0 := GetFuncOrNil&<procedure(list: UInt32; pname: ListParameterName; param: Int32)>(z_ListParameteriSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListParameteriSGIX(list: UInt32; pname: ListParameterName; param: Int32);
begin
z_ListParameteriSGIX_ovr_0(list, pname, param);
end;
public z_ListParameterivSGIX_adr := GetFuncAdr('glListParameterivSGIX');
public z_ListParameterivSGIX_ovr_0 := GetFuncOrNil&<procedure(list: UInt32; pname: ListParameterName; var ¶ms: Int32)>(z_ListParameterivSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListParameterivSGIX(list: UInt32; pname: ListParameterName; ¶ms: array of Int32);
begin
z_ListParameterivSGIX_ovr_0(list, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListParameterivSGIX(list: UInt32; pname: ListParameterName; var ¶ms: Int32);
begin
z_ListParameterivSGIX_ovr_0(list, pname, ¶ms);
end;
public z_ListParameterivSGIX_ovr_2 := GetFuncOrNil&<procedure(list: UInt32; pname: ListParameterName; ¶ms: IntPtr)>(z_ListParameterivSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ListParameterivSGIX(list: UInt32; pname: ListParameterName; ¶ms: IntPtr);
begin
z_ListParameterivSGIX_ovr_2(list, pname, ¶ms);
end;
end;
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);
public z_PixelTexGenSGIX_adr := GetFuncAdr('glPixelTexGenSGIX');
public z_PixelTexGenSGIX_ovr_0 := GetFuncOrNil&<procedure(mode: PixelTexGenModeSGIX)>(z_PixelTexGenSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure PixelTexGenSGIX(mode: PixelTexGenModeSGIX);
begin
z_PixelTexGenSGIX_ovr_0(mode);
end;
end;
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);
public z_DeformationMap3dSGIX_adr := GetFuncAdr('glDeformationMap3dSGIX');
public z_DeformationMap3dSGIX_ovr_0 := GetFuncOrNil&<procedure(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_adr);
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);
begin
z_DeformationMap3dSGIX_ovr_0(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points[0]);
end;
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);
begin
z_DeformationMap3dSGIX_ovr_0(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points);
end;
public z_DeformationMap3dSGIX_ovr_2 := GetFuncOrNil&<procedure(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_adr);
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);
begin
z_DeformationMap3dSGIX_ovr_2(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points);
end;
public z_DeformationMap3fSGIX_adr := GetFuncAdr('glDeformationMap3fSGIX');
public z_DeformationMap3fSGIX_ovr_0 := GetFuncOrNil&<procedure(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_adr);
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);
begin
z_DeformationMap3fSGIX_ovr_0(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points[0]);
end;
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);
begin
z_DeformationMap3fSGIX_ovr_0(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points);
end;
public z_DeformationMap3fSGIX_ovr_2 := GetFuncOrNil&<procedure(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_adr);
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);
begin
z_DeformationMap3fSGIX_ovr_2(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points);
end;
public z_DeformSGIX_adr := GetFuncAdr('glDeformSGIX');
public z_DeformSGIX_ovr_0 := GetFuncOrNil&<procedure(mask: DummyFlags)>(z_DeformSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DeformSGIX(mask: DummyFlags);
begin
z_DeformSGIX_ovr_0(mask);
end;
public z_LoadIdentityDeformationMapSGIX_adr := GetFuncAdr('glLoadIdentityDeformationMapSGIX');
public z_LoadIdentityDeformationMapSGIX_ovr_0 := GetFuncOrNil&<procedure(mask: DummyFlags)>(z_LoadIdentityDeformationMapSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure LoadIdentityDeformationMapSGIX(mask: DummyFlags);
begin
z_LoadIdentityDeformationMapSGIX_ovr_0(mask);
end;
end;
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);
public z_ReferencePlaneSGIX_adr := GetFuncAdr('glReferencePlaneSGIX');
public z_ReferencePlaneSGIX_ovr_0 := GetFuncOrNil&<procedure(var equation: real)>(z_ReferencePlaneSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReferencePlaneSGIX(equation: array of real);
begin
z_ReferencePlaneSGIX_ovr_0(equation[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReferencePlaneSGIX(var equation: real);
begin
z_ReferencePlaneSGIX_ovr_0(equation);
end;
public z_ReferencePlaneSGIX_ovr_2 := GetFuncOrNil&<procedure(equation: IntPtr)>(z_ReferencePlaneSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReferencePlaneSGIX(equation: IntPtr);
begin
z_ReferencePlaneSGIX_ovr_2(equation);
end;
end;
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);
public z_SpriteParameterfSGIX_adr := GetFuncAdr('glSpriteParameterfSGIX');
public z_SpriteParameterfSGIX_ovr_0 := GetFuncOrNil&<procedure(pname: SpriteParameterNameSGIX; param: single)>(z_SpriteParameterfSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpriteParameterfSGIX(pname: SpriteParameterNameSGIX; param: single);
begin
z_SpriteParameterfSGIX_ovr_0(pname, param);
end;
public z_SpriteParameterfvSGIX_adr := GetFuncAdr('glSpriteParameterfvSGIX');
public z_SpriteParameterfvSGIX_ovr_0 := GetFuncOrNil&<procedure(pname: SpriteParameterNameSGIX; var ¶ms: single)>(z_SpriteParameterfvSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpriteParameterfvSGIX(pname: SpriteParameterNameSGIX; ¶ms: array of single);
begin
z_SpriteParameterfvSGIX_ovr_0(pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpriteParameterfvSGIX(pname: SpriteParameterNameSGIX; var ¶ms: single);
begin
z_SpriteParameterfvSGIX_ovr_0(pname, ¶ms);
end;
public z_SpriteParameterfvSGIX_ovr_2 := GetFuncOrNil&<procedure(pname: SpriteParameterNameSGIX; ¶ms: IntPtr)>(z_SpriteParameterfvSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpriteParameterfvSGIX(pname: SpriteParameterNameSGIX; ¶ms: IntPtr);
begin
z_SpriteParameterfvSGIX_ovr_2(pname, ¶ms);
end;
public z_SpriteParameteriSGIX_adr := GetFuncAdr('glSpriteParameteriSGIX');
public z_SpriteParameteriSGIX_ovr_0 := GetFuncOrNil&<procedure(pname: SpriteParameterNameSGIX; param: Int32)>(z_SpriteParameteriSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpriteParameteriSGIX(pname: SpriteParameterNameSGIX; param: Int32);
begin
z_SpriteParameteriSGIX_ovr_0(pname, param);
end;
public z_SpriteParameterivSGIX_adr := GetFuncAdr('glSpriteParameterivSGIX');
public z_SpriteParameterivSGIX_ovr_0 := GetFuncOrNil&<procedure(pname: SpriteParameterNameSGIX; var ¶ms: Int32)>(z_SpriteParameterivSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpriteParameterivSGIX(pname: SpriteParameterNameSGIX; ¶ms: array of Int32);
begin
z_SpriteParameterivSGIX_ovr_0(pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpriteParameterivSGIX(pname: SpriteParameterNameSGIX; var ¶ms: Int32);
begin
z_SpriteParameterivSGIX_ovr_0(pname, ¶ms);
end;
public z_SpriteParameterivSGIX_ovr_2 := GetFuncOrNil&<procedure(pname: SpriteParameterNameSGIX; ¶ms: IntPtr)>(z_SpriteParameterivSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure SpriteParameterivSGIX(pname: SpriteParameterNameSGIX; ¶ms: IntPtr);
begin
z_SpriteParameterivSGIX_ovr_2(pname, ¶ms);
end;
end;
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);
public z_TagSampleBufferSGIX_adr := GetFuncAdr('glTagSampleBufferSGIX');
public z_TagSampleBufferSGIX_ovr_0 := GetFuncOrNil&<procedure>(z_TagSampleBufferSGIX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TagSampleBufferSGIX;
begin
z_TagSampleBufferSGIX_ovr_0;
end;
end;
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);
public z_ColorTableSGI_adr := GetFuncAdr('glColorTableSGI');
public z_ColorTableSGI_ovr_0 := GetFuncOrNil&<procedure(target: ColorTableTargetSGI; _internalformat: InternalFormat; width: Int32; format: PixelFormat; &type: PixelType; table: IntPtr)>(z_ColorTableSGI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorTableSGI(target: ColorTableTargetSGI; _internalformat: InternalFormat; width: Int32; format: PixelFormat; &type: PixelType; table: IntPtr);
begin
z_ColorTableSGI_ovr_0(target, _internalformat, width, format, &type, table);
end;
public z_ColorTableParameterfvSGI_adr := GetFuncAdr('glColorTableParameterfvSGI');
public z_ColorTableParameterfvSGI_ovr_0 := GetFuncOrNil&<procedure(target: ColorTableTargetSGI; pname: DummyEnum; var ¶ms: single)>(z_ColorTableParameterfvSGI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorTableParameterfvSGI(target: ColorTableTargetSGI; pname: DummyEnum; ¶ms: array of single);
begin
z_ColorTableParameterfvSGI_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorTableParameterfvSGI(target: ColorTableTargetSGI; pname: DummyEnum; var ¶ms: single);
begin
z_ColorTableParameterfvSGI_ovr_0(target, pname, ¶ms);
end;
public z_ColorTableParameterfvSGI_ovr_2 := GetFuncOrNil&<procedure(target: ColorTableTargetSGI; pname: DummyEnum; ¶ms: IntPtr)>(z_ColorTableParameterfvSGI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorTableParameterfvSGI(target: ColorTableTargetSGI; pname: DummyEnum; ¶ms: IntPtr);
begin
z_ColorTableParameterfvSGI_ovr_2(target, pname, ¶ms);
end;
public z_ColorTableParameterivSGI_adr := GetFuncAdr('glColorTableParameterivSGI');
public z_ColorTableParameterivSGI_ovr_0 := GetFuncOrNil&<procedure(target: ColorTableTargetSGI; pname: DummyEnum; var ¶ms: Int32)>(z_ColorTableParameterivSGI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorTableParameterivSGI(target: ColorTableTargetSGI; pname: DummyEnum; ¶ms: array of Int32);
begin
z_ColorTableParameterivSGI_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorTableParameterivSGI(target: ColorTableTargetSGI; pname: DummyEnum; var ¶ms: Int32);
begin
z_ColorTableParameterivSGI_ovr_0(target, pname, ¶ms);
end;
public z_ColorTableParameterivSGI_ovr_2 := GetFuncOrNil&<procedure(target: ColorTableTargetSGI; pname: DummyEnum; ¶ms: IntPtr)>(z_ColorTableParameterivSGI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ColorTableParameterivSGI(target: ColorTableTargetSGI; pname: DummyEnum; ¶ms: IntPtr);
begin
z_ColorTableParameterivSGI_ovr_2(target, pname, ¶ms);
end;
public z_CopyColorTableSGI_adr := GetFuncAdr('glCopyColorTableSGI');
public z_CopyColorTableSGI_ovr_0 := GetFuncOrNil&<procedure(target: ColorTableTargetSGI; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32)>(z_CopyColorTableSGI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure CopyColorTableSGI(target: ColorTableTargetSGI; _internalformat: InternalFormat; x: Int32; y: Int32; width: Int32);
begin
z_CopyColorTableSGI_ovr_0(target, _internalformat, x, y, width);
end;
public z_GetColorTableSGI_adr := GetFuncAdr('glGetColorTableSGI');
public z_GetColorTableSGI_ovr_0 := GetFuncOrNil&<procedure(target: ColorTableTargetSGI; format: PixelFormat; &type: PixelType; table: IntPtr)>(z_GetColorTableSGI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableSGI(target: ColorTableTargetSGI; format: PixelFormat; &type: PixelType; table: IntPtr);
begin
z_GetColorTableSGI_ovr_0(target, format, &type, table);
end;
public z_GetColorTableParameterfvSGI_adr := GetFuncAdr('glGetColorTableParameterfvSGI');
public z_GetColorTableParameterfvSGI_ovr_0 := GetFuncOrNil&<procedure(target: ColorTableTargetSGI; pname: GetColorTableParameterPNameSGI; var ¶ms: single)>(z_GetColorTableParameterfvSGI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameterfvSGI(target: ColorTableTargetSGI; pname: GetColorTableParameterPNameSGI; ¶ms: array of single);
begin
z_GetColorTableParameterfvSGI_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameterfvSGI(target: ColorTableTargetSGI; pname: GetColorTableParameterPNameSGI; var ¶ms: single);
begin
z_GetColorTableParameterfvSGI_ovr_0(target, pname, ¶ms);
end;
public z_GetColorTableParameterfvSGI_ovr_2 := GetFuncOrNil&<procedure(target: ColorTableTargetSGI; pname: GetColorTableParameterPNameSGI; ¶ms: IntPtr)>(z_GetColorTableParameterfvSGI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameterfvSGI(target: ColorTableTargetSGI; pname: GetColorTableParameterPNameSGI; ¶ms: IntPtr);
begin
z_GetColorTableParameterfvSGI_ovr_2(target, pname, ¶ms);
end;
public z_GetColorTableParameterivSGI_adr := GetFuncAdr('glGetColorTableParameterivSGI');
public z_GetColorTableParameterivSGI_ovr_0 := GetFuncOrNil&<procedure(target: ColorTableTargetSGI; pname: GetColorTableParameterPNameSGI; var ¶ms: Int32)>(z_GetColorTableParameterivSGI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameterivSGI(target: ColorTableTargetSGI; pname: GetColorTableParameterPNameSGI; ¶ms: array of Int32);
begin
z_GetColorTableParameterivSGI_ovr_0(target, pname, ¶ms[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameterivSGI(target: ColorTableTargetSGI; pname: GetColorTableParameterPNameSGI; var ¶ms: Int32);
begin
z_GetColorTableParameterivSGI_ovr_0(target, pname, ¶ms);
end;
public z_GetColorTableParameterivSGI_ovr_2 := GetFuncOrNil&<procedure(target: ColorTableTargetSGI; pname: GetColorTableParameterPNameSGI; ¶ms: IntPtr)>(z_GetColorTableParameterivSGI_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetColorTableParameterivSGI(target: ColorTableTargetSGI; pname: GetColorTableParameterPNameSGI; ¶ms: IntPtr);
begin
z_GetColorTableParameterivSGI_ovr_2(target, pname, ¶ms);
end;
end;
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);
public z_FinishTextureSUNX_adr := GetFuncAdr('glFinishTextureSUNX');
public z_FinishTextureSUNX_ovr_0 := GetFuncOrNil&<procedure>(z_FinishTextureSUNX_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FinishTextureSUNX;
begin
z_FinishTextureSUNX_ovr_0;
end;
end;
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);
public z_GlobalAlphaFactorbSUN_adr := GetFuncAdr('glGlobalAlphaFactorbSUN');
public z_GlobalAlphaFactorbSUN_ovr_0 := GetFuncOrNil&<procedure(factor: SByte)>(z_GlobalAlphaFactorbSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GlobalAlphaFactorbSUN(factor: SByte);
begin
z_GlobalAlphaFactorbSUN_ovr_0(factor);
end;
public z_GlobalAlphaFactorsSUN_adr := GetFuncAdr('glGlobalAlphaFactorsSUN');
public z_GlobalAlphaFactorsSUN_ovr_0 := GetFuncOrNil&<procedure(factor: Int16)>(z_GlobalAlphaFactorsSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GlobalAlphaFactorsSUN(factor: Int16);
begin
z_GlobalAlphaFactorsSUN_ovr_0(factor);
end;
public z_GlobalAlphaFactoriSUN_adr := GetFuncAdr('glGlobalAlphaFactoriSUN');
public z_GlobalAlphaFactoriSUN_ovr_0 := GetFuncOrNil&<procedure(factor: Int32)>(z_GlobalAlphaFactoriSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GlobalAlphaFactoriSUN(factor: Int32);
begin
z_GlobalAlphaFactoriSUN_ovr_0(factor);
end;
public z_GlobalAlphaFactorfSUN_adr := GetFuncAdr('glGlobalAlphaFactorfSUN');
public z_GlobalAlphaFactorfSUN_ovr_0 := GetFuncOrNil&<procedure(factor: single)>(z_GlobalAlphaFactorfSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GlobalAlphaFactorfSUN(factor: single);
begin
z_GlobalAlphaFactorfSUN_ovr_0(factor);
end;
public z_GlobalAlphaFactordSUN_adr := GetFuncAdr('glGlobalAlphaFactordSUN');
public z_GlobalAlphaFactordSUN_ovr_0 := GetFuncOrNil&<procedure(factor: real)>(z_GlobalAlphaFactordSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GlobalAlphaFactordSUN(factor: real);
begin
z_GlobalAlphaFactordSUN_ovr_0(factor);
end;
public z_GlobalAlphaFactorubSUN_adr := GetFuncAdr('glGlobalAlphaFactorubSUN');
public z_GlobalAlphaFactorubSUN_ovr_0 := GetFuncOrNil&<procedure(factor: Byte)>(z_GlobalAlphaFactorubSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GlobalAlphaFactorubSUN(factor: Byte);
begin
z_GlobalAlphaFactorubSUN_ovr_0(factor);
end;
public z_GlobalAlphaFactorusSUN_adr := GetFuncAdr('glGlobalAlphaFactorusSUN');
public z_GlobalAlphaFactorusSUN_ovr_0 := GetFuncOrNil&<procedure(factor: UInt16)>(z_GlobalAlphaFactorusSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GlobalAlphaFactorusSUN(factor: UInt16);
begin
z_GlobalAlphaFactorusSUN_ovr_0(factor);
end;
public z_GlobalAlphaFactoruiSUN_adr := GetFuncAdr('glGlobalAlphaFactoruiSUN');
public z_GlobalAlphaFactoruiSUN_ovr_0 := GetFuncOrNil&<procedure(factor: UInt32)>(z_GlobalAlphaFactoruiSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GlobalAlphaFactoruiSUN(factor: UInt32);
begin
z_GlobalAlphaFactoruiSUN_ovr_0(factor);
end;
end;
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);
public z_DrawMeshArraysSUN_adr := GetFuncAdr('glDrawMeshArraysSUN');
public z_DrawMeshArraysSUN_ovr_0 := GetFuncOrNil&<procedure(mode: PrimitiveType; first: Int32; count: Int32; width: Int32)>(z_DrawMeshArraysSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure DrawMeshArraysSUN(mode: PrimitiveType; first: Int32; count: Int32; width: Int32);
begin
z_DrawMeshArraysSUN_ovr_0(mode, first, count, width);
end;
end;
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);
public z_ReplacementCodeuiSUN_adr := GetFuncAdr('glReplacementCodeuiSUN');
public z_ReplacementCodeuiSUN_ovr_0 := GetFuncOrNil&<procedure(code: UInt32)>(z_ReplacementCodeuiSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiSUN(code: UInt32);
begin
z_ReplacementCodeuiSUN_ovr_0(code);
end;
public z_ReplacementCodeusSUN_adr := GetFuncAdr('glReplacementCodeusSUN');
public z_ReplacementCodeusSUN_ovr_0 := GetFuncOrNil&<procedure(code: UInt16)>(z_ReplacementCodeusSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeusSUN(code: UInt16);
begin
z_ReplacementCodeusSUN_ovr_0(code);
end;
public z_ReplacementCodeubSUN_adr := GetFuncAdr('glReplacementCodeubSUN');
public z_ReplacementCodeubSUN_ovr_0 := GetFuncOrNil&<procedure(code: Byte)>(z_ReplacementCodeubSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeubSUN(code: Byte);
begin
z_ReplacementCodeubSUN_ovr_0(code);
end;
public z_ReplacementCodeuivSUN_adr := GetFuncAdr('glReplacementCodeuivSUN');
public z_ReplacementCodeuivSUN_ovr_0 := GetFuncOrNil&<procedure(var code: UInt32)>(z_ReplacementCodeuivSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuivSUN(code: array of UInt32);
begin
z_ReplacementCodeuivSUN_ovr_0(code[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuivSUN(var code: UInt32);
begin
z_ReplacementCodeuivSUN_ovr_0(code);
end;
public z_ReplacementCodeuivSUN_ovr_2 := GetFuncOrNil&<procedure(code: IntPtr)>(z_ReplacementCodeuivSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuivSUN(code: IntPtr);
begin
z_ReplacementCodeuivSUN_ovr_2(code);
end;
public z_ReplacementCodeusvSUN_adr := GetFuncAdr('glReplacementCodeusvSUN');
public z_ReplacementCodeusvSUN_ovr_0 := GetFuncOrNil&<procedure(var code: UInt16)>(z_ReplacementCodeusvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeusvSUN(code: array of UInt16);
begin
z_ReplacementCodeusvSUN_ovr_0(code[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeusvSUN(var code: UInt16);
begin
z_ReplacementCodeusvSUN_ovr_0(code);
end;
public z_ReplacementCodeusvSUN_ovr_2 := GetFuncOrNil&<procedure(code: IntPtr)>(z_ReplacementCodeusvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeusvSUN(code: IntPtr);
begin
z_ReplacementCodeusvSUN_ovr_2(code);
end;
public z_ReplacementCodeubvSUN_adr := GetFuncAdr('glReplacementCodeubvSUN');
public z_ReplacementCodeubvSUN_ovr_0 := GetFuncOrNil&<procedure(var code: Byte)>(z_ReplacementCodeubvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeubvSUN(code: array of Byte);
begin
z_ReplacementCodeubvSUN_ovr_0(code[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeubvSUN(var code: Byte);
begin
z_ReplacementCodeubvSUN_ovr_0(code);
end;
public z_ReplacementCodeubvSUN_ovr_2 := GetFuncOrNil&<procedure(code: IntPtr)>(z_ReplacementCodeubvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeubvSUN(code: IntPtr);
begin
z_ReplacementCodeubvSUN_ovr_2(code);
end;
public z_ReplacementCodePointerSUN_adr := GetFuncAdr('glReplacementCodePointerSUN');
public z_ReplacementCodePointerSUN_ovr_0 := GetFuncOrNil&<procedure(&type: ReplacementCodeTypeSUN; stride: Int32; var _pointer: IntPtr)>(z_ReplacementCodePointerSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodePointerSUN(&type: ReplacementCodeTypeSUN; stride: Int32; _pointer: array of IntPtr);
begin
z_ReplacementCodePointerSUN_ovr_0(&type, stride, _pointer[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodePointerSUN(&type: ReplacementCodeTypeSUN; stride: Int32; var _pointer: IntPtr);
begin
z_ReplacementCodePointerSUN_ovr_0(&type, stride, _pointer);
end;
public z_ReplacementCodePointerSUN_ovr_2 := GetFuncOrNil&<procedure(&type: ReplacementCodeTypeSUN; stride: Int32; _pointer: pointer)>(z_ReplacementCodePointerSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodePointerSUN(&type: ReplacementCodeTypeSUN; stride: Int32; _pointer: pointer);
begin
z_ReplacementCodePointerSUN_ovr_2(&type, stride, _pointer);
end;
end;
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);
public z_Color4ubVertex2fSUN_adr := GetFuncAdr('glColor4ubVertex2fSUN');
public z_Color4ubVertex2fSUN_ovr_0 := GetFuncOrNil&<procedure(r: Byte; g: Byte; b: Byte; a: Byte; x: single; y: single)>(z_Color4ubVertex2fSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ubVertex2fSUN(r: Byte; g: Byte; b: Byte; a: Byte; x: single; y: single);
begin
z_Color4ubVertex2fSUN_ovr_0(r, g, b, a, x, y);
end;
public z_Color4ubVertex2fvSUN_adr := GetFuncAdr('glColor4ubVertex2fvSUN');
public z_Color4ubVertex2fvSUN_ovr_0 := GetFuncOrNil&<procedure(var c: Vec4ub; var v: Vec2f)>(z_Color4ubVertex2fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ubVertex2fvSUN(var c: Vec4ub; var v: Vec2f);
begin
z_Color4ubVertex2fvSUN_ovr_0(c, v);
end;
public z_Color4ubVertex2fvSUN_ovr_1 := GetFuncOrNil&<procedure(var c: Byte; var v: single)>(z_Color4ubVertex2fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ubVertex2fvSUN(c: array of Byte; v: array of single);
begin
z_Color4ubVertex2fvSUN_ovr_1(c[0], v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ubVertex2fvSUN(var c: Byte; var v: single);
begin
z_Color4ubVertex2fvSUN_ovr_1(c, v);
end;
public z_Color4ubVertex2fvSUN_ovr_3 := GetFuncOrNil&<procedure(c: IntPtr; v: IntPtr)>(z_Color4ubVertex2fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ubVertex2fvSUN(c: IntPtr; v: IntPtr);
begin
z_Color4ubVertex2fvSUN_ovr_3(c, v);
end;
public z_Color4ubVertex3fSUN_adr := GetFuncAdr('glColor4ubVertex3fSUN');
public z_Color4ubVertex3fSUN_ovr_0 := GetFuncOrNil&<procedure(r: Byte; g: Byte; b: Byte; a: Byte; x: single; y: single; z: single)>(z_Color4ubVertex3fSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ubVertex3fSUN(r: Byte; g: Byte; b: Byte; a: Byte; x: single; y: single; z: single);
begin
z_Color4ubVertex3fSUN_ovr_0(r, g, b, a, x, y, z);
end;
public z_Color4ubVertex3fvSUN_adr := GetFuncAdr('glColor4ubVertex3fvSUN');
public z_Color4ubVertex3fvSUN_ovr_0 := GetFuncOrNil&<procedure(var c: Vec4ub; var v: Vec3f)>(z_Color4ubVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ubVertex3fvSUN(var c: Vec4ub; var v: Vec3f);
begin
z_Color4ubVertex3fvSUN_ovr_0(c, v);
end;
public z_Color4ubVertex3fvSUN_ovr_1 := GetFuncOrNil&<procedure(var c: Byte; var v: single)>(z_Color4ubVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ubVertex3fvSUN(c: array of Byte; v: array of single);
begin
z_Color4ubVertex3fvSUN_ovr_1(c[0], v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ubVertex3fvSUN(var c: Byte; var v: single);
begin
z_Color4ubVertex3fvSUN_ovr_1(c, v);
end;
public z_Color4ubVertex3fvSUN_ovr_3 := GetFuncOrNil&<procedure(c: IntPtr; v: IntPtr)>(z_Color4ubVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4ubVertex3fvSUN(c: IntPtr; v: IntPtr);
begin
z_Color4ubVertex3fvSUN_ovr_3(c, v);
end;
public z_Color3fVertex3fSUN_adr := GetFuncAdr('glColor3fVertex3fSUN');
public z_Color3fVertex3fSUN_ovr_0 := GetFuncOrNil&<procedure(r: single; g: single; b: single; x: single; y: single; z: single)>(z_Color3fVertex3fSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3fVertex3fSUN(r: single; g: single; b: single; x: single; y: single; z: single);
begin
z_Color3fVertex3fSUN_ovr_0(r, g, b, x, y, z);
end;
public z_Color3fVertex3fvSUN_adr := GetFuncAdr('glColor3fVertex3fvSUN');
public z_Color3fVertex3fvSUN_ovr_0 := GetFuncOrNil&<procedure(var c: Vec3f; var v: Vec3f)>(z_Color3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3fVertex3fvSUN(var c: Vec3f; var v: Vec3f);
begin
z_Color3fVertex3fvSUN_ovr_0(c, v);
end;
public z_Color3fVertex3fvSUN_ovr_1 := GetFuncOrNil&<procedure(var c: single; var v: single)>(z_Color3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3fVertex3fvSUN(c: array of single; v: array of single);
begin
z_Color3fVertex3fvSUN_ovr_1(c[0], v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3fVertex3fvSUN(var c: single; var v: single);
begin
z_Color3fVertex3fvSUN_ovr_1(c, v);
end;
public z_Color3fVertex3fvSUN_ovr_3 := GetFuncOrNil&<procedure(c: IntPtr; v: IntPtr)>(z_Color3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color3fVertex3fvSUN(c: IntPtr; v: IntPtr);
begin
z_Color3fVertex3fvSUN_ovr_3(c, v);
end;
public z_Normal3fVertex3fSUN_adr := GetFuncAdr('glNormal3fVertex3fSUN');
public z_Normal3fVertex3fSUN_ovr_0 := GetFuncOrNil&<procedure(nx: single; ny: single; nz: single; x: single; y: single; z: single)>(z_Normal3fVertex3fSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3fVertex3fSUN(nx: single; ny: single; nz: single; x: single; y: single; z: single);
begin
z_Normal3fVertex3fSUN_ovr_0(nx, ny, nz, x, y, z);
end;
public z_Normal3fVertex3fvSUN_adr := GetFuncAdr('glNormal3fVertex3fvSUN');
public z_Normal3fVertex3fvSUN_ovr_0 := GetFuncOrNil&<procedure(var n: Vec3f; var v: Vec3f)>(z_Normal3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3fVertex3fvSUN(var n: Vec3f; var v: Vec3f);
begin
z_Normal3fVertex3fvSUN_ovr_0(n, v);
end;
public z_Normal3fVertex3fvSUN_ovr_1 := GetFuncOrNil&<procedure(var n: single; var v: single)>(z_Normal3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3fVertex3fvSUN(n: array of single; v: array of single);
begin
z_Normal3fVertex3fvSUN_ovr_1(n[0], v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3fVertex3fvSUN(var n: single; var v: single);
begin
z_Normal3fVertex3fvSUN_ovr_1(n, v);
end;
public z_Normal3fVertex3fvSUN_ovr_3 := GetFuncOrNil&<procedure(n: IntPtr; v: IntPtr)>(z_Normal3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Normal3fVertex3fvSUN(n: IntPtr; v: IntPtr);
begin
z_Normal3fVertex3fvSUN_ovr_3(n, v);
end;
public z_Color4fNormal3fVertex3fSUN_adr := GetFuncAdr('glColor4fNormal3fVertex3fSUN');
public z_Color4fNormal3fVertex3fSUN_ovr_0 := GetFuncOrNil&<procedure(r: single; g: single; b: single; a: single; nx: single; ny: single; nz: single; x: single; y: single; z: single)>(z_Color4fNormal3fVertex3fSUN_adr);
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);
begin
z_Color4fNormal3fVertex3fSUN_ovr_0(r, g, b, a, nx, ny, nz, x, y, z);
end;
public z_Color4fNormal3fVertex3fvSUN_adr := GetFuncAdr('glColor4fNormal3fVertex3fvSUN');
public z_Color4fNormal3fVertex3fvSUN_ovr_0 := GetFuncOrNil&<procedure(var c: Vec4f; var n: Vec3f; var v: Vec3f)>(z_Color4fNormal3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4fNormal3fVertex3fvSUN(var c: Vec4f; var n: Vec3f; var v: Vec3f);
begin
z_Color4fNormal3fVertex3fvSUN_ovr_0(c, n, v);
end;
public z_Color4fNormal3fVertex3fvSUN_ovr_1 := GetFuncOrNil&<procedure(var c: single; var n: single; var v: single)>(z_Color4fNormal3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4fNormal3fVertex3fvSUN(c: array of single; n: array of single; v: array of single);
begin
z_Color4fNormal3fVertex3fvSUN_ovr_1(c[0], n[0], v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4fNormal3fVertex3fvSUN(var c: single; var n: single; var v: single);
begin
z_Color4fNormal3fVertex3fvSUN_ovr_1(c, n, v);
end;
public z_Color4fNormal3fVertex3fvSUN_ovr_3 := GetFuncOrNil&<procedure(c: IntPtr; n: IntPtr; v: IntPtr)>(z_Color4fNormal3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Color4fNormal3fVertex3fvSUN(c: IntPtr; n: IntPtr; v: IntPtr);
begin
z_Color4fNormal3fVertex3fvSUN_ovr_3(c, n, v);
end;
public z_TexCoord2fVertex3fSUN_adr := GetFuncAdr('glTexCoord2fVertex3fSUN');
public z_TexCoord2fVertex3fSUN_ovr_0 := GetFuncOrNil&<procedure(s: single; t: single; x: single; y: single; z: single)>(z_TexCoord2fVertex3fSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fVertex3fSUN(s: single; t: single; x: single; y: single; z: single);
begin
z_TexCoord2fVertex3fSUN_ovr_0(s, t, x, y, z);
end;
public z_TexCoord2fVertex3fvSUN_adr := GetFuncAdr('glTexCoord2fVertex3fvSUN');
public z_TexCoord2fVertex3fvSUN_ovr_0 := GetFuncOrNil&<procedure(var tc: Vec2f; var v: Vec3f)>(z_TexCoord2fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fVertex3fvSUN(var tc: Vec2f; var v: Vec3f);
begin
z_TexCoord2fVertex3fvSUN_ovr_0(tc, v);
end;
public z_TexCoord2fVertex3fvSUN_ovr_1 := GetFuncOrNil&<procedure(var tc: single; var v: single)>(z_TexCoord2fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fVertex3fvSUN(tc: array of single; v: array of single);
begin
z_TexCoord2fVertex3fvSUN_ovr_1(tc[0], v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fVertex3fvSUN(var tc: single; var v: single);
begin
z_TexCoord2fVertex3fvSUN_ovr_1(tc, v);
end;
public z_TexCoord2fVertex3fvSUN_ovr_3 := GetFuncOrNil&<procedure(tc: IntPtr; v: IntPtr)>(z_TexCoord2fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fVertex3fvSUN(tc: IntPtr; v: IntPtr);
begin
z_TexCoord2fVertex3fvSUN_ovr_3(tc, v);
end;
public z_TexCoord4fVertex4fSUN_adr := GetFuncAdr('glTexCoord4fVertex4fSUN');
public z_TexCoord4fVertex4fSUN_ovr_0 := GetFuncOrNil&<procedure(s: single; t: single; p: single; q: single; x: single; y: single; z: single; w: single)>(z_TexCoord4fVertex4fSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4fVertex4fSUN(s: single; t: single; p: single; q: single; x: single; y: single; z: single; w: single);
begin
z_TexCoord4fVertex4fSUN_ovr_0(s, t, p, q, x, y, z, w);
end;
public z_TexCoord4fVertex4fvSUN_adr := GetFuncAdr('glTexCoord4fVertex4fvSUN');
public z_TexCoord4fVertex4fvSUN_ovr_0 := GetFuncOrNil&<procedure(var tc: Vec4f; var v: Vec4f)>(z_TexCoord4fVertex4fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4fVertex4fvSUN(var tc: Vec4f; var v: Vec4f);
begin
z_TexCoord4fVertex4fvSUN_ovr_0(tc, v);
end;
public z_TexCoord4fVertex4fvSUN_ovr_1 := GetFuncOrNil&<procedure(var tc: single; var v: single)>(z_TexCoord4fVertex4fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4fVertex4fvSUN(tc: array of single; v: array of single);
begin
z_TexCoord4fVertex4fvSUN_ovr_1(tc[0], v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4fVertex4fvSUN(var tc: single; var v: single);
begin
z_TexCoord4fVertex4fvSUN_ovr_1(tc, v);
end;
public z_TexCoord4fVertex4fvSUN_ovr_3 := GetFuncOrNil&<procedure(tc: IntPtr; v: IntPtr)>(z_TexCoord4fVertex4fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4fVertex4fvSUN(tc: IntPtr; v: IntPtr);
begin
z_TexCoord4fVertex4fvSUN_ovr_3(tc, v);
end;
public z_TexCoord2fColor4ubVertex3fSUN_adr := GetFuncAdr('glTexCoord2fColor4ubVertex3fSUN');
public z_TexCoord2fColor4ubVertex3fSUN_ovr_0 := GetFuncOrNil&<procedure(s: single; t: single; r: Byte; g: Byte; b: Byte; a: Byte; x: single; y: single; z: single)>(z_TexCoord2fColor4ubVertex3fSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor4ubVertex3fSUN(s: single; t: single; r: Byte; g: Byte; b: Byte; a: Byte; x: single; y: single; z: single);
begin
z_TexCoord2fColor4ubVertex3fSUN_ovr_0(s, t, r, g, b, a, x, y, z);
end;
public z_TexCoord2fColor4ubVertex3fvSUN_adr := GetFuncAdr('glTexCoord2fColor4ubVertex3fvSUN');
public z_TexCoord2fColor4ubVertex3fvSUN_ovr_0 := GetFuncOrNil&<procedure(var tc: Vec2f; var c: Vec4ub; var v: Vec3f)>(z_TexCoord2fColor4ubVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor4ubVertex3fvSUN(var tc: Vec2f; var c: Vec4ub; var v: Vec3f);
begin
z_TexCoord2fColor4ubVertex3fvSUN_ovr_0(tc, c, v);
end;
public z_TexCoord2fColor4ubVertex3fvSUN_ovr_1 := GetFuncOrNil&<procedure(var tc: single; var c: Byte; var v: single)>(z_TexCoord2fColor4ubVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor4ubVertex3fvSUN(tc: array of single; c: array of Byte; v: array of single);
begin
z_TexCoord2fColor4ubVertex3fvSUN_ovr_1(tc[0], c[0], v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor4ubVertex3fvSUN(var tc: single; var c: Byte; var v: single);
begin
z_TexCoord2fColor4ubVertex3fvSUN_ovr_1(tc, c, v);
end;
public z_TexCoord2fColor4ubVertex3fvSUN_ovr_3 := GetFuncOrNil&<procedure(tc: IntPtr; c: IntPtr; v: IntPtr)>(z_TexCoord2fColor4ubVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor4ubVertex3fvSUN(tc: IntPtr; c: IntPtr; v: IntPtr);
begin
z_TexCoord2fColor4ubVertex3fvSUN_ovr_3(tc, c, v);
end;
public z_TexCoord2fColor3fVertex3fSUN_adr := GetFuncAdr('glTexCoord2fColor3fVertex3fSUN');
public z_TexCoord2fColor3fVertex3fSUN_ovr_0 := GetFuncOrNil&<procedure(s: single; t: single; r: single; g: single; b: single; x: single; y: single; z: single)>(z_TexCoord2fColor3fVertex3fSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor3fVertex3fSUN(s: single; t: single; r: single; g: single; b: single; x: single; y: single; z: single);
begin
z_TexCoord2fColor3fVertex3fSUN_ovr_0(s, t, r, g, b, x, y, z);
end;
public z_TexCoord2fColor3fVertex3fvSUN_adr := GetFuncAdr('glTexCoord2fColor3fVertex3fvSUN');
public z_TexCoord2fColor3fVertex3fvSUN_ovr_0 := GetFuncOrNil&<procedure(var tc: Vec2f; var c: Vec3f; var v: Vec3f)>(z_TexCoord2fColor3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor3fVertex3fvSUN(var tc: Vec2f; var c: Vec3f; var v: Vec3f);
begin
z_TexCoord2fColor3fVertex3fvSUN_ovr_0(tc, c, v);
end;
public z_TexCoord2fColor3fVertex3fvSUN_ovr_1 := GetFuncOrNil&<procedure(var tc: single; var c: single; var v: single)>(z_TexCoord2fColor3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor3fVertex3fvSUN(tc: array of single; c: array of single; v: array of single);
begin
z_TexCoord2fColor3fVertex3fvSUN_ovr_1(tc[0], c[0], v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor3fVertex3fvSUN(var tc: single; var c: single; var v: single);
begin
z_TexCoord2fColor3fVertex3fvSUN_ovr_1(tc, c, v);
end;
public z_TexCoord2fColor3fVertex3fvSUN_ovr_3 := GetFuncOrNil&<procedure(tc: IntPtr; c: IntPtr; v: IntPtr)>(z_TexCoord2fColor3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor3fVertex3fvSUN(tc: IntPtr; c: IntPtr; v: IntPtr);
begin
z_TexCoord2fColor3fVertex3fvSUN_ovr_3(tc, c, v);
end;
public z_TexCoord2fNormal3fVertex3fSUN_adr := GetFuncAdr('glTexCoord2fNormal3fVertex3fSUN');
public z_TexCoord2fNormal3fVertex3fSUN_ovr_0 := GetFuncOrNil&<procedure(s: single; t: single; nx: single; ny: single; nz: single; x: single; y: single; z: single)>(z_TexCoord2fNormal3fVertex3fSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fNormal3fVertex3fSUN(s: single; t: single; nx: single; ny: single; nz: single; x: single; y: single; z: single);
begin
z_TexCoord2fNormal3fVertex3fSUN_ovr_0(s, t, nx, ny, nz, x, y, z);
end;
public z_TexCoord2fNormal3fVertex3fvSUN_adr := GetFuncAdr('glTexCoord2fNormal3fVertex3fvSUN');
public z_TexCoord2fNormal3fVertex3fvSUN_ovr_0 := GetFuncOrNil&<procedure(var tc: Vec2f; var n: Vec3f; var v: Vec3f)>(z_TexCoord2fNormal3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fNormal3fVertex3fvSUN(var tc: Vec2f; var n: Vec3f; var v: Vec3f);
begin
z_TexCoord2fNormal3fVertex3fvSUN_ovr_0(tc, n, v);
end;
public z_TexCoord2fNormal3fVertex3fvSUN_ovr_1 := GetFuncOrNil&<procedure(var tc: single; var n: single; var v: single)>(z_TexCoord2fNormal3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fNormal3fVertex3fvSUN(tc: array of single; n: array of single; v: array of single);
begin
z_TexCoord2fNormal3fVertex3fvSUN_ovr_1(tc[0], n[0], v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fNormal3fVertex3fvSUN(var tc: single; var n: single; var v: single);
begin
z_TexCoord2fNormal3fVertex3fvSUN_ovr_1(tc, n, v);
end;
public z_TexCoord2fNormal3fVertex3fvSUN_ovr_3 := GetFuncOrNil&<procedure(tc: IntPtr; n: IntPtr; v: IntPtr)>(z_TexCoord2fNormal3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fNormal3fVertex3fvSUN(tc: IntPtr; n: IntPtr; v: IntPtr);
begin
z_TexCoord2fNormal3fVertex3fvSUN_ovr_3(tc, n, v);
end;
public z_TexCoord2fColor4fNormal3fVertex3fSUN_adr := GetFuncAdr('glTexCoord2fColor4fNormal3fVertex3fSUN');
public z_TexCoord2fColor4fNormal3fVertex3fSUN_ovr_0 := GetFuncOrNil&<procedure(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_adr);
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);
begin
z_TexCoord2fColor4fNormal3fVertex3fSUN_ovr_0(s, t, r, g, b, a, nx, ny, nz, x, y, z);
end;
public z_TexCoord2fColor4fNormal3fVertex3fvSUN_adr := GetFuncAdr('glTexCoord2fColor4fNormal3fVertex3fvSUN');
public z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_0 := GetFuncOrNil&<procedure(var tc: Vec2f; var c: Vec4f; var n: Vec3f; var v: Vec3f)>(z_TexCoord2fColor4fNormal3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor4fNormal3fVertex3fvSUN(var tc: Vec2f; var c: Vec4f; var n: Vec3f; var v: Vec3f);
begin
z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_0(tc, c, n, v);
end;
public z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1 := GetFuncOrNil&<procedure(var tc: single; var c: single; var n: single; var v: single)>(z_TexCoord2fColor4fNormal3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor4fNormal3fVertex3fvSUN(tc: array of single; c: array of single; n: array of single; v: array of single);
begin
z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1(tc[0], c[0], n[0], v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor4fNormal3fVertex3fvSUN(var tc: single; var c: single; var n: single; var v: single);
begin
z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1(tc, c, n, v);
end;
public z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_3 := GetFuncOrNil&<procedure(tc: IntPtr; c: IntPtr; n: IntPtr; v: IntPtr)>(z_TexCoord2fColor4fNormal3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord2fColor4fNormal3fVertex3fvSUN(tc: IntPtr; c: IntPtr; n: IntPtr; v: IntPtr);
begin
z_TexCoord2fColor4fNormal3fVertex3fvSUN_ovr_3(tc, c, n, v);
end;
public z_TexCoord4fColor4fNormal3fVertex4fSUN_adr := GetFuncAdr('glTexCoord4fColor4fNormal3fVertex4fSUN');
public z_TexCoord4fColor4fNormal3fVertex4fSUN_ovr_0 := GetFuncOrNil&<procedure(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_adr);
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);
begin
z_TexCoord4fColor4fNormal3fVertex4fSUN_ovr_0(s, t, p, q, r, g, b, a, nx, ny, nz, x, y, z, w);
end;
public z_TexCoord4fColor4fNormal3fVertex4fvSUN_adr := GetFuncAdr('glTexCoord4fColor4fNormal3fVertex4fvSUN');
public z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_0 := GetFuncOrNil&<procedure(var tc: Vec4f; var c: Vec4f; var n: Vec3f; var v: Vec4f)>(z_TexCoord4fColor4fNormal3fVertex4fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4fColor4fNormal3fVertex4fvSUN(var tc: Vec4f; var c: Vec4f; var n: Vec3f; var v: Vec4f);
begin
z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_0(tc, c, n, v);
end;
public z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1 := GetFuncOrNil&<procedure(var tc: single; var c: single; var n: single; var v: single)>(z_TexCoord4fColor4fNormal3fVertex4fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4fColor4fNormal3fVertex4fvSUN(tc: array of single; c: array of single; n: array of single; v: array of single);
begin
z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1(tc[0], c[0], n[0], v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4fColor4fNormal3fVertex4fvSUN(var tc: single; var c: single; var n: single; var v: single);
begin
z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_1(tc, c, n, v);
end;
public z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_3 := GetFuncOrNil&<procedure(tc: IntPtr; c: IntPtr; n: IntPtr; v: IntPtr)>(z_TexCoord4fColor4fNormal3fVertex4fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure TexCoord4fColor4fNormal3fVertex4fvSUN(tc: IntPtr; c: IntPtr; n: IntPtr; v: IntPtr);
begin
z_TexCoord4fColor4fNormal3fVertex4fvSUN_ovr_3(tc, c, n, v);
end;
public z_ReplacementCodeuiVertex3fSUN_adr := GetFuncAdr('glReplacementCodeuiVertex3fSUN');
public z_ReplacementCodeuiVertex3fSUN_ovr_0 := GetFuncOrNil&<procedure(rc: UInt32; x: single; y: single; z: single)>(z_ReplacementCodeuiVertex3fSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiVertex3fSUN(rc: UInt32; x: single; y: single; z: single);
begin
z_ReplacementCodeuiVertex3fSUN_ovr_0(rc, x, y, z);
end;
public z_ReplacementCodeuiVertex3fvSUN_adr := GetFuncAdr('glReplacementCodeuiVertex3fvSUN');
public z_ReplacementCodeuiVertex3fvSUN_ovr_0 := GetFuncOrNil&<procedure(var rc: UInt32; var v: Vec3f)>(z_ReplacementCodeuiVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiVertex3fvSUN(var rc: UInt32; var v: Vec3f);
begin
z_ReplacementCodeuiVertex3fvSUN_ovr_0(rc, v);
end;
public z_ReplacementCodeuiVertex3fvSUN_ovr_1 := GetFuncOrNil&<procedure(var rc: UInt32; var v: single)>(z_ReplacementCodeuiVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiVertex3fvSUN(var rc: UInt32; v: array of single);
begin
z_ReplacementCodeuiVertex3fvSUN_ovr_1(rc, v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiVertex3fvSUN(var rc: UInt32; var v: single);
begin
z_ReplacementCodeuiVertex3fvSUN_ovr_1(rc, v);
end;
public z_ReplacementCodeuiVertex3fvSUN_ovr_3 := GetFuncOrNil&<procedure(rc: IntPtr; v: IntPtr)>(z_ReplacementCodeuiVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiVertex3fvSUN(rc: IntPtr; v: IntPtr);
begin
z_ReplacementCodeuiVertex3fvSUN_ovr_3(rc, v);
end;
public z_ReplacementCodeuiColor4ubVertex3fSUN_adr := GetFuncAdr('glReplacementCodeuiColor4ubVertex3fSUN');
public z_ReplacementCodeuiColor4ubVertex3fSUN_ovr_0 := GetFuncOrNil&<procedure(rc: UInt32; r: Byte; g: Byte; b: Byte; a: Byte; x: single; y: single; z: single)>(z_ReplacementCodeuiColor4ubVertex3fSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor4ubVertex3fSUN(rc: UInt32; r: Byte; g: Byte; b: Byte; a: Byte; x: single; y: single; z: single);
begin
z_ReplacementCodeuiColor4ubVertex3fSUN_ovr_0(rc, r, g, b, a, x, y, z);
end;
public z_ReplacementCodeuiColor4ubVertex3fvSUN_adr := GetFuncAdr('glReplacementCodeuiColor4ubVertex3fvSUN');
public z_ReplacementCodeuiColor4ubVertex3fvSUN_ovr_0 := GetFuncOrNil&<procedure(var rc: UInt32; var c: Vec4ub; var v: Vec3f)>(z_ReplacementCodeuiColor4ubVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor4ubVertex3fvSUN(var rc: UInt32; var c: Vec4ub; var v: Vec3f);
begin
z_ReplacementCodeuiColor4ubVertex3fvSUN_ovr_0(rc, c, v);
end;
public z_ReplacementCodeuiColor4ubVertex3fvSUN_ovr_1 := GetFuncOrNil&<procedure(var rc: UInt32; var c: Byte; var v: single)>(z_ReplacementCodeuiColor4ubVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor4ubVertex3fvSUN(var rc: UInt32; c: array of Byte; v: array of single);
begin
z_ReplacementCodeuiColor4ubVertex3fvSUN_ovr_1(rc, c[0], v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor4ubVertex3fvSUN(var rc: UInt32; var c: Byte; var v: single);
begin
z_ReplacementCodeuiColor4ubVertex3fvSUN_ovr_1(rc, c, v);
end;
public z_ReplacementCodeuiColor4ubVertex3fvSUN_ovr_3 := GetFuncOrNil&<procedure(rc: IntPtr; c: IntPtr; v: IntPtr)>(z_ReplacementCodeuiColor4ubVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor4ubVertex3fvSUN(rc: IntPtr; c: IntPtr; v: IntPtr);
begin
z_ReplacementCodeuiColor4ubVertex3fvSUN_ovr_3(rc, c, v);
end;
public z_ReplacementCodeuiColor3fVertex3fSUN_adr := GetFuncAdr('glReplacementCodeuiColor3fVertex3fSUN');
public z_ReplacementCodeuiColor3fVertex3fSUN_ovr_0 := GetFuncOrNil&<procedure(rc: UInt32; r: single; g: single; b: single; x: single; y: single; z: single)>(z_ReplacementCodeuiColor3fVertex3fSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor3fVertex3fSUN(rc: UInt32; r: single; g: single; b: single; x: single; y: single; z: single);
begin
z_ReplacementCodeuiColor3fVertex3fSUN_ovr_0(rc, r, g, b, x, y, z);
end;
public z_ReplacementCodeuiColor3fVertex3fvSUN_adr := GetFuncAdr('glReplacementCodeuiColor3fVertex3fvSUN');
public z_ReplacementCodeuiColor3fVertex3fvSUN_ovr_0 := GetFuncOrNil&<procedure(var rc: UInt32; var c: Vec3f; var v: Vec3f)>(z_ReplacementCodeuiColor3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor3fVertex3fvSUN(var rc: UInt32; var c: Vec3f; var v: Vec3f);
begin
z_ReplacementCodeuiColor3fVertex3fvSUN_ovr_0(rc, c, v);
end;
public z_ReplacementCodeuiColor3fVertex3fvSUN_ovr_1 := GetFuncOrNil&<procedure(var rc: UInt32; var c: single; var v: single)>(z_ReplacementCodeuiColor3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor3fVertex3fvSUN(var rc: UInt32; c: array of single; v: array of single);
begin
z_ReplacementCodeuiColor3fVertex3fvSUN_ovr_1(rc, c[0], v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor3fVertex3fvSUN(var rc: UInt32; var c: single; var v: single);
begin
z_ReplacementCodeuiColor3fVertex3fvSUN_ovr_1(rc, c, v);
end;
public z_ReplacementCodeuiColor3fVertex3fvSUN_ovr_3 := GetFuncOrNil&<procedure(rc: IntPtr; c: IntPtr; v: IntPtr)>(z_ReplacementCodeuiColor3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor3fVertex3fvSUN(rc: IntPtr; c: IntPtr; v: IntPtr);
begin
z_ReplacementCodeuiColor3fVertex3fvSUN_ovr_3(rc, c, v);
end;
public z_ReplacementCodeuiNormal3fVertex3fSUN_adr := GetFuncAdr('glReplacementCodeuiNormal3fVertex3fSUN');
public z_ReplacementCodeuiNormal3fVertex3fSUN_ovr_0 := GetFuncOrNil&<procedure(rc: UInt32; nx: single; ny: single; nz: single; x: single; y: single; z: single)>(z_ReplacementCodeuiNormal3fVertex3fSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiNormal3fVertex3fSUN(rc: UInt32; nx: single; ny: single; nz: single; x: single; y: single; z: single);
begin
z_ReplacementCodeuiNormal3fVertex3fSUN_ovr_0(rc, nx, ny, nz, x, y, z);
end;
public z_ReplacementCodeuiNormal3fVertex3fvSUN_adr := GetFuncAdr('glReplacementCodeuiNormal3fVertex3fvSUN');
public z_ReplacementCodeuiNormal3fVertex3fvSUN_ovr_0 := GetFuncOrNil&<procedure(var rc: UInt32; var n: Vec3f; var v: Vec3f)>(z_ReplacementCodeuiNormal3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiNormal3fVertex3fvSUN(var rc: UInt32; var n: Vec3f; var v: Vec3f);
begin
z_ReplacementCodeuiNormal3fVertex3fvSUN_ovr_0(rc, n, v);
end;
public z_ReplacementCodeuiNormal3fVertex3fvSUN_ovr_1 := GetFuncOrNil&<procedure(var rc: UInt32; var n: single; var v: single)>(z_ReplacementCodeuiNormal3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiNormal3fVertex3fvSUN(var rc: UInt32; n: array of single; v: array of single);
begin
z_ReplacementCodeuiNormal3fVertex3fvSUN_ovr_1(rc, n[0], v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiNormal3fVertex3fvSUN(var rc: UInt32; var n: single; var v: single);
begin
z_ReplacementCodeuiNormal3fVertex3fvSUN_ovr_1(rc, n, v);
end;
public z_ReplacementCodeuiNormal3fVertex3fvSUN_ovr_3 := GetFuncOrNil&<procedure(rc: IntPtr; n: IntPtr; v: IntPtr)>(z_ReplacementCodeuiNormal3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiNormal3fVertex3fvSUN(rc: IntPtr; n: IntPtr; v: IntPtr);
begin
z_ReplacementCodeuiNormal3fVertex3fvSUN_ovr_3(rc, n, v);
end;
public z_ReplacementCodeuiColor4fNormal3fVertex3fSUN_adr := GetFuncAdr('glReplacementCodeuiColor4fNormal3fVertex3fSUN');
public z_ReplacementCodeuiColor4fNormal3fVertex3fSUN_ovr_0 := GetFuncOrNil&<procedure(rc: UInt32; r: single; g: single; b: single; a: single; nx: single; ny: single; nz: single; x: single; y: single; z: single)>(z_ReplacementCodeuiColor4fNormal3fVertex3fSUN_adr);
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);
begin
z_ReplacementCodeuiColor4fNormal3fVertex3fSUN_ovr_0(rc, r, g, b, a, nx, ny, nz, x, y, z);
end;
public z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_adr := GetFuncAdr('glReplacementCodeuiColor4fNormal3fVertex3fvSUN');
public z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_0 := GetFuncOrNil&<procedure(var rc: UInt32; var c: Vec4f; var n: Vec3f; var v: Vec3f)>(z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor4fNormal3fVertex3fvSUN(var rc: UInt32; var c: Vec4f; var n: Vec3f; var v: Vec3f);
begin
z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_0(rc, c, n, v);
end;
public z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_1 := GetFuncOrNil&<procedure(var rc: UInt32; var c: single; var n: single; var v: single)>(z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor4fNormal3fVertex3fvSUN(var rc: UInt32; c: array of single; n: array of single; v: array of single);
begin
z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_1(rc, c[0], n[0], v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor4fNormal3fVertex3fvSUN(var rc: UInt32; var c: single; var n: single; var v: single);
begin
z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_1(rc, c, n, v);
end;
public z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_3 := GetFuncOrNil&<procedure(rc: IntPtr; c: IntPtr; n: IntPtr; v: IntPtr)>(z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc: IntPtr; c: IntPtr; n: IntPtr; v: IntPtr);
begin
z_ReplacementCodeuiColor4fNormal3fVertex3fvSUN_ovr_3(rc, c, n, v);
end;
public z_ReplacementCodeuiTexCoord2fVertex3fSUN_adr := GetFuncAdr('glReplacementCodeuiTexCoord2fVertex3fSUN');
public z_ReplacementCodeuiTexCoord2fVertex3fSUN_ovr_0 := GetFuncOrNil&<procedure(rc: UInt32; s: single; t: single; x: single; y: single; z: single)>(z_ReplacementCodeuiTexCoord2fVertex3fSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fVertex3fSUN(rc: UInt32; s: single; t: single; x: single; y: single; z: single);
begin
z_ReplacementCodeuiTexCoord2fVertex3fSUN_ovr_0(rc, s, t, x, y, z);
end;
public z_ReplacementCodeuiTexCoord2fVertex3fvSUN_adr := GetFuncAdr('glReplacementCodeuiTexCoord2fVertex3fvSUN');
public z_ReplacementCodeuiTexCoord2fVertex3fvSUN_ovr_0 := GetFuncOrNil&<procedure(var rc: UInt32; var tc: Vec2f; var v: Vec3f)>(z_ReplacementCodeuiTexCoord2fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fVertex3fvSUN(var rc: UInt32; var tc: Vec2f; var v: Vec3f);
begin
z_ReplacementCodeuiTexCoord2fVertex3fvSUN_ovr_0(rc, tc, v);
end;
public z_ReplacementCodeuiTexCoord2fVertex3fvSUN_ovr_1 := GetFuncOrNil&<procedure(var rc: UInt32; var tc: single; var v: single)>(z_ReplacementCodeuiTexCoord2fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fVertex3fvSUN(var rc: UInt32; tc: array of single; v: array of single);
begin
z_ReplacementCodeuiTexCoord2fVertex3fvSUN_ovr_1(rc, tc[0], v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fVertex3fvSUN(var rc: UInt32; var tc: single; var v: single);
begin
z_ReplacementCodeuiTexCoord2fVertex3fvSUN_ovr_1(rc, tc, v);
end;
public z_ReplacementCodeuiTexCoord2fVertex3fvSUN_ovr_3 := GetFuncOrNil&<procedure(rc: IntPtr; tc: IntPtr; v: IntPtr)>(z_ReplacementCodeuiTexCoord2fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fVertex3fvSUN(rc: IntPtr; tc: IntPtr; v: IntPtr);
begin
z_ReplacementCodeuiTexCoord2fVertex3fvSUN_ovr_3(rc, tc, v);
end;
public z_ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN_adr := GetFuncAdr('glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN');
public z_ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN_ovr_0 := GetFuncOrNil&<procedure(rc: UInt32; s: single; t: single; nx: single; ny: single; nz: single; x: single; y: single; z: single)>(z_ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(rc: UInt32; s: single; t: single; nx: single; ny: single; nz: single; x: single; y: single; z: single);
begin
z_ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN_ovr_0(rc, s, t, nx, ny, nz, x, y, z);
end;
public z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_adr := GetFuncAdr('glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN');
public z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_0 := GetFuncOrNil&<procedure(var rc: UInt32; var tc: Vec2f; var n: Vec3f; var v: Vec3f)>(z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(var rc: UInt32; var tc: Vec2f; var n: Vec3f; var v: Vec3f);
begin
z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_0(rc, tc, n, v);
end;
public z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_1 := GetFuncOrNil&<procedure(var rc: UInt32; var tc: single; var n: single; var v: single)>(z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(var rc: UInt32; tc: array of single; n: array of single; v: array of single);
begin
z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_1(rc, tc[0], n[0], v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(var rc: UInt32; var tc: single; var n: single; var v: single);
begin
z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_1(rc, tc, n, v);
end;
public z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_3 := GetFuncOrNil&<procedure(rc: IntPtr; tc: IntPtr; n: IntPtr; v: IntPtr)>(z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc: IntPtr; tc: IntPtr; n: IntPtr; v: IntPtr);
begin
z_ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN_ovr_3(rc, tc, n, v);
end;
public z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN_adr := GetFuncAdr('glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN');
public z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN_ovr_0 := GetFuncOrNil&<procedure(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_adr);
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);
begin
z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN_ovr_0(rc, s, t, r, g, b, a, nx, ny, nz, x, y, z);
end;
public z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_adr := GetFuncAdr('glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN');
public z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_0 := GetFuncOrNil&<procedure(var rc: UInt32; var tc: Vec2f; var c: Vec4f; var n: Vec3f; var v: Vec3f)>(z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(var rc: UInt32; var tc: Vec2f; var c: Vec4f; var n: Vec3f; var v: Vec3f);
begin
z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_0(rc, tc, c, n, v);
end;
public z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1 := GetFuncOrNil&<procedure(var rc: UInt32; var tc: single; var c: single; var n: single; var v: single)>(z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_adr);
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);
begin
z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1(rc, tc[0], c[0], n[0], v[0]);
end;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(var rc: UInt32; var tc: single; var c: single; var n: single; var v: single);
begin
z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_1(rc, tc, c, n, v);
end;
public z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_3 := GetFuncOrNil&<procedure(rc: IntPtr; tc: IntPtr; c: IntPtr; n: IntPtr; v: IntPtr)>(z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_adr);
public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc: IntPtr; tc: IntPtr; c: IntPtr; n: IntPtr; v: IntPtr);
begin
z_ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN_ovr_3(rc, tc, c, n, v);
end;
end;
wglStereoControl3DL = static class
private static function _z_SetStereoEmitterState3DL_ovr0(hDC: GDI_DC; uState: UInt32): UInt32;
external 'opengl32.dll' name 'wglSetStereoEmitterState3DL';
public static z_SetStereoEmitterState3DL_ovr0 := _z_SetStereoEmitterState3DL_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetStereoEmitterState3DL(hDC: GDI_DC; uState: UInt32): UInt32 := z_SetStereoEmitterState3DL_ovr0(hDC, uState);
end;
wglGpuAssociationAMD = static class
private static function _z_GetGPUIDsAMD_ovr0(maxCount: UInt32; [MarshalAs(UnmanagedType.LPArray)] ids: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglGetGPUIDsAMD';
public static z_GetGPUIDsAMD_ovr0 := _z_GetGPUIDsAMD_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGPUIDsAMD(maxCount: UInt32; ids: array of UInt32): UInt32 := z_GetGPUIDsAMD_ovr0(maxCount, ids);
private static function _z_GetGPUIDsAMD_ovr1(maxCount: UInt32; var ids: UInt32): UInt32;
external 'opengl32.dll' name 'wglGetGPUIDsAMD';
public static z_GetGPUIDsAMD_ovr1 := _z_GetGPUIDsAMD_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGPUIDsAMD(maxCount: UInt32; var ids: UInt32): UInt32 := z_GetGPUIDsAMD_ovr1(maxCount, ids);
private static function _z_GetGPUIDsAMD_ovr2(maxCount: UInt32; ids: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGPUIDsAMD';
public static z_GetGPUIDsAMD_ovr2 := _z_GetGPUIDsAMD_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGPUIDsAMD(maxCount: UInt32; ids: IntPtr): UInt32 := z_GetGPUIDsAMD_ovr2(maxCount, ids);
private static function _z_GetGPUInfoAMD_ovr0(id: UInt32; &property: Int32; dataType: DummyEnum; size: UInt32; data: IntPtr): Int32;
external 'opengl32.dll' name 'wglGetGPUInfoAMD';
public static z_GetGPUInfoAMD_ovr0 := _z_GetGPUInfoAMD_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGPUInfoAMD(id: UInt32; &property: Int32; dataType: DummyEnum; size: UInt32; data: IntPtr): Int32 := z_GetGPUInfoAMD_ovr0(id, &property, dataType, size, data);
private static function _z_GetContextGPUIDAMD_ovr0(hglrc: GLContext): UInt32;
external 'opengl32.dll' name 'wglGetContextGPUIDAMD';
public static z_GetContextGPUIDAMD_ovr0 := _z_GetContextGPUIDAMD_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetContextGPUIDAMD(hglrc: GLContext): UInt32 := z_GetContextGPUIDAMD_ovr0(hglrc);
private static function _z_CreateAssociatedContextAMD_ovr0(id: UInt32): GLContext;
external 'opengl32.dll' name 'wglCreateAssociatedContextAMD';
public static z_CreateAssociatedContextAMD_ovr0 := _z_CreateAssociatedContextAMD_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateAssociatedContextAMD(id: UInt32): GLContext := z_CreateAssociatedContextAMD_ovr0(id);
private static function _z_CreateAssociatedContextAttribsAMD_ovr0(id: UInt32; hShareContext: GLContext; [MarshalAs(UnmanagedType.LPArray)] attribList: array of Int32): GLContext;
external 'opengl32.dll' name 'wglCreateAssociatedContextAttribsAMD';
public static z_CreateAssociatedContextAttribsAMD_ovr0 := _z_CreateAssociatedContextAttribsAMD_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateAssociatedContextAttribsAMD(id: UInt32; hShareContext: GLContext; attribList: array of Int32): GLContext := z_CreateAssociatedContextAttribsAMD_ovr0(id, hShareContext, attribList);
private static function _z_CreateAssociatedContextAttribsAMD_ovr1(id: UInt32; hShareContext: GLContext; var attribList: Int32): GLContext;
external 'opengl32.dll' name 'wglCreateAssociatedContextAttribsAMD';
public static z_CreateAssociatedContextAttribsAMD_ovr1 := _z_CreateAssociatedContextAttribsAMD_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateAssociatedContextAttribsAMD(id: UInt32; hShareContext: GLContext; var attribList: Int32): GLContext := z_CreateAssociatedContextAttribsAMD_ovr1(id, hShareContext, attribList);
private static function _z_CreateAssociatedContextAttribsAMD_ovr2(id: UInt32; hShareContext: GLContext; attribList: IntPtr): GLContext;
external 'opengl32.dll' name 'wglCreateAssociatedContextAttribsAMD';
public static z_CreateAssociatedContextAttribsAMD_ovr2 := _z_CreateAssociatedContextAttribsAMD_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateAssociatedContextAttribsAMD(id: UInt32; hShareContext: GLContext; attribList: IntPtr): GLContext := z_CreateAssociatedContextAttribsAMD_ovr2(id, hShareContext, attribList);
private static function _z_DeleteAssociatedContextAMD_ovr0(hglrc: GLContext): UInt32;
external 'opengl32.dll' name 'wglDeleteAssociatedContextAMD';
public static z_DeleteAssociatedContextAMD_ovr0 := _z_DeleteAssociatedContextAMD_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DeleteAssociatedContextAMD(hglrc: GLContext): UInt32 := z_DeleteAssociatedContextAMD_ovr0(hglrc);
private static function _z_MakeAssociatedContextCurrentAMD_ovr0(hglrc: GLContext): UInt32;
external 'opengl32.dll' name 'wglMakeAssociatedContextCurrentAMD';
public static z_MakeAssociatedContextCurrentAMD_ovr0 := _z_MakeAssociatedContextCurrentAMD_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function MakeAssociatedContextCurrentAMD(hglrc: GLContext): UInt32 := z_MakeAssociatedContextCurrentAMD_ovr0(hglrc);
private static function _z_GetCurrentAssociatedContextAMD_ovr0: GLContext;
external 'opengl32.dll' name 'wglGetCurrentAssociatedContextAMD';
public static z_GetCurrentAssociatedContextAMD_ovr0: function: GLContext := _z_GetCurrentAssociatedContextAMD_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetCurrentAssociatedContextAMD: GLContext := z_GetCurrentAssociatedContextAMD_ovr0;
private static procedure _z_BlitContextFramebufferAMD_ovr0(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 static z_BlitContextFramebufferAMD_ovr0 := _z_BlitContextFramebufferAMD_ovr0;
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_ovr0(dstCtx, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
end;
wglBufferRegionARB = static class
private static function _z_CreateBufferRegionARB_ovr0(hDC: GDI_DC; iLayerPlane: Int32; uType: UInt32): IntPtr;
external 'opengl32.dll' name 'wglCreateBufferRegionARB';
public static z_CreateBufferRegionARB_ovr0 := _z_CreateBufferRegionARB_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateBufferRegionARB(hDC: GDI_DC; iLayerPlane: Int32; uType: UInt32): IntPtr := z_CreateBufferRegionARB_ovr0(hDC, iLayerPlane, uType);
private static procedure _z_DeleteBufferRegionARB_ovr0(hRegion: IntPtr);
external 'opengl32.dll' name 'wglDeleteBufferRegionARB';
public static z_DeleteBufferRegionARB_ovr0 := _z_DeleteBufferRegionARB_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static procedure DeleteBufferRegionARB(hRegion: IntPtr) := z_DeleteBufferRegionARB_ovr0(hRegion);
private static function _z_SaveBufferRegionARB_ovr0(hRegion: IntPtr; x: Int32; y: Int32; width: Int32; height: Int32): UInt32;
external 'opengl32.dll' name 'wglSaveBufferRegionARB';
public static z_SaveBufferRegionARB_ovr0 := _z_SaveBufferRegionARB_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SaveBufferRegionARB(hRegion: IntPtr; x: Int32; y: Int32; width: Int32; height: Int32): UInt32 := z_SaveBufferRegionARB_ovr0(hRegion, x, y, width, height);
private static function _z_RestoreBufferRegionARB_ovr0(hRegion: IntPtr; x: Int32; y: Int32; width: Int32; height: Int32; xSrc: Int32; ySrc: Int32): UInt32;
external 'opengl32.dll' name 'wglRestoreBufferRegionARB';
public static z_RestoreBufferRegionARB_ovr0 := _z_RestoreBufferRegionARB_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function RestoreBufferRegionARB(hRegion: IntPtr; x: Int32; y: Int32; width: Int32; height: Int32; xSrc: Int32; ySrc: Int32): UInt32 := z_RestoreBufferRegionARB_ovr0(hRegion, x, y, width, height, xSrc, ySrc);
end;
wglCreateContextARB = static class
private static function _z_CreateContextAttribsARB_ovr0(hDC: GDI_DC; hShareContext: GLContext; [MarshalAs(UnmanagedType.LPArray)] attribList: array of Int32): GLContext;
external 'opengl32.dll' name 'wglCreateContextAttribsARB';
public static z_CreateContextAttribsARB_ovr0 := _z_CreateContextAttribsARB_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateContextAttribsARB(hDC: GDI_DC; hShareContext: GLContext; attribList: array of Int32): GLContext := z_CreateContextAttribsARB_ovr0(hDC, hShareContext, attribList);
private static function _z_CreateContextAttribsARB_ovr1(hDC: GDI_DC; hShareContext: GLContext; var attribList: Int32): GLContext;
external 'opengl32.dll' name 'wglCreateContextAttribsARB';
public static z_CreateContextAttribsARB_ovr1 := _z_CreateContextAttribsARB_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateContextAttribsARB(hDC: GDI_DC; hShareContext: GLContext; var attribList: Int32): GLContext := z_CreateContextAttribsARB_ovr1(hDC, hShareContext, attribList);
private static function _z_CreateContextAttribsARB_ovr2(hDC: GDI_DC; hShareContext: GLContext; attribList: IntPtr): GLContext;
external 'opengl32.dll' name 'wglCreateContextAttribsARB';
public static z_CreateContextAttribsARB_ovr2 := _z_CreateContextAttribsARB_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateContextAttribsARB(hDC: GDI_DC; hShareContext: GLContext; attribList: IntPtr): GLContext := z_CreateContextAttribsARB_ovr2(hDC, hShareContext, attribList);
end;
wglExtensionsStringARB = static class
private [Result: MarshalAs(UnmanagedType.LPStr)] static function _z_GetExtensionsStringARB_ovr0(hdc: GDI_DC): string;
external 'opengl32.dll' name 'wglGetExtensionsStringARB';
public static z_GetExtensionsStringARB_ovr0 := _z_GetExtensionsStringARB_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetExtensionsStringARB(hdc: GDI_DC): string := z_GetExtensionsStringARB_ovr0(hdc);
end;
wglMakeCurrentReadARB = static class
private static function _z_MakeContextCurrentARB_ovr0(hDrawDC: GDI_DC; hReadDC: GDI_DC; hglrc: GLContext): UInt32;
external 'opengl32.dll' name 'wglMakeContextCurrentARB';
public static z_MakeContextCurrentARB_ovr0 := _z_MakeContextCurrentARB_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function MakeContextCurrentARB(hDrawDC: GDI_DC; hReadDC: GDI_DC; hglrc: GLContext): UInt32 := z_MakeContextCurrentARB_ovr0(hDrawDC, hReadDC, hglrc);
private static function _z_GetCurrentReadDCARB_ovr0: GDI_DC;
external 'opengl32.dll' name 'wglGetCurrentReadDCARB';
public static z_GetCurrentReadDCARB_ovr0: function: GDI_DC := _z_GetCurrentReadDCARB_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetCurrentReadDCARB: GDI_DC := z_GetCurrentReadDCARB_ovr0;
end;
wglPbufferARB = static class
private static function _z_CreatePbufferARB_ovr0(hDC: GDI_DC; iPixelFormat: Int32; iWidth: Int32; iHeight: Int32; [MarshalAs(UnmanagedType.LPArray)] piAttribList: array of Int32): HPBUFFER;
external 'opengl32.dll' name 'wglCreatePbufferARB';
public static z_CreatePbufferARB_ovr0 := _z_CreatePbufferARB_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreatePbufferARB(hDC: GDI_DC; iPixelFormat: Int32; iWidth: Int32; iHeight: Int32; piAttribList: array of Int32): HPBUFFER := z_CreatePbufferARB_ovr0(hDC, iPixelFormat, iWidth, iHeight, piAttribList);
private static function _z_CreatePbufferARB_ovr1(hDC: GDI_DC; iPixelFormat: Int32; iWidth: Int32; iHeight: Int32; var piAttribList: Int32): HPBUFFER;
external 'opengl32.dll' name 'wglCreatePbufferARB';
public static z_CreatePbufferARB_ovr1 := _z_CreatePbufferARB_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreatePbufferARB(hDC: GDI_DC; iPixelFormat: Int32; iWidth: Int32; iHeight: Int32; var piAttribList: Int32): HPBUFFER := z_CreatePbufferARB_ovr1(hDC, iPixelFormat, iWidth, iHeight, piAttribList);
private static function _z_CreatePbufferARB_ovr2(hDC: GDI_DC; iPixelFormat: Int32; iWidth: Int32; iHeight: Int32; piAttribList: IntPtr): HPBUFFER;
external 'opengl32.dll' name 'wglCreatePbufferARB';
public static z_CreatePbufferARB_ovr2 := _z_CreatePbufferARB_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreatePbufferARB(hDC: GDI_DC; iPixelFormat: Int32; iWidth: Int32; iHeight: Int32; piAttribList: IntPtr): HPBUFFER := z_CreatePbufferARB_ovr2(hDC, iPixelFormat, iWidth, iHeight, piAttribList);
private static function _z_GetPbufferDCARB_ovr0(_hPbuffer: HPBUFFER): GDI_DC;
external 'opengl32.dll' name 'wglGetPbufferDCARB';
public static z_GetPbufferDCARB_ovr0 := _z_GetPbufferDCARB_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPbufferDCARB(_hPbuffer: HPBUFFER): GDI_DC := z_GetPbufferDCARB_ovr0(_hPbuffer);
private static function _z_ReleasePbufferDCARB_ovr0(_hPbuffer: HPBUFFER; hDC: GDI_DC): Int32;
external 'opengl32.dll' name 'wglReleasePbufferDCARB';
public static z_ReleasePbufferDCARB_ovr0 := _z_ReleasePbufferDCARB_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleasePbufferDCARB(_hPbuffer: HPBUFFER; hDC: GDI_DC): Int32 := z_ReleasePbufferDCARB_ovr0(_hPbuffer, hDC);
private static function _z_DestroyPbufferARB_ovr0(_hPbuffer: HPBUFFER): UInt32;
external 'opengl32.dll' name 'wglDestroyPbufferARB';
public static z_DestroyPbufferARB_ovr0 := _z_DestroyPbufferARB_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DestroyPbufferARB(_hPbuffer: HPBUFFER): UInt32 := z_DestroyPbufferARB_ovr0(_hPbuffer);
private static function _z_QueryPbufferARB_ovr0(_hPbuffer: HPBUFFER; iAttribute: Int32; [MarshalAs(UnmanagedType.LPArray)] piValue: array of Int32): UInt32;
external 'opengl32.dll' name 'wglQueryPbufferARB';
public static z_QueryPbufferARB_ovr0 := _z_QueryPbufferARB_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryPbufferARB(_hPbuffer: HPBUFFER; iAttribute: Int32; piValue: array of Int32): UInt32 := z_QueryPbufferARB_ovr0(_hPbuffer, iAttribute, piValue);
private static function _z_QueryPbufferARB_ovr1(_hPbuffer: HPBUFFER; iAttribute: Int32; var piValue: Int32): UInt32;
external 'opengl32.dll' name 'wglQueryPbufferARB';
public static z_QueryPbufferARB_ovr1 := _z_QueryPbufferARB_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryPbufferARB(_hPbuffer: HPBUFFER; iAttribute: Int32; var piValue: Int32): UInt32 := z_QueryPbufferARB_ovr1(_hPbuffer, iAttribute, piValue);
private static function _z_QueryPbufferARB_ovr2(_hPbuffer: HPBUFFER; iAttribute: Int32; piValue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryPbufferARB';
public static z_QueryPbufferARB_ovr2 := _z_QueryPbufferARB_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryPbufferARB(_hPbuffer: HPBUFFER; iAttribute: Int32; piValue: IntPtr): UInt32 := z_QueryPbufferARB_ovr2(_hPbuffer, iAttribute, piValue);
end;
wglPixelFormatARB = static class
private static function _z_GetPixelFormatAttribivARB_ovr0(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; [MarshalAs(UnmanagedType.LPArray)] piAttributes: array of Int32; [MarshalAs(UnmanagedType.LPArray)] piValues: array of Int32): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivARB';
public static z_GetPixelFormatAttribivARB_ovr0 := _z_GetPixelFormatAttribivARB_ovr0;
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 := z_GetPixelFormatAttribivARB_ovr0(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
private static function _z_GetPixelFormatAttribivARB_ovr1(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; [MarshalAs(UnmanagedType.LPArray)] piAttributes: array of Int32; var piValues: Int32): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivARB';
public static z_GetPixelFormatAttribivARB_ovr1 := _z_GetPixelFormatAttribivARB_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: array of Int32; var piValues: Int32): UInt32 := z_GetPixelFormatAttribivARB_ovr1(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
private static function _z_GetPixelFormatAttribivARB_ovr2(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; [MarshalAs(UnmanagedType.LPArray)] piAttributes: array of Int32; piValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivARB';
public static z_GetPixelFormatAttribivARB_ovr2 := _z_GetPixelFormatAttribivARB_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: array of Int32; piValues: IntPtr): UInt32 := z_GetPixelFormatAttribivARB_ovr2(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
private static function _z_GetPixelFormatAttribivARB_ovr3(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; [MarshalAs(UnmanagedType.LPArray)] piValues: array of Int32): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivARB';
public static z_GetPixelFormatAttribivARB_ovr3 := _z_GetPixelFormatAttribivARB_ovr3;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; piValues: array of Int32): UInt32 := z_GetPixelFormatAttribivARB_ovr3(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
private static function _z_GetPixelFormatAttribivARB_ovr4(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; var piValues: Int32): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivARB';
public static z_GetPixelFormatAttribivARB_ovr4 := _z_GetPixelFormatAttribivARB_ovr4;
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_ovr4(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
private static function _z_GetPixelFormatAttribivARB_ovr5(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; piValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivARB';
public static z_GetPixelFormatAttribivARB_ovr5 := _z_GetPixelFormatAttribivARB_ovr5;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; piValues: IntPtr): UInt32 := z_GetPixelFormatAttribivARB_ovr5(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
private static function _z_GetPixelFormatAttribivARB_ovr6(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; [MarshalAs(UnmanagedType.LPArray)] piValues: array of Int32): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivARB';
public static z_GetPixelFormatAttribivARB_ovr6 := _z_GetPixelFormatAttribivARB_ovr6;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; piValues: array of Int32): UInt32 := z_GetPixelFormatAttribivARB_ovr6(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
private static function _z_GetPixelFormatAttribivARB_ovr7(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; var piValues: Int32): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivARB';
public static z_GetPixelFormatAttribivARB_ovr7 := _z_GetPixelFormatAttribivARB_ovr7;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; var piValues: Int32): UInt32 := z_GetPixelFormatAttribivARB_ovr7(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
private static function _z_GetPixelFormatAttribivARB_ovr8(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; piValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivARB';
public static z_GetPixelFormatAttribivARB_ovr8 := _z_GetPixelFormatAttribivARB_ovr8;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; piValues: IntPtr): UInt32 := z_GetPixelFormatAttribivARB_ovr8(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
private static function _z_GetPixelFormatAttribfvARB_ovr0(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; [MarshalAs(UnmanagedType.LPArray)] piAttributes: array of Int32; [MarshalAs(UnmanagedType.LPArray)] pfValues: array of single): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvARB';
public static z_GetPixelFormatAttribfvARB_ovr0 := _z_GetPixelFormatAttribfvARB_ovr0;
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 := z_GetPixelFormatAttribfvARB_ovr0(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
private static function _z_GetPixelFormatAttribfvARB_ovr1(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; [MarshalAs(UnmanagedType.LPArray)] piAttributes: array of Int32; var pfValues: single): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvARB';
public static z_GetPixelFormatAttribfvARB_ovr1 := _z_GetPixelFormatAttribfvARB_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: array of Int32; var pfValues: single): UInt32 := z_GetPixelFormatAttribfvARB_ovr1(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
private static function _z_GetPixelFormatAttribfvARB_ovr2(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; [MarshalAs(UnmanagedType.LPArray)] piAttributes: array of Int32; pfValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvARB';
public static z_GetPixelFormatAttribfvARB_ovr2 := _z_GetPixelFormatAttribfvARB_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: array of Int32; pfValues: IntPtr): UInt32 := z_GetPixelFormatAttribfvARB_ovr2(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
private static function _z_GetPixelFormatAttribfvARB_ovr3(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; [MarshalAs(UnmanagedType.LPArray)] pfValues: array of single): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvARB';
public static z_GetPixelFormatAttribfvARB_ovr3 := _z_GetPixelFormatAttribfvARB_ovr3;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; pfValues: array of single): UInt32 := z_GetPixelFormatAttribfvARB_ovr3(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
private static function _z_GetPixelFormatAttribfvARB_ovr4(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; var pfValues: single): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvARB';
public static z_GetPixelFormatAttribfvARB_ovr4 := _z_GetPixelFormatAttribfvARB_ovr4;
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_ovr4(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
private static function _z_GetPixelFormatAttribfvARB_ovr5(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; pfValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvARB';
public static z_GetPixelFormatAttribfvARB_ovr5 := _z_GetPixelFormatAttribfvARB_ovr5;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; pfValues: IntPtr): UInt32 := z_GetPixelFormatAttribfvARB_ovr5(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
private static function _z_GetPixelFormatAttribfvARB_ovr6(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pfValues: array of single): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvARB';
public static z_GetPixelFormatAttribfvARB_ovr6 := _z_GetPixelFormatAttribfvARB_ovr6;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; pfValues: array of single): UInt32 := z_GetPixelFormatAttribfvARB_ovr6(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
private static function _z_GetPixelFormatAttribfvARB_ovr7(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; var pfValues: single): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvARB';
public static z_GetPixelFormatAttribfvARB_ovr7 := _z_GetPixelFormatAttribfvARB_ovr7;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; var pfValues: single): UInt32 := z_GetPixelFormatAttribfvARB_ovr7(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
private static function _z_GetPixelFormatAttribfvARB_ovr8(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; pfValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvARB';
public static z_GetPixelFormatAttribfvARB_ovr8 := _z_GetPixelFormatAttribfvARB_ovr8;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvARB(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; pfValues: IntPtr): UInt32 := z_GetPixelFormatAttribfvARB_ovr8(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
private static function _z_ChoosePixelFormatARB_ovr0(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr0 := _z_ChoosePixelFormatARB_ovr0;
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 := z_ChoosePixelFormatARB_ovr0(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr1(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr1 := _z_ChoosePixelFormatARB_ovr1;
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 := z_ChoosePixelFormatARB_ovr1(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr2(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr2 := _z_ChoosePixelFormatARB_ovr2;
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 := z_ChoosePixelFormatARB_ovr2(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr3(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr3 := _z_ChoosePixelFormatARB_ovr3;
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 := z_ChoosePixelFormatARB_ovr3(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr4(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr4 := _z_ChoosePixelFormatARB_ovr4;
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 := z_ChoosePixelFormatARB_ovr4(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr5(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr5 := _z_ChoosePixelFormatARB_ovr5;
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 := z_ChoosePixelFormatARB_ovr5(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr6(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr6 := _z_ChoosePixelFormatARB_ovr6;
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 := z_ChoosePixelFormatARB_ovr6(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr7(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr7 := _z_ChoosePixelFormatARB_ovr7;
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 := z_ChoosePixelFormatARB_ovr7(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr8(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr8 := _z_ChoosePixelFormatARB_ovr8;
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 := z_ChoosePixelFormatARB_ovr8(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr9(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr9 := _z_ChoosePixelFormatARB_ovr9;
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 := z_ChoosePixelFormatARB_ovr9(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr10(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr10 := _z_ChoosePixelFormatARB_ovr10;
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 := z_ChoosePixelFormatARB_ovr10(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr11(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr11 := _z_ChoosePixelFormatARB_ovr11;
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 := z_ChoosePixelFormatARB_ovr11(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr12(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr12 := _z_ChoosePixelFormatARB_ovr12;
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 := z_ChoosePixelFormatARB_ovr12(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr13(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr13 := _z_ChoosePixelFormatARB_ovr13;
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 := z_ChoosePixelFormatARB_ovr13(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr14(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr14 := _z_ChoosePixelFormatARB_ovr14;
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 := z_ChoosePixelFormatARB_ovr14(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr15(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr15 := _z_ChoosePixelFormatARB_ovr15;
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 := z_ChoosePixelFormatARB_ovr15(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr16(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr16 := _z_ChoosePixelFormatARB_ovr16;
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 := z_ChoosePixelFormatARB_ovr16(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr17(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr17 := _z_ChoosePixelFormatARB_ovr17;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 := z_ChoosePixelFormatARB_ovr17(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr18(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr18 := _z_ChoosePixelFormatARB_ovr18;
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 := z_ChoosePixelFormatARB_ovr18(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr19(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr19 := _z_ChoosePixelFormatARB_ovr19;
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 := z_ChoosePixelFormatARB_ovr19(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr20(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr20 := _z_ChoosePixelFormatARB_ovr20;
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 := z_ChoosePixelFormatARB_ovr20(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr21(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr21 := _z_ChoosePixelFormatARB_ovr21;
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 := z_ChoosePixelFormatARB_ovr21(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr22(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr22 := _z_ChoosePixelFormatARB_ovr22;
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 := z_ChoosePixelFormatARB_ovr22(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr23(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr23 := _z_ChoosePixelFormatARB_ovr23;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32 := z_ChoosePixelFormatARB_ovr23(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr24(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr24 := _z_ChoosePixelFormatARB_ovr24;
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 := z_ChoosePixelFormatARB_ovr24(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr25(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr25 := _z_ChoosePixelFormatARB_ovr25;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32 := z_ChoosePixelFormatARB_ovr25(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr26(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr26 := _z_ChoosePixelFormatARB_ovr26;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 := z_ChoosePixelFormatARB_ovr26(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr27(hdc: GDI_DC; var piAttribIList: Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr27 := _z_ChoosePixelFormatARB_ovr27;
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 := z_ChoosePixelFormatARB_ovr27(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr28(hdc: GDI_DC; var piAttribIList: Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr28 := _z_ChoosePixelFormatARB_ovr28;
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 := z_ChoosePixelFormatARB_ovr28(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr29(hdc: GDI_DC; var piAttribIList: Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr29 := _z_ChoosePixelFormatARB_ovr29;
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 := z_ChoosePixelFormatARB_ovr29(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr30(hdc: GDI_DC; var piAttribIList: Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr30 := _z_ChoosePixelFormatARB_ovr30;
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 := z_ChoosePixelFormatARB_ovr30(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr31(hdc: GDI_DC; var piAttribIList: Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr31 := _z_ChoosePixelFormatARB_ovr31;
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 := z_ChoosePixelFormatARB_ovr31(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr32(hdc: GDI_DC; var piAttribIList: Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr32 := _z_ChoosePixelFormatARB_ovr32;
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 := z_ChoosePixelFormatARB_ovr32(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr33(hdc: GDI_DC; var piAttribIList: Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr33 := _z_ChoosePixelFormatARB_ovr33;
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 := z_ChoosePixelFormatARB_ovr33(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr34(hdc: GDI_DC; var piAttribIList: Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr34 := _z_ChoosePixelFormatARB_ovr34;
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 := z_ChoosePixelFormatARB_ovr34(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr35(hdc: GDI_DC; var piAttribIList: Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr35 := _z_ChoosePixelFormatARB_ovr35;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 := z_ChoosePixelFormatARB_ovr35(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr36(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr36 := _z_ChoosePixelFormatARB_ovr36;
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 := z_ChoosePixelFormatARB_ovr36(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr37(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr37 := _z_ChoosePixelFormatARB_ovr37;
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 := z_ChoosePixelFormatARB_ovr37(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr38(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr38 := _z_ChoosePixelFormatARB_ovr38;
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 := z_ChoosePixelFormatARB_ovr38(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr39(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr39 := _z_ChoosePixelFormatARB_ovr39;
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 := z_ChoosePixelFormatARB_ovr39(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr40(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr40 := _z_ChoosePixelFormatARB_ovr40;
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_ovr40(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr41(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr41 := _z_ChoosePixelFormatARB_ovr41;
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_ovr41(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr42(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr42 := _z_ChoosePixelFormatARB_ovr42;
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 := z_ChoosePixelFormatARB_ovr42(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr43(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr43 := _z_ChoosePixelFormatARB_ovr43;
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_ovr43(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr44(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr44 := _z_ChoosePixelFormatARB_ovr44;
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_ovr44(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr45(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr45 := _z_ChoosePixelFormatARB_ovr45;
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 := z_ChoosePixelFormatARB_ovr45(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr46(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr46 := _z_ChoosePixelFormatARB_ovr46;
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 := z_ChoosePixelFormatARB_ovr46(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr47(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr47 := _z_ChoosePixelFormatARB_ovr47;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: IntPtr): UInt32 := z_ChoosePixelFormatARB_ovr47(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr48(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr48 := _z_ChoosePixelFormatARB_ovr48;
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 := z_ChoosePixelFormatARB_ovr48(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr49(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr49 := _z_ChoosePixelFormatARB_ovr49;
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_ovr49(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr50(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr50 := _z_ChoosePixelFormatARB_ovr50;
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_ovr50(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr51(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr51 := _z_ChoosePixelFormatARB_ovr51;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: array of UInt32): UInt32 := z_ChoosePixelFormatARB_ovr51(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr52(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr52 := _z_ChoosePixelFormatARB_ovr52;
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_ovr52(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr53(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr53 := _z_ChoosePixelFormatARB_ovr53;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 := z_ChoosePixelFormatARB_ovr53(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr54(hdc: GDI_DC; piAttribIList: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr54 := _z_ChoosePixelFormatARB_ovr54;
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 := z_ChoosePixelFormatARB_ovr54(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr55(hdc: GDI_DC; piAttribIList: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr55 := _z_ChoosePixelFormatARB_ovr55;
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 := z_ChoosePixelFormatARB_ovr55(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr56(hdc: GDI_DC; piAttribIList: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr56 := _z_ChoosePixelFormatARB_ovr56;
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 := z_ChoosePixelFormatARB_ovr56(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr57(hdc: GDI_DC; piAttribIList: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr57 := _z_ChoosePixelFormatARB_ovr57;
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 := z_ChoosePixelFormatARB_ovr57(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr58(hdc: GDI_DC; piAttribIList: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr58 := _z_ChoosePixelFormatARB_ovr58;
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 := z_ChoosePixelFormatARB_ovr58(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr59(hdc: GDI_DC; piAttribIList: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr59 := _z_ChoosePixelFormatARB_ovr59;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32 := z_ChoosePixelFormatARB_ovr59(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr60(hdc: GDI_DC; piAttribIList: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr60 := _z_ChoosePixelFormatARB_ovr60;
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 := z_ChoosePixelFormatARB_ovr60(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr61(hdc: GDI_DC; piAttribIList: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr61 := _z_ChoosePixelFormatARB_ovr61;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32 := z_ChoosePixelFormatARB_ovr61(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr62(hdc: GDI_DC; piAttribIList: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr62 := _z_ChoosePixelFormatARB_ovr62;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 := z_ChoosePixelFormatARB_ovr62(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr63(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr63 := _z_ChoosePixelFormatARB_ovr63;
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 := z_ChoosePixelFormatARB_ovr63(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr64(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr64 := _z_ChoosePixelFormatARB_ovr64;
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 := z_ChoosePixelFormatARB_ovr64(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr65(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr65 := _z_ChoosePixelFormatARB_ovr65;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: IntPtr): UInt32 := z_ChoosePixelFormatARB_ovr65(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr66(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr66 := _z_ChoosePixelFormatARB_ovr66;
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 := z_ChoosePixelFormatARB_ovr66(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr67(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr67 := _z_ChoosePixelFormatARB_ovr67;
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_ovr67(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr68(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr68 := _z_ChoosePixelFormatARB_ovr68;
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_ovr68(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr69(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr69 := _z_ChoosePixelFormatARB_ovr69;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: array of UInt32): UInt32 := z_ChoosePixelFormatARB_ovr69(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr70(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr70 := _z_ChoosePixelFormatARB_ovr70;
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_ovr70(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr71(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr71 := _z_ChoosePixelFormatARB_ovr71;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 := z_ChoosePixelFormatARB_ovr71(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr72(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr72 := _z_ChoosePixelFormatARB_ovr72;
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 := z_ChoosePixelFormatARB_ovr72(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr73(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr73 := _z_ChoosePixelFormatARB_ovr73;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: array of Int32; var nNumFormats: UInt32): UInt32 := z_ChoosePixelFormatARB_ovr73(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr74(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr74 := _z_ChoosePixelFormatARB_ovr74;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: IntPtr): UInt32 := z_ChoosePixelFormatARB_ovr74(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr75(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr75 := _z_ChoosePixelFormatARB_ovr75;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: array of UInt32): UInt32 := z_ChoosePixelFormatARB_ovr75(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr76(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr76 := _z_ChoosePixelFormatARB_ovr76;
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_ovr76(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr77(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr77 := _z_ChoosePixelFormatARB_ovr77;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32 := z_ChoosePixelFormatARB_ovr77(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr78(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr78 := _z_ChoosePixelFormatARB_ovr78;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: array of UInt32): UInt32 := z_ChoosePixelFormatARB_ovr78(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr79(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr79 := _z_ChoosePixelFormatARB_ovr79;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32 := z_ChoosePixelFormatARB_ovr79(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatARB_ovr80(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatARB';
public static z_ChoosePixelFormatARB_ovr80 := _z_ChoosePixelFormatARB_ovr80;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatARB(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 := z_ChoosePixelFormatARB_ovr80(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
end;
wglRenderTextureARB = static class
private static function _z_BindTexImageARB_ovr0(_hPbuffer: HPBUFFER; iBuffer: Int32): UInt32;
external 'opengl32.dll' name 'wglBindTexImageARB';
public static z_BindTexImageARB_ovr0 := _z_BindTexImageARB_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function BindTexImageARB(_hPbuffer: HPBUFFER; iBuffer: Int32): UInt32 := z_BindTexImageARB_ovr0(_hPbuffer, iBuffer);
private static function _z_ReleaseTexImageARB_ovr0(_hPbuffer: HPBUFFER; iBuffer: Int32): UInt32;
external 'opengl32.dll' name 'wglReleaseTexImageARB';
public static z_ReleaseTexImageARB_ovr0 := _z_ReleaseTexImageARB_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleaseTexImageARB(_hPbuffer: HPBUFFER; iBuffer: Int32): UInt32 := z_ReleaseTexImageARB_ovr0(_hPbuffer, iBuffer);
private static function _z_SetPbufferAttribARB_ovr0(_hPbuffer: HPBUFFER; [MarshalAs(UnmanagedType.LPArray)] piAttribList: array of Int32): UInt32;
external 'opengl32.dll' name 'wglSetPbufferAttribARB';
public static z_SetPbufferAttribARB_ovr0 := _z_SetPbufferAttribARB_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetPbufferAttribARB(_hPbuffer: HPBUFFER; piAttribList: array of Int32): UInt32 := z_SetPbufferAttribARB_ovr0(_hPbuffer, piAttribList);
private static function _z_SetPbufferAttribARB_ovr1(_hPbuffer: HPBUFFER; var piAttribList: Int32): UInt32;
external 'opengl32.dll' name 'wglSetPbufferAttribARB';
public static z_SetPbufferAttribARB_ovr1 := _z_SetPbufferAttribARB_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetPbufferAttribARB(_hPbuffer: HPBUFFER; var piAttribList: Int32): UInt32 := z_SetPbufferAttribARB_ovr1(_hPbuffer, piAttribList);
private static function _z_SetPbufferAttribARB_ovr2(_hPbuffer: HPBUFFER; piAttribList: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetPbufferAttribARB';
public static z_SetPbufferAttribARB_ovr2 := _z_SetPbufferAttribARB_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetPbufferAttribARB(_hPbuffer: HPBUFFER; piAttribList: IntPtr): UInt32 := z_SetPbufferAttribARB_ovr2(_hPbuffer, piAttribList);
end;
wglDisplayColorTableEXT = static class
private static function _z_CreateDisplayColorTableEXT_ovr0(id: UInt16): boolean;
external 'opengl32.dll' name 'wglCreateDisplayColorTableEXT';
public static z_CreateDisplayColorTableEXT_ovr0 := _z_CreateDisplayColorTableEXT_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateDisplayColorTableEXT(id: UInt16): boolean := z_CreateDisplayColorTableEXT_ovr0(id);
private static function _z_LoadDisplayColorTableEXT_ovr0([MarshalAs(UnmanagedType.LPArray)] table: array of UInt16; length: UInt32): boolean;
external 'opengl32.dll' name 'wglLoadDisplayColorTableEXT';
public static z_LoadDisplayColorTableEXT_ovr0 := _z_LoadDisplayColorTableEXT_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function LoadDisplayColorTableEXT(table: array of UInt16; length: UInt32): boolean := z_LoadDisplayColorTableEXT_ovr0(table, length);
private static function _z_LoadDisplayColorTableEXT_ovr1(var table: UInt16; length: UInt32): boolean;
external 'opengl32.dll' name 'wglLoadDisplayColorTableEXT';
public static z_LoadDisplayColorTableEXT_ovr1 := _z_LoadDisplayColorTableEXT_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function LoadDisplayColorTableEXT(var table: UInt16; length: UInt32): boolean := z_LoadDisplayColorTableEXT_ovr1(table, length);
private static function _z_LoadDisplayColorTableEXT_ovr2(table: IntPtr; length: UInt32): boolean;
external 'opengl32.dll' name 'wglLoadDisplayColorTableEXT';
public static z_LoadDisplayColorTableEXT_ovr2 := _z_LoadDisplayColorTableEXT_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function LoadDisplayColorTableEXT(table: IntPtr; length: UInt32): boolean := z_LoadDisplayColorTableEXT_ovr2(table, length);
private static function _z_BindDisplayColorTableEXT_ovr0(id: UInt16): boolean;
external 'opengl32.dll' name 'wglBindDisplayColorTableEXT';
public static z_BindDisplayColorTableEXT_ovr0 := _z_BindDisplayColorTableEXT_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function BindDisplayColorTableEXT(id: UInt16): boolean := z_BindDisplayColorTableEXT_ovr0(id);
private static procedure _z_DestroyDisplayColorTableEXT_ovr0(id: UInt16);
external 'opengl32.dll' name 'wglDestroyDisplayColorTableEXT';
public static z_DestroyDisplayColorTableEXT_ovr0 := _z_DestroyDisplayColorTableEXT_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static procedure DestroyDisplayColorTableEXT(id: UInt16) := z_DestroyDisplayColorTableEXT_ovr0(id);
end;
wglExtensionsStringEXT = static class
private [Result: MarshalAs(UnmanagedType.LPStr)] static function _z_GetExtensionsStringEXT_ovr0: string;
external 'opengl32.dll' name 'wglGetExtensionsStringEXT';
public static z_GetExtensionsStringEXT_ovr0: function: string := _z_GetExtensionsStringEXT_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetExtensionsStringEXT: string := z_GetExtensionsStringEXT_ovr0;
end;
wglMakeCurrentReadEXT = static class
private static function _z_MakeContextCurrentEXT_ovr0(hDrawDC: GDI_DC; hReadDC: GDI_DC; hglrc: GLContext): UInt32;
external 'opengl32.dll' name 'wglMakeContextCurrentEXT';
public static z_MakeContextCurrentEXT_ovr0 := _z_MakeContextCurrentEXT_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function MakeContextCurrentEXT(hDrawDC: GDI_DC; hReadDC: GDI_DC; hglrc: GLContext): UInt32 := z_MakeContextCurrentEXT_ovr0(hDrawDC, hReadDC, hglrc);
private static function _z_GetCurrentReadDCEXT_ovr0: GDI_DC;
external 'opengl32.dll' name 'wglGetCurrentReadDCEXT';
public static z_GetCurrentReadDCEXT_ovr0: function: GDI_DC := _z_GetCurrentReadDCEXT_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetCurrentReadDCEXT: GDI_DC := z_GetCurrentReadDCEXT_ovr0;
end;
wglPbufferEXT = static class
private static function _z_CreatePbufferEXT_ovr0(hDC: GDI_DC; iPixelFormat: Int32; iWidth: Int32; iHeight: Int32; [MarshalAs(UnmanagedType.LPArray)] piAttribList: array of Int32): HPBUFFER;
external 'opengl32.dll' name 'wglCreatePbufferEXT';
public static z_CreatePbufferEXT_ovr0 := _z_CreatePbufferEXT_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreatePbufferEXT(hDC: GDI_DC; iPixelFormat: Int32; iWidth: Int32; iHeight: Int32; piAttribList: array of Int32): HPBUFFER := z_CreatePbufferEXT_ovr0(hDC, iPixelFormat, iWidth, iHeight, piAttribList);
private static function _z_CreatePbufferEXT_ovr1(hDC: GDI_DC; iPixelFormat: Int32; iWidth: Int32; iHeight: Int32; var piAttribList: Int32): HPBUFFER;
external 'opengl32.dll' name 'wglCreatePbufferEXT';
public static z_CreatePbufferEXT_ovr1 := _z_CreatePbufferEXT_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreatePbufferEXT(hDC: GDI_DC; iPixelFormat: Int32; iWidth: Int32; iHeight: Int32; var piAttribList: Int32): HPBUFFER := z_CreatePbufferEXT_ovr1(hDC, iPixelFormat, iWidth, iHeight, piAttribList);
private static function _z_CreatePbufferEXT_ovr2(hDC: GDI_DC; iPixelFormat: Int32; iWidth: Int32; iHeight: Int32; piAttribList: IntPtr): HPBUFFER;
external 'opengl32.dll' name 'wglCreatePbufferEXT';
public static z_CreatePbufferEXT_ovr2 := _z_CreatePbufferEXT_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreatePbufferEXT(hDC: GDI_DC; iPixelFormat: Int32; iWidth: Int32; iHeight: Int32; piAttribList: IntPtr): HPBUFFER := z_CreatePbufferEXT_ovr2(hDC, iPixelFormat, iWidth, iHeight, piAttribList);
private static function _z_GetPbufferDCEXT_ovr0(_hPbuffer: HPBUFFER): GDI_DC;
external 'opengl32.dll' name 'wglGetPbufferDCEXT';
public static z_GetPbufferDCEXT_ovr0 := _z_GetPbufferDCEXT_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPbufferDCEXT(_hPbuffer: HPBUFFER): GDI_DC := z_GetPbufferDCEXT_ovr0(_hPbuffer);
private static function _z_ReleasePbufferDCEXT_ovr0(_hPbuffer: HPBUFFER; hDC: GDI_DC): Int32;
external 'opengl32.dll' name 'wglReleasePbufferDCEXT';
public static z_ReleasePbufferDCEXT_ovr0 := _z_ReleasePbufferDCEXT_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleasePbufferDCEXT(_hPbuffer: HPBUFFER; hDC: GDI_DC): Int32 := z_ReleasePbufferDCEXT_ovr0(_hPbuffer, hDC);
private static function _z_DestroyPbufferEXT_ovr0(_hPbuffer: HPBUFFER): UInt32;
external 'opengl32.dll' name 'wglDestroyPbufferEXT';
public static z_DestroyPbufferEXT_ovr0 := _z_DestroyPbufferEXT_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DestroyPbufferEXT(_hPbuffer: HPBUFFER): UInt32 := z_DestroyPbufferEXT_ovr0(_hPbuffer);
private static function _z_QueryPbufferEXT_ovr0(_hPbuffer: HPBUFFER; iAttribute: Int32; [MarshalAs(UnmanagedType.LPArray)] piValue: array of Int32): UInt32;
external 'opengl32.dll' name 'wglQueryPbufferEXT';
public static z_QueryPbufferEXT_ovr0 := _z_QueryPbufferEXT_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryPbufferEXT(_hPbuffer: HPBUFFER; iAttribute: Int32; piValue: array of Int32): UInt32 := z_QueryPbufferEXT_ovr0(_hPbuffer, iAttribute, piValue);
private static function _z_QueryPbufferEXT_ovr1(_hPbuffer: HPBUFFER; iAttribute: Int32; var piValue: Int32): UInt32;
external 'opengl32.dll' name 'wglQueryPbufferEXT';
public static z_QueryPbufferEXT_ovr1 := _z_QueryPbufferEXT_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryPbufferEXT(_hPbuffer: HPBUFFER; iAttribute: Int32; var piValue: Int32): UInt32 := z_QueryPbufferEXT_ovr1(_hPbuffer, iAttribute, piValue);
private static function _z_QueryPbufferEXT_ovr2(_hPbuffer: HPBUFFER; iAttribute: Int32; piValue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryPbufferEXT';
public static z_QueryPbufferEXT_ovr2 := _z_QueryPbufferEXT_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryPbufferEXT(_hPbuffer: HPBUFFER; iAttribute: Int32; piValue: IntPtr): UInt32 := z_QueryPbufferEXT_ovr2(_hPbuffer, iAttribute, piValue);
end;
wglPixelFormatEXT = static class
private static function _z_GetPixelFormatAttribivEXT_ovr0(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; [MarshalAs(UnmanagedType.LPArray)] piAttributes: array of Int32; [MarshalAs(UnmanagedType.LPArray)] piValues: array of Int32): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivEXT';
public static z_GetPixelFormatAttribivEXT_ovr0 := _z_GetPixelFormatAttribivEXT_ovr0;
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 := z_GetPixelFormatAttribivEXT_ovr0(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
private static function _z_GetPixelFormatAttribivEXT_ovr1(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; [MarshalAs(UnmanagedType.LPArray)] piAttributes: array of Int32; var piValues: Int32): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivEXT';
public static z_GetPixelFormatAttribivEXT_ovr1 := _z_GetPixelFormatAttribivEXT_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: array of Int32; var piValues: Int32): UInt32 := z_GetPixelFormatAttribivEXT_ovr1(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
private static function _z_GetPixelFormatAttribivEXT_ovr2(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; [MarshalAs(UnmanagedType.LPArray)] piAttributes: array of Int32; piValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivEXT';
public static z_GetPixelFormatAttribivEXT_ovr2 := _z_GetPixelFormatAttribivEXT_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: array of Int32; piValues: IntPtr): UInt32 := z_GetPixelFormatAttribivEXT_ovr2(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
private static function _z_GetPixelFormatAttribivEXT_ovr3(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; [MarshalAs(UnmanagedType.LPArray)] piValues: array of Int32): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivEXT';
public static z_GetPixelFormatAttribivEXT_ovr3 := _z_GetPixelFormatAttribivEXT_ovr3;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; piValues: array of Int32): UInt32 := z_GetPixelFormatAttribivEXT_ovr3(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
private static function _z_GetPixelFormatAttribivEXT_ovr4(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; var piValues: Int32): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivEXT';
public static z_GetPixelFormatAttribivEXT_ovr4 := _z_GetPixelFormatAttribivEXT_ovr4;
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_ovr4(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
private static function _z_GetPixelFormatAttribivEXT_ovr5(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; piValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivEXT';
public static z_GetPixelFormatAttribivEXT_ovr5 := _z_GetPixelFormatAttribivEXT_ovr5;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; piValues: IntPtr): UInt32 := z_GetPixelFormatAttribivEXT_ovr5(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
private static function _z_GetPixelFormatAttribivEXT_ovr6(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; [MarshalAs(UnmanagedType.LPArray)] piValues: array of Int32): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivEXT';
public static z_GetPixelFormatAttribivEXT_ovr6 := _z_GetPixelFormatAttribivEXT_ovr6;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; piValues: array of Int32): UInt32 := z_GetPixelFormatAttribivEXT_ovr6(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
private static function _z_GetPixelFormatAttribivEXT_ovr7(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; var piValues: Int32): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivEXT';
public static z_GetPixelFormatAttribivEXT_ovr7 := _z_GetPixelFormatAttribivEXT_ovr7;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; var piValues: Int32): UInt32 := z_GetPixelFormatAttribivEXT_ovr7(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
private static function _z_GetPixelFormatAttribivEXT_ovr8(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; piValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribivEXT';
public static z_GetPixelFormatAttribivEXT_ovr8 := _z_GetPixelFormatAttribivEXT_ovr8;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribivEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; piValues: IntPtr): UInt32 := z_GetPixelFormatAttribivEXT_ovr8(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
private static function _z_GetPixelFormatAttribfvEXT_ovr0(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; [MarshalAs(UnmanagedType.LPArray)] piAttributes: array of Int32; [MarshalAs(UnmanagedType.LPArray)] pfValues: array of single): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvEXT';
public static z_GetPixelFormatAttribfvEXT_ovr0 := _z_GetPixelFormatAttribfvEXT_ovr0;
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 := z_GetPixelFormatAttribfvEXT_ovr0(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
private static function _z_GetPixelFormatAttribfvEXT_ovr1(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; [MarshalAs(UnmanagedType.LPArray)] piAttributes: array of Int32; var pfValues: single): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvEXT';
public static z_GetPixelFormatAttribfvEXT_ovr1 := _z_GetPixelFormatAttribfvEXT_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: array of Int32; var pfValues: single): UInt32 := z_GetPixelFormatAttribfvEXT_ovr1(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
private static function _z_GetPixelFormatAttribfvEXT_ovr2(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; [MarshalAs(UnmanagedType.LPArray)] piAttributes: array of Int32; pfValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvEXT';
public static z_GetPixelFormatAttribfvEXT_ovr2 := _z_GetPixelFormatAttribfvEXT_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: array of Int32; pfValues: IntPtr): UInt32 := z_GetPixelFormatAttribfvEXT_ovr2(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
private static function _z_GetPixelFormatAttribfvEXT_ovr3(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; [MarshalAs(UnmanagedType.LPArray)] pfValues: array of single): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvEXT';
public static z_GetPixelFormatAttribfvEXT_ovr3 := _z_GetPixelFormatAttribfvEXT_ovr3;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; pfValues: array of single): UInt32 := z_GetPixelFormatAttribfvEXT_ovr3(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
private static function _z_GetPixelFormatAttribfvEXT_ovr4(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; var pfValues: single): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvEXT';
public static z_GetPixelFormatAttribfvEXT_ovr4 := _z_GetPixelFormatAttribfvEXT_ovr4;
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_ovr4(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
private static function _z_GetPixelFormatAttribfvEXT_ovr5(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; pfValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvEXT';
public static z_GetPixelFormatAttribfvEXT_ovr5 := _z_GetPixelFormatAttribfvEXT_ovr5;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; var piAttributes: Int32; pfValues: IntPtr): UInt32 := z_GetPixelFormatAttribfvEXT_ovr5(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
private static function _z_GetPixelFormatAttribfvEXT_ovr6(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pfValues: array of single): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvEXT';
public static z_GetPixelFormatAttribfvEXT_ovr6 := _z_GetPixelFormatAttribfvEXT_ovr6;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; pfValues: array of single): UInt32 := z_GetPixelFormatAttribfvEXT_ovr6(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
private static function _z_GetPixelFormatAttribfvEXT_ovr7(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; var pfValues: single): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvEXT';
public static z_GetPixelFormatAttribfvEXT_ovr7 := _z_GetPixelFormatAttribfvEXT_ovr7;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; var pfValues: single): UInt32 := z_GetPixelFormatAttribfvEXT_ovr7(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
private static function _z_GetPixelFormatAttribfvEXT_ovr8(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; pfValues: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetPixelFormatAttribfvEXT';
public static z_GetPixelFormatAttribfvEXT_ovr8 := _z_GetPixelFormatAttribfvEXT_ovr8;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetPixelFormatAttribfvEXT(hdc: GDI_DC; iPixelFormat: Int32; iLayerPlane: Int32; nAttributes: UInt32; piAttributes: IntPtr; pfValues: IntPtr): UInt32 := z_GetPixelFormatAttribfvEXT_ovr8(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
private static function _z_ChoosePixelFormatEXT_ovr0(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr0 := _z_ChoosePixelFormatEXT_ovr0;
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 := z_ChoosePixelFormatEXT_ovr0(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr1(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr1 := _z_ChoosePixelFormatEXT_ovr1;
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 := z_ChoosePixelFormatEXT_ovr1(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr2(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr2 := _z_ChoosePixelFormatEXT_ovr2;
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 := z_ChoosePixelFormatEXT_ovr2(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr3(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr3 := _z_ChoosePixelFormatEXT_ovr3;
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 := z_ChoosePixelFormatEXT_ovr3(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr4(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr4 := _z_ChoosePixelFormatEXT_ovr4;
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 := z_ChoosePixelFormatEXT_ovr4(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr5(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr5 := _z_ChoosePixelFormatEXT_ovr5;
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 := z_ChoosePixelFormatEXT_ovr5(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr6(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr6 := _z_ChoosePixelFormatEXT_ovr6;
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 := z_ChoosePixelFormatEXT_ovr6(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr7(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr7 := _z_ChoosePixelFormatEXT_ovr7;
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 := z_ChoosePixelFormatEXT_ovr7(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr8(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr8 := _z_ChoosePixelFormatEXT_ovr8;
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 := z_ChoosePixelFormatEXT_ovr8(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr9(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr9 := _z_ChoosePixelFormatEXT_ovr9;
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 := z_ChoosePixelFormatEXT_ovr9(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr10(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr10 := _z_ChoosePixelFormatEXT_ovr10;
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 := z_ChoosePixelFormatEXT_ovr10(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr11(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr11 := _z_ChoosePixelFormatEXT_ovr11;
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 := z_ChoosePixelFormatEXT_ovr11(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr12(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr12 := _z_ChoosePixelFormatEXT_ovr12;
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 := z_ChoosePixelFormatEXT_ovr12(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr13(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr13 := _z_ChoosePixelFormatEXT_ovr13;
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 := z_ChoosePixelFormatEXT_ovr13(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr14(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr14 := _z_ChoosePixelFormatEXT_ovr14;
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 := z_ChoosePixelFormatEXT_ovr14(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr15(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr15 := _z_ChoosePixelFormatEXT_ovr15;
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 := z_ChoosePixelFormatEXT_ovr15(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr16(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr16 := _z_ChoosePixelFormatEXT_ovr16;
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 := z_ChoosePixelFormatEXT_ovr16(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr17(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr17 := _z_ChoosePixelFormatEXT_ovr17;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 := z_ChoosePixelFormatEXT_ovr17(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr18(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr18 := _z_ChoosePixelFormatEXT_ovr18;
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 := z_ChoosePixelFormatEXT_ovr18(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr19(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr19 := _z_ChoosePixelFormatEXT_ovr19;
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 := z_ChoosePixelFormatEXT_ovr19(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr20(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr20 := _z_ChoosePixelFormatEXT_ovr20;
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 := z_ChoosePixelFormatEXT_ovr20(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr21(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr21 := _z_ChoosePixelFormatEXT_ovr21;
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 := z_ChoosePixelFormatEXT_ovr21(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr22(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr22 := _z_ChoosePixelFormatEXT_ovr22;
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 := z_ChoosePixelFormatEXT_ovr22(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr23(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr23 := _z_ChoosePixelFormatEXT_ovr23;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32 := z_ChoosePixelFormatEXT_ovr23(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr24(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr24 := _z_ChoosePixelFormatEXT_ovr24;
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 := z_ChoosePixelFormatEXT_ovr24(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr25(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr25 := _z_ChoosePixelFormatEXT_ovr25;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32 := z_ChoosePixelFormatEXT_ovr25(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr26(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr26 := _z_ChoosePixelFormatEXT_ovr26;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: array of Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 := z_ChoosePixelFormatEXT_ovr26(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr27(hdc: GDI_DC; var piAttribIList: Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr27 := _z_ChoosePixelFormatEXT_ovr27;
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 := z_ChoosePixelFormatEXT_ovr27(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr28(hdc: GDI_DC; var piAttribIList: Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr28 := _z_ChoosePixelFormatEXT_ovr28;
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 := z_ChoosePixelFormatEXT_ovr28(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr29(hdc: GDI_DC; var piAttribIList: Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr29 := _z_ChoosePixelFormatEXT_ovr29;
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 := z_ChoosePixelFormatEXT_ovr29(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr30(hdc: GDI_DC; var piAttribIList: Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr30 := _z_ChoosePixelFormatEXT_ovr30;
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 := z_ChoosePixelFormatEXT_ovr30(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr31(hdc: GDI_DC; var piAttribIList: Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr31 := _z_ChoosePixelFormatEXT_ovr31;
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 := z_ChoosePixelFormatEXT_ovr31(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr32(hdc: GDI_DC; var piAttribIList: Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr32 := _z_ChoosePixelFormatEXT_ovr32;
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 := z_ChoosePixelFormatEXT_ovr32(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr33(hdc: GDI_DC; var piAttribIList: Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr33 := _z_ChoosePixelFormatEXT_ovr33;
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 := z_ChoosePixelFormatEXT_ovr33(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr34(hdc: GDI_DC; var piAttribIList: Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr34 := _z_ChoosePixelFormatEXT_ovr34;
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 := z_ChoosePixelFormatEXT_ovr34(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr35(hdc: GDI_DC; var piAttribIList: Int32; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr35 := _z_ChoosePixelFormatEXT_ovr35;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 := z_ChoosePixelFormatEXT_ovr35(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr36(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr36 := _z_ChoosePixelFormatEXT_ovr36;
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 := z_ChoosePixelFormatEXT_ovr36(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr37(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr37 := _z_ChoosePixelFormatEXT_ovr37;
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 := z_ChoosePixelFormatEXT_ovr37(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr38(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr38 := _z_ChoosePixelFormatEXT_ovr38;
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 := z_ChoosePixelFormatEXT_ovr38(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr39(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr39 := _z_ChoosePixelFormatEXT_ovr39;
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 := z_ChoosePixelFormatEXT_ovr39(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr40(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr40 := _z_ChoosePixelFormatEXT_ovr40;
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_ovr40(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr41(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr41 := _z_ChoosePixelFormatEXT_ovr41;
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_ovr41(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr42(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr42 := _z_ChoosePixelFormatEXT_ovr42;
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 := z_ChoosePixelFormatEXT_ovr42(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr43(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr43 := _z_ChoosePixelFormatEXT_ovr43;
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_ovr43(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr44(hdc: GDI_DC; var piAttribIList: Int32; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr44 := _z_ChoosePixelFormatEXT_ovr44;
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_ovr44(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr45(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr45 := _z_ChoosePixelFormatEXT_ovr45;
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 := z_ChoosePixelFormatEXT_ovr45(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr46(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr46 := _z_ChoosePixelFormatEXT_ovr46;
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 := z_ChoosePixelFormatEXT_ovr46(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr47(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr47 := _z_ChoosePixelFormatEXT_ovr47;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: IntPtr): UInt32 := z_ChoosePixelFormatEXT_ovr47(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr48(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr48 := _z_ChoosePixelFormatEXT_ovr48;
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 := z_ChoosePixelFormatEXT_ovr48(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr49(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr49 := _z_ChoosePixelFormatEXT_ovr49;
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_ovr49(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr50(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr50 := _z_ChoosePixelFormatEXT_ovr50;
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_ovr50(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr51(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr51 := _z_ChoosePixelFormatEXT_ovr51;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: array of UInt32): UInt32 := z_ChoosePixelFormatEXT_ovr51(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr52(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr52 := _z_ChoosePixelFormatEXT_ovr52;
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_ovr52(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr53(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr53 := _z_ChoosePixelFormatEXT_ovr53;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; var piAttribIList: Int32; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 := z_ChoosePixelFormatEXT_ovr53(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr54(hdc: GDI_DC; piAttribIList: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr54 := _z_ChoosePixelFormatEXT_ovr54;
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 := z_ChoosePixelFormatEXT_ovr54(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr55(hdc: GDI_DC; piAttribIList: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr55 := _z_ChoosePixelFormatEXT_ovr55;
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 := z_ChoosePixelFormatEXT_ovr55(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr56(hdc: GDI_DC; piAttribIList: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr56 := _z_ChoosePixelFormatEXT_ovr56;
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 := z_ChoosePixelFormatEXT_ovr56(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr57(hdc: GDI_DC; piAttribIList: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr57 := _z_ChoosePixelFormatEXT_ovr57;
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 := z_ChoosePixelFormatEXT_ovr57(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr58(hdc: GDI_DC; piAttribIList: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr58 := _z_ChoosePixelFormatEXT_ovr58;
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 := z_ChoosePixelFormatEXT_ovr58(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr59(hdc: GDI_DC; piAttribIList: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr59 := _z_ChoosePixelFormatEXT_ovr59;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: array of single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32 := z_ChoosePixelFormatEXT_ovr59(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr60(hdc: GDI_DC; piAttribIList: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr60 := _z_ChoosePixelFormatEXT_ovr60;
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 := z_ChoosePixelFormatEXT_ovr60(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr61(hdc: GDI_DC; piAttribIList: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr61 := _z_ChoosePixelFormatEXT_ovr61;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32 := z_ChoosePixelFormatEXT_ovr61(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr62(hdc: GDI_DC; piAttribIList: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr62 := _z_ChoosePixelFormatEXT_ovr62;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: array of single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 := z_ChoosePixelFormatEXT_ovr62(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr63(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr63 := _z_ChoosePixelFormatEXT_ovr63;
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 := z_ChoosePixelFormatEXT_ovr63(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr64(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr64 := _z_ChoosePixelFormatEXT_ovr64;
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 := z_ChoosePixelFormatEXT_ovr64(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr65(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr65 := _z_ChoosePixelFormatEXT_ovr65;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: IntPtr): UInt32 := z_ChoosePixelFormatEXT_ovr65(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr66(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr66 := _z_ChoosePixelFormatEXT_ovr66;
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 := z_ChoosePixelFormatEXT_ovr66(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr67(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr67 := _z_ChoosePixelFormatEXT_ovr67;
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_ovr67(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr68(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr68 := _z_ChoosePixelFormatEXT_ovr68;
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_ovr68(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr69(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr69 := _z_ChoosePixelFormatEXT_ovr69;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: array of UInt32): UInt32 := z_ChoosePixelFormatEXT_ovr69(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr70(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr70 := _z_ChoosePixelFormatEXT_ovr70;
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_ovr70(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr71(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr71 := _z_ChoosePixelFormatEXT_ovr71;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; var pfAttribFList: single; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 := z_ChoosePixelFormatEXT_ovr71(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr72(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr72 := _z_ChoosePixelFormatEXT_ovr72;
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 := z_ChoosePixelFormatEXT_ovr72(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr73(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr73 := _z_ChoosePixelFormatEXT_ovr73;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: array of Int32; var nNumFormats: UInt32): UInt32 := z_ChoosePixelFormatEXT_ovr73(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr74(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; [MarshalAs(UnmanagedType.LPArray)] piFormats: array of Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr74 := _z_ChoosePixelFormatEXT_ovr74;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: array of Int32; nNumFormats: IntPtr): UInt32 := z_ChoosePixelFormatEXT_ovr74(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr75(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr75 := _z_ChoosePixelFormatEXT_ovr75;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: array of UInt32): UInt32 := z_ChoosePixelFormatEXT_ovr75(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr76(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr76 := _z_ChoosePixelFormatEXT_ovr76;
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_ovr76(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr77(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr77 := _z_ChoosePixelFormatEXT_ovr77;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; var piFormats: Int32; nNumFormats: IntPtr): UInt32 := z_ChoosePixelFormatEXT_ovr77(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr78(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; [MarshalAs(UnmanagedType.LPArray)] nNumFormats: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr78 := _z_ChoosePixelFormatEXT_ovr78;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: array of UInt32): UInt32 := z_ChoosePixelFormatEXT_ovr78(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr79(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr79 := _z_ChoosePixelFormatEXT_ovr79;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; var nNumFormats: UInt32): UInt32 := z_ChoosePixelFormatEXT_ovr79(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
private static function _z_ChoosePixelFormatEXT_ovr80(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32;
external 'opengl32.dll' name 'wglChoosePixelFormatEXT';
public static z_ChoosePixelFormatEXT_ovr80 := _z_ChoosePixelFormatEXT_ovr80;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ChoosePixelFormatEXT(hdc: GDI_DC; piAttribIList: IntPtr; pfAttribFList: IntPtr; nMaxFormats: UInt32; piFormats: IntPtr; nNumFormats: IntPtr): UInt32 := z_ChoosePixelFormatEXT_ovr80(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
end;
wglSwapControlEXT = static class
private static function _z_SwapIntervalEXT_ovr0(interval: Int32): UInt32;
external 'opengl32.dll' name 'wglSwapIntervalEXT';
public static z_SwapIntervalEXT_ovr0 := _z_SwapIntervalEXT_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SwapIntervalEXT(interval: Int32): UInt32 := z_SwapIntervalEXT_ovr0(interval);
private static function _z_GetSwapIntervalEXT_ovr0: Int32;
external 'opengl32.dll' name 'wglGetSwapIntervalEXT';
public static z_GetSwapIntervalEXT_ovr0: function: Int32 := _z_GetSwapIntervalEXT_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSwapIntervalEXT: Int32 := z_GetSwapIntervalEXT_ovr0;
end;
wglDigitalVideoControlI3D = static class
private static function _z_GetDigitalVideoParametersI3D_ovr0(hDC: GDI_DC; iAttribute: Int32; [MarshalAs(UnmanagedType.LPArray)] piValue: array of Int32): UInt32;
external 'opengl32.dll' name 'wglGetDigitalVideoParametersI3D';
public static z_GetDigitalVideoParametersI3D_ovr0 := _z_GetDigitalVideoParametersI3D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDigitalVideoParametersI3D(hDC: GDI_DC; iAttribute: Int32; piValue: array of Int32): UInt32 := z_GetDigitalVideoParametersI3D_ovr0(hDC, iAttribute, piValue);
private static function _z_GetDigitalVideoParametersI3D_ovr1(hDC: GDI_DC; iAttribute: Int32; var piValue: Int32): UInt32;
external 'opengl32.dll' name 'wglGetDigitalVideoParametersI3D';
public static z_GetDigitalVideoParametersI3D_ovr1 := _z_GetDigitalVideoParametersI3D_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDigitalVideoParametersI3D(hDC: GDI_DC; iAttribute: Int32; var piValue: Int32): UInt32 := z_GetDigitalVideoParametersI3D_ovr1(hDC, iAttribute, piValue);
private static function _z_GetDigitalVideoParametersI3D_ovr2(hDC: GDI_DC; iAttribute: Int32; piValue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetDigitalVideoParametersI3D';
public static z_GetDigitalVideoParametersI3D_ovr2 := _z_GetDigitalVideoParametersI3D_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetDigitalVideoParametersI3D(hDC: GDI_DC; iAttribute: Int32; piValue: IntPtr): UInt32 := z_GetDigitalVideoParametersI3D_ovr2(hDC, iAttribute, piValue);
private static function _z_SetDigitalVideoParametersI3D_ovr0(hDC: GDI_DC; iAttribute: Int32; [MarshalAs(UnmanagedType.LPArray)] piValue: array of Int32): UInt32;
external 'opengl32.dll' name 'wglSetDigitalVideoParametersI3D';
public static z_SetDigitalVideoParametersI3D_ovr0 := _z_SetDigitalVideoParametersI3D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetDigitalVideoParametersI3D(hDC: GDI_DC; iAttribute: Int32; piValue: array of Int32): UInt32 := z_SetDigitalVideoParametersI3D_ovr0(hDC, iAttribute, piValue);
private static function _z_SetDigitalVideoParametersI3D_ovr1(hDC: GDI_DC; iAttribute: Int32; var piValue: Int32): UInt32;
external 'opengl32.dll' name 'wglSetDigitalVideoParametersI3D';
public static z_SetDigitalVideoParametersI3D_ovr1 := _z_SetDigitalVideoParametersI3D_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetDigitalVideoParametersI3D(hDC: GDI_DC; iAttribute: Int32; var piValue: Int32): UInt32 := z_SetDigitalVideoParametersI3D_ovr1(hDC, iAttribute, piValue);
private static function _z_SetDigitalVideoParametersI3D_ovr2(hDC: GDI_DC; iAttribute: Int32; piValue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetDigitalVideoParametersI3D';
public static z_SetDigitalVideoParametersI3D_ovr2 := _z_SetDigitalVideoParametersI3D_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetDigitalVideoParametersI3D(hDC: GDI_DC; iAttribute: Int32; piValue: IntPtr): UInt32 := z_SetDigitalVideoParametersI3D_ovr2(hDC, iAttribute, piValue);
end;
wglGammaI3D = static class
private static function _z_GetGammaTableParametersI3D_ovr0(hDC: GDI_DC; iAttribute: Int32; [MarshalAs(UnmanagedType.LPArray)] piValue: array of Int32): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableParametersI3D';
public static z_GetGammaTableParametersI3D_ovr0 := _z_GetGammaTableParametersI3D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableParametersI3D(hDC: GDI_DC; iAttribute: Int32; piValue: array of Int32): UInt32 := z_GetGammaTableParametersI3D_ovr0(hDC, iAttribute, piValue);
private static function _z_GetGammaTableParametersI3D_ovr1(hDC: GDI_DC; iAttribute: Int32; var piValue: Int32): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableParametersI3D';
public static z_GetGammaTableParametersI3D_ovr1 := _z_GetGammaTableParametersI3D_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableParametersI3D(hDC: GDI_DC; iAttribute: Int32; var piValue: Int32): UInt32 := z_GetGammaTableParametersI3D_ovr1(hDC, iAttribute, piValue);
private static function _z_GetGammaTableParametersI3D_ovr2(hDC: GDI_DC; iAttribute: Int32; piValue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableParametersI3D';
public static z_GetGammaTableParametersI3D_ovr2 := _z_GetGammaTableParametersI3D_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableParametersI3D(hDC: GDI_DC; iAttribute: Int32; piValue: IntPtr): UInt32 := z_GetGammaTableParametersI3D_ovr2(hDC, iAttribute, piValue);
private static function _z_SetGammaTableParametersI3D_ovr0(hDC: GDI_DC; iAttribute: Int32; [MarshalAs(UnmanagedType.LPArray)] piValue: array of Int32): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableParametersI3D';
public static z_SetGammaTableParametersI3D_ovr0 := _z_SetGammaTableParametersI3D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableParametersI3D(hDC: GDI_DC; iAttribute: Int32; piValue: array of Int32): UInt32 := z_SetGammaTableParametersI3D_ovr0(hDC, iAttribute, piValue);
private static function _z_SetGammaTableParametersI3D_ovr1(hDC: GDI_DC; iAttribute: Int32; var piValue: Int32): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableParametersI3D';
public static z_SetGammaTableParametersI3D_ovr1 := _z_SetGammaTableParametersI3D_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableParametersI3D(hDC: GDI_DC; iAttribute: Int32; var piValue: Int32): UInt32 := z_SetGammaTableParametersI3D_ovr1(hDC, iAttribute, piValue);
private static function _z_SetGammaTableParametersI3D_ovr2(hDC: GDI_DC; iAttribute: Int32; piValue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableParametersI3D';
public static z_SetGammaTableParametersI3D_ovr2 := _z_SetGammaTableParametersI3D_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableParametersI3D(hDC: GDI_DC; iAttribute: Int32; piValue: IntPtr): UInt32 := z_SetGammaTableParametersI3D_ovr2(hDC, iAttribute, piValue);
private static function _z_GetGammaTableI3D_ovr0(hDC: GDI_DC; iEntries: Int32; [MarshalAs(UnmanagedType.LPArray)] puRed: array of UInt16; [MarshalAs(UnmanagedType.LPArray)] puGreen: array of UInt16; [MarshalAs(UnmanagedType.LPArray)] puBlue: array of UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public static z_GetGammaTableI3D_ovr0 := _z_GetGammaTableI3D_ovr0;
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 := z_GetGammaTableI3D_ovr0(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_GetGammaTableI3D_ovr1(hDC: GDI_DC; iEntries: Int32; [MarshalAs(UnmanagedType.LPArray)] puRed: array of UInt16; [MarshalAs(UnmanagedType.LPArray)] puGreen: array of UInt16; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public static z_GetGammaTableI3D_ovr1 := _z_GetGammaTableI3D_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; puGreen: array of UInt16; var puBlue: UInt16): UInt32 := z_GetGammaTableI3D_ovr1(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_GetGammaTableI3D_ovr2(hDC: GDI_DC; iEntries: Int32; [MarshalAs(UnmanagedType.LPArray)] puRed: array of UInt16; [MarshalAs(UnmanagedType.LPArray)] puGreen: array of UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public static z_GetGammaTableI3D_ovr2 := _z_GetGammaTableI3D_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; puGreen: array of UInt16; puBlue: IntPtr): UInt32 := z_GetGammaTableI3D_ovr2(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_GetGammaTableI3D_ovr3(hDC: GDI_DC; iEntries: Int32; [MarshalAs(UnmanagedType.LPArray)] puRed: array of UInt16; var puGreen: UInt16; [MarshalAs(UnmanagedType.LPArray)] puBlue: array of UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public static z_GetGammaTableI3D_ovr3 := _z_GetGammaTableI3D_ovr3;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; var puGreen: UInt16; puBlue: array of UInt16): UInt32 := z_GetGammaTableI3D_ovr3(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_GetGammaTableI3D_ovr4(hDC: GDI_DC; iEntries: Int32; [MarshalAs(UnmanagedType.LPArray)] puRed: array of UInt16; var puGreen: UInt16; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public static z_GetGammaTableI3D_ovr4 := _z_GetGammaTableI3D_ovr4;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; var puGreen: UInt16; var puBlue: UInt16): UInt32 := z_GetGammaTableI3D_ovr4(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_GetGammaTableI3D_ovr5(hDC: GDI_DC; iEntries: Int32; [MarshalAs(UnmanagedType.LPArray)] puRed: array of UInt16; var puGreen: UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public static z_GetGammaTableI3D_ovr5 := _z_GetGammaTableI3D_ovr5;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; var puGreen: UInt16; puBlue: IntPtr): UInt32 := z_GetGammaTableI3D_ovr5(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_GetGammaTableI3D_ovr6(hDC: GDI_DC; iEntries: Int32; [MarshalAs(UnmanagedType.LPArray)] puRed: array of UInt16; puGreen: IntPtr; [MarshalAs(UnmanagedType.LPArray)] puBlue: array of UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public static z_GetGammaTableI3D_ovr6 := _z_GetGammaTableI3D_ovr6;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; puGreen: IntPtr; puBlue: array of UInt16): UInt32 := z_GetGammaTableI3D_ovr6(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_GetGammaTableI3D_ovr7(hDC: GDI_DC; iEntries: Int32; [MarshalAs(UnmanagedType.LPArray)] puRed: array of UInt16; puGreen: IntPtr; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public static z_GetGammaTableI3D_ovr7 := _z_GetGammaTableI3D_ovr7;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; puGreen: IntPtr; var puBlue: UInt16): UInt32 := z_GetGammaTableI3D_ovr7(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_GetGammaTableI3D_ovr8(hDC: GDI_DC; iEntries: Int32; [MarshalAs(UnmanagedType.LPArray)] puRed: array of UInt16; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public static z_GetGammaTableI3D_ovr8 := _z_GetGammaTableI3D_ovr8;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; puGreen: IntPtr; puBlue: IntPtr): UInt32 := z_GetGammaTableI3D_ovr8(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_GetGammaTableI3D_ovr9(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; [MarshalAs(UnmanagedType.LPArray)] puGreen: array of UInt16; [MarshalAs(UnmanagedType.LPArray)] puBlue: array of UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public static z_GetGammaTableI3D_ovr9 := _z_GetGammaTableI3D_ovr9;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: array of UInt16; puBlue: array of UInt16): UInt32 := z_GetGammaTableI3D_ovr9(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_GetGammaTableI3D_ovr10(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; [MarshalAs(UnmanagedType.LPArray)] puGreen: array of UInt16; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public static z_GetGammaTableI3D_ovr10 := _z_GetGammaTableI3D_ovr10;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: array of UInt16; var puBlue: UInt16): UInt32 := z_GetGammaTableI3D_ovr10(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_GetGammaTableI3D_ovr11(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; [MarshalAs(UnmanagedType.LPArray)] puGreen: array of UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public static z_GetGammaTableI3D_ovr11 := _z_GetGammaTableI3D_ovr11;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: array of UInt16; puBlue: IntPtr): UInt32 := z_GetGammaTableI3D_ovr11(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_GetGammaTableI3D_ovr12(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; var puGreen: UInt16; [MarshalAs(UnmanagedType.LPArray)] puBlue: array of UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public static z_GetGammaTableI3D_ovr12 := _z_GetGammaTableI3D_ovr12;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; var puGreen: UInt16; puBlue: array of UInt16): UInt32 := z_GetGammaTableI3D_ovr12(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_GetGammaTableI3D_ovr13(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; var puGreen: UInt16; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public static z_GetGammaTableI3D_ovr13 := _z_GetGammaTableI3D_ovr13;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; var puGreen: UInt16; var puBlue: UInt16): UInt32 := z_GetGammaTableI3D_ovr13(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_GetGammaTableI3D_ovr14(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; var puGreen: UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public static z_GetGammaTableI3D_ovr14 := _z_GetGammaTableI3D_ovr14;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; var puGreen: UInt16; puBlue: IntPtr): UInt32 := z_GetGammaTableI3D_ovr14(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_GetGammaTableI3D_ovr15(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; [MarshalAs(UnmanagedType.LPArray)] puBlue: array of UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public static z_GetGammaTableI3D_ovr15 := _z_GetGammaTableI3D_ovr15;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; puBlue: array of UInt16): UInt32 := z_GetGammaTableI3D_ovr15(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_GetGammaTableI3D_ovr16(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public static z_GetGammaTableI3D_ovr16 := _z_GetGammaTableI3D_ovr16;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; var puBlue: UInt16): UInt32 := z_GetGammaTableI3D_ovr16(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_GetGammaTableI3D_ovr17(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public static z_GetGammaTableI3D_ovr17 := _z_GetGammaTableI3D_ovr17;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; puBlue: IntPtr): UInt32 := z_GetGammaTableI3D_ovr17(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_GetGammaTableI3D_ovr18(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; [MarshalAs(UnmanagedType.LPArray)] puGreen: array of UInt16; [MarshalAs(UnmanagedType.LPArray)] puBlue: array of UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public static z_GetGammaTableI3D_ovr18 := _z_GetGammaTableI3D_ovr18;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: array of UInt16; puBlue: array of UInt16): UInt32 := z_GetGammaTableI3D_ovr18(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_GetGammaTableI3D_ovr19(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; [MarshalAs(UnmanagedType.LPArray)] puGreen: array of UInt16; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public static z_GetGammaTableI3D_ovr19 := _z_GetGammaTableI3D_ovr19;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: array of UInt16; var puBlue: UInt16): UInt32 := z_GetGammaTableI3D_ovr19(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_GetGammaTableI3D_ovr20(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; [MarshalAs(UnmanagedType.LPArray)] puGreen: array of UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public static z_GetGammaTableI3D_ovr20 := _z_GetGammaTableI3D_ovr20;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: array of UInt16; puBlue: IntPtr): UInt32 := z_GetGammaTableI3D_ovr20(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_GetGammaTableI3D_ovr21(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; [MarshalAs(UnmanagedType.LPArray)] puBlue: array of UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public static z_GetGammaTableI3D_ovr21 := _z_GetGammaTableI3D_ovr21;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; puBlue: array of UInt16): UInt32 := z_GetGammaTableI3D_ovr21(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_GetGammaTableI3D_ovr22(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public static z_GetGammaTableI3D_ovr22 := _z_GetGammaTableI3D_ovr22;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; var puBlue: UInt16): UInt32 := z_GetGammaTableI3D_ovr22(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_GetGammaTableI3D_ovr23(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public static z_GetGammaTableI3D_ovr23 := _z_GetGammaTableI3D_ovr23;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; puBlue: IntPtr): UInt32 := z_GetGammaTableI3D_ovr23(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_GetGammaTableI3D_ovr24(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; [MarshalAs(UnmanagedType.LPArray)] puBlue: array of UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public static z_GetGammaTableI3D_ovr24 := _z_GetGammaTableI3D_ovr24;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; puBlue: array of UInt16): UInt32 := z_GetGammaTableI3D_ovr24(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_GetGammaTableI3D_ovr25(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public static z_GetGammaTableI3D_ovr25 := _z_GetGammaTableI3D_ovr25;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; var puBlue: UInt16): UInt32 := z_GetGammaTableI3D_ovr25(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_GetGammaTableI3D_ovr26(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGammaTableI3D';
public static z_GetGammaTableI3D_ovr26 := _z_GetGammaTableI3D_ovr26;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; puBlue: IntPtr): UInt32 := z_GetGammaTableI3D_ovr26(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_SetGammaTableI3D_ovr0(hDC: GDI_DC; iEntries: Int32; [MarshalAs(UnmanagedType.LPArray)] puRed: array of UInt16; [MarshalAs(UnmanagedType.LPArray)] puGreen: array of UInt16; [MarshalAs(UnmanagedType.LPArray)] puBlue: array of UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public static z_SetGammaTableI3D_ovr0 := _z_SetGammaTableI3D_ovr0;
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 := z_SetGammaTableI3D_ovr0(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_SetGammaTableI3D_ovr1(hDC: GDI_DC; iEntries: Int32; [MarshalAs(UnmanagedType.LPArray)] puRed: array of UInt16; [MarshalAs(UnmanagedType.LPArray)] puGreen: array of UInt16; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public static z_SetGammaTableI3D_ovr1 := _z_SetGammaTableI3D_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; puGreen: array of UInt16; var puBlue: UInt16): UInt32 := z_SetGammaTableI3D_ovr1(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_SetGammaTableI3D_ovr2(hDC: GDI_DC; iEntries: Int32; [MarshalAs(UnmanagedType.LPArray)] puRed: array of UInt16; [MarshalAs(UnmanagedType.LPArray)] puGreen: array of UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public static z_SetGammaTableI3D_ovr2 := _z_SetGammaTableI3D_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; puGreen: array of UInt16; puBlue: IntPtr): UInt32 := z_SetGammaTableI3D_ovr2(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_SetGammaTableI3D_ovr3(hDC: GDI_DC; iEntries: Int32; [MarshalAs(UnmanagedType.LPArray)] puRed: array of UInt16; var puGreen: UInt16; [MarshalAs(UnmanagedType.LPArray)] puBlue: array of UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public static z_SetGammaTableI3D_ovr3 := _z_SetGammaTableI3D_ovr3;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; var puGreen: UInt16; puBlue: array of UInt16): UInt32 := z_SetGammaTableI3D_ovr3(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_SetGammaTableI3D_ovr4(hDC: GDI_DC; iEntries: Int32; [MarshalAs(UnmanagedType.LPArray)] puRed: array of UInt16; var puGreen: UInt16; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public static z_SetGammaTableI3D_ovr4 := _z_SetGammaTableI3D_ovr4;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; var puGreen: UInt16; var puBlue: UInt16): UInt32 := z_SetGammaTableI3D_ovr4(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_SetGammaTableI3D_ovr5(hDC: GDI_DC; iEntries: Int32; [MarshalAs(UnmanagedType.LPArray)] puRed: array of UInt16; var puGreen: UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public static z_SetGammaTableI3D_ovr5 := _z_SetGammaTableI3D_ovr5;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; var puGreen: UInt16; puBlue: IntPtr): UInt32 := z_SetGammaTableI3D_ovr5(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_SetGammaTableI3D_ovr6(hDC: GDI_DC; iEntries: Int32; [MarshalAs(UnmanagedType.LPArray)] puRed: array of UInt16; puGreen: IntPtr; [MarshalAs(UnmanagedType.LPArray)] puBlue: array of UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public static z_SetGammaTableI3D_ovr6 := _z_SetGammaTableI3D_ovr6;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; puGreen: IntPtr; puBlue: array of UInt16): UInt32 := z_SetGammaTableI3D_ovr6(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_SetGammaTableI3D_ovr7(hDC: GDI_DC; iEntries: Int32; [MarshalAs(UnmanagedType.LPArray)] puRed: array of UInt16; puGreen: IntPtr; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public static z_SetGammaTableI3D_ovr7 := _z_SetGammaTableI3D_ovr7;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; puGreen: IntPtr; var puBlue: UInt16): UInt32 := z_SetGammaTableI3D_ovr7(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_SetGammaTableI3D_ovr8(hDC: GDI_DC; iEntries: Int32; [MarshalAs(UnmanagedType.LPArray)] puRed: array of UInt16; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public static z_SetGammaTableI3D_ovr8 := _z_SetGammaTableI3D_ovr8;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: array of UInt16; puGreen: IntPtr; puBlue: IntPtr): UInt32 := z_SetGammaTableI3D_ovr8(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_SetGammaTableI3D_ovr9(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; [MarshalAs(UnmanagedType.LPArray)] puGreen: array of UInt16; [MarshalAs(UnmanagedType.LPArray)] puBlue: array of UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public static z_SetGammaTableI3D_ovr9 := _z_SetGammaTableI3D_ovr9;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: array of UInt16; puBlue: array of UInt16): UInt32 := z_SetGammaTableI3D_ovr9(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_SetGammaTableI3D_ovr10(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; [MarshalAs(UnmanagedType.LPArray)] puGreen: array of UInt16; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public static z_SetGammaTableI3D_ovr10 := _z_SetGammaTableI3D_ovr10;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: array of UInt16; var puBlue: UInt16): UInt32 := z_SetGammaTableI3D_ovr10(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_SetGammaTableI3D_ovr11(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; [MarshalAs(UnmanagedType.LPArray)] puGreen: array of UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public static z_SetGammaTableI3D_ovr11 := _z_SetGammaTableI3D_ovr11;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: array of UInt16; puBlue: IntPtr): UInt32 := z_SetGammaTableI3D_ovr11(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_SetGammaTableI3D_ovr12(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; var puGreen: UInt16; [MarshalAs(UnmanagedType.LPArray)] puBlue: array of UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public static z_SetGammaTableI3D_ovr12 := _z_SetGammaTableI3D_ovr12;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; var puGreen: UInt16; puBlue: array of UInt16): UInt32 := z_SetGammaTableI3D_ovr12(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_SetGammaTableI3D_ovr13(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; var puGreen: UInt16; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public static z_SetGammaTableI3D_ovr13 := _z_SetGammaTableI3D_ovr13;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; var puGreen: UInt16; var puBlue: UInt16): UInt32 := z_SetGammaTableI3D_ovr13(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_SetGammaTableI3D_ovr14(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; var puGreen: UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public static z_SetGammaTableI3D_ovr14 := _z_SetGammaTableI3D_ovr14;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; var puGreen: UInt16; puBlue: IntPtr): UInt32 := z_SetGammaTableI3D_ovr14(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_SetGammaTableI3D_ovr15(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; [MarshalAs(UnmanagedType.LPArray)] puBlue: array of UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public static z_SetGammaTableI3D_ovr15 := _z_SetGammaTableI3D_ovr15;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; puBlue: array of UInt16): UInt32 := z_SetGammaTableI3D_ovr15(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_SetGammaTableI3D_ovr16(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public static z_SetGammaTableI3D_ovr16 := _z_SetGammaTableI3D_ovr16;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; var puBlue: UInt16): UInt32 := z_SetGammaTableI3D_ovr16(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_SetGammaTableI3D_ovr17(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public static z_SetGammaTableI3D_ovr17 := _z_SetGammaTableI3D_ovr17;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; var puRed: UInt16; puGreen: IntPtr; puBlue: IntPtr): UInt32 := z_SetGammaTableI3D_ovr17(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_SetGammaTableI3D_ovr18(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; [MarshalAs(UnmanagedType.LPArray)] puGreen: array of UInt16; [MarshalAs(UnmanagedType.LPArray)] puBlue: array of UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public static z_SetGammaTableI3D_ovr18 := _z_SetGammaTableI3D_ovr18;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: array of UInt16; puBlue: array of UInt16): UInt32 := z_SetGammaTableI3D_ovr18(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_SetGammaTableI3D_ovr19(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; [MarshalAs(UnmanagedType.LPArray)] puGreen: array of UInt16; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public static z_SetGammaTableI3D_ovr19 := _z_SetGammaTableI3D_ovr19;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: array of UInt16; var puBlue: UInt16): UInt32 := z_SetGammaTableI3D_ovr19(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_SetGammaTableI3D_ovr20(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; [MarshalAs(UnmanagedType.LPArray)] puGreen: array of UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public static z_SetGammaTableI3D_ovr20 := _z_SetGammaTableI3D_ovr20;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: array of UInt16; puBlue: IntPtr): UInt32 := z_SetGammaTableI3D_ovr20(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_SetGammaTableI3D_ovr21(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; [MarshalAs(UnmanagedType.LPArray)] puBlue: array of UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public static z_SetGammaTableI3D_ovr21 := _z_SetGammaTableI3D_ovr21;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; puBlue: array of UInt16): UInt32 := z_SetGammaTableI3D_ovr21(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_SetGammaTableI3D_ovr22(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public static z_SetGammaTableI3D_ovr22 := _z_SetGammaTableI3D_ovr22;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; var puBlue: UInt16): UInt32 := z_SetGammaTableI3D_ovr22(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_SetGammaTableI3D_ovr23(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public static z_SetGammaTableI3D_ovr23 := _z_SetGammaTableI3D_ovr23;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; var puGreen: UInt16; puBlue: IntPtr): UInt32 := z_SetGammaTableI3D_ovr23(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_SetGammaTableI3D_ovr24(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; [MarshalAs(UnmanagedType.LPArray)] puBlue: array of UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public static z_SetGammaTableI3D_ovr24 := _z_SetGammaTableI3D_ovr24;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; puBlue: array of UInt16): UInt32 := z_SetGammaTableI3D_ovr24(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_SetGammaTableI3D_ovr25(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; var puBlue: UInt16): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public static z_SetGammaTableI3D_ovr25 := _z_SetGammaTableI3D_ovr25;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; var puBlue: UInt16): UInt32 := z_SetGammaTableI3D_ovr25(hDC, iEntries, puRed, puGreen, puBlue);
private static function _z_SetGammaTableI3D_ovr26(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; puBlue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglSetGammaTableI3D';
public static z_SetGammaTableI3D_ovr26 := _z_SetGammaTableI3D_ovr26;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SetGammaTableI3D(hDC: GDI_DC; iEntries: Int32; puRed: IntPtr; puGreen: IntPtr; puBlue: IntPtr): UInt32 := z_SetGammaTableI3D_ovr26(hDC, iEntries, puRed, puGreen, puBlue);
end;
wglGenlockI3D = static class
private static function _z_EnableGenlockI3D_ovr0(hDC: GDI_DC): UInt32;
external 'opengl32.dll' name 'wglEnableGenlockI3D';
public static z_EnableGenlockI3D_ovr0 := _z_EnableGenlockI3D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnableGenlockI3D(hDC: GDI_DC): UInt32 := z_EnableGenlockI3D_ovr0(hDC);
private static function _z_DisableGenlockI3D_ovr0(hDC: GDI_DC): UInt32;
external 'opengl32.dll' name 'wglDisableGenlockI3D';
public static z_DisableGenlockI3D_ovr0 := _z_DisableGenlockI3D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DisableGenlockI3D(hDC: GDI_DC): UInt32 := z_DisableGenlockI3D_ovr0(hDC);
private static function _z_IsEnabledGenlockI3D_ovr0(hDC: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] pFlag: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglIsEnabledGenlockI3D';
public static z_IsEnabledGenlockI3D_ovr0 := _z_IsEnabledGenlockI3D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function IsEnabledGenlockI3D(hDC: GDI_DC; pFlag: array of UInt32): UInt32 := z_IsEnabledGenlockI3D_ovr0(hDC, pFlag);
private static function _z_IsEnabledGenlockI3D_ovr1(hDC: GDI_DC; var pFlag: UInt32): UInt32;
external 'opengl32.dll' name 'wglIsEnabledGenlockI3D';
public static z_IsEnabledGenlockI3D_ovr1 := _z_IsEnabledGenlockI3D_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function IsEnabledGenlockI3D(hDC: GDI_DC; var pFlag: UInt32): UInt32 := z_IsEnabledGenlockI3D_ovr1(hDC, pFlag);
private static function _z_IsEnabledGenlockI3D_ovr2(hDC: GDI_DC; pFlag: IntPtr): UInt32;
external 'opengl32.dll' name 'wglIsEnabledGenlockI3D';
public static z_IsEnabledGenlockI3D_ovr2 := _z_IsEnabledGenlockI3D_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function IsEnabledGenlockI3D(hDC: GDI_DC; pFlag: IntPtr): UInt32 := z_IsEnabledGenlockI3D_ovr2(hDC, pFlag);
private static function _z_GenlockSourceI3D_ovr0(hDC: GDI_DC; uSource: UInt32): UInt32;
external 'opengl32.dll' name 'wglGenlockSourceI3D';
public static z_GenlockSourceI3D_ovr0 := _z_GenlockSourceI3D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GenlockSourceI3D(hDC: GDI_DC; uSource: UInt32): UInt32 := z_GenlockSourceI3D_ovr0(hDC, uSource);
private static function _z_GetGenlockSourceI3D_ovr0(hDC: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] uSource: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglGetGenlockSourceI3D';
public static z_GetGenlockSourceI3D_ovr0 := _z_GetGenlockSourceI3D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGenlockSourceI3D(hDC: GDI_DC; uSource: array of UInt32): UInt32 := z_GetGenlockSourceI3D_ovr0(hDC, uSource);
private static function _z_GetGenlockSourceI3D_ovr1(hDC: GDI_DC; var uSource: UInt32): UInt32;
external 'opengl32.dll' name 'wglGetGenlockSourceI3D';
public static z_GetGenlockSourceI3D_ovr1 := _z_GetGenlockSourceI3D_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGenlockSourceI3D(hDC: GDI_DC; var uSource: UInt32): UInt32 := z_GetGenlockSourceI3D_ovr1(hDC, uSource);
private static function _z_GetGenlockSourceI3D_ovr2(hDC: GDI_DC; uSource: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGenlockSourceI3D';
public static z_GetGenlockSourceI3D_ovr2 := _z_GetGenlockSourceI3D_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGenlockSourceI3D(hDC: GDI_DC; uSource: IntPtr): UInt32 := z_GetGenlockSourceI3D_ovr2(hDC, uSource);
private static function _z_GenlockSourceEdgeI3D_ovr0(hDC: GDI_DC; uEdge: UInt32): UInt32;
external 'opengl32.dll' name 'wglGenlockSourceEdgeI3D';
public static z_GenlockSourceEdgeI3D_ovr0 := _z_GenlockSourceEdgeI3D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GenlockSourceEdgeI3D(hDC: GDI_DC; uEdge: UInt32): UInt32 := z_GenlockSourceEdgeI3D_ovr0(hDC, uEdge);
private static function _z_GetGenlockSourceEdgeI3D_ovr0(hDC: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] uEdge: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglGetGenlockSourceEdgeI3D';
public static z_GetGenlockSourceEdgeI3D_ovr0 := _z_GetGenlockSourceEdgeI3D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGenlockSourceEdgeI3D(hDC: GDI_DC; uEdge: array of UInt32): UInt32 := z_GetGenlockSourceEdgeI3D_ovr0(hDC, uEdge);
private static function _z_GetGenlockSourceEdgeI3D_ovr1(hDC: GDI_DC; var uEdge: UInt32): UInt32;
external 'opengl32.dll' name 'wglGetGenlockSourceEdgeI3D';
public static z_GetGenlockSourceEdgeI3D_ovr1 := _z_GetGenlockSourceEdgeI3D_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGenlockSourceEdgeI3D(hDC: GDI_DC; var uEdge: UInt32): UInt32 := z_GetGenlockSourceEdgeI3D_ovr1(hDC, uEdge);
private static function _z_GetGenlockSourceEdgeI3D_ovr2(hDC: GDI_DC; uEdge: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGenlockSourceEdgeI3D';
public static z_GetGenlockSourceEdgeI3D_ovr2 := _z_GetGenlockSourceEdgeI3D_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGenlockSourceEdgeI3D(hDC: GDI_DC; uEdge: IntPtr): UInt32 := z_GetGenlockSourceEdgeI3D_ovr2(hDC, uEdge);
private static function _z_GenlockSampleRateI3D_ovr0(hDC: GDI_DC; uRate: UInt32): UInt32;
external 'opengl32.dll' name 'wglGenlockSampleRateI3D';
public static z_GenlockSampleRateI3D_ovr0 := _z_GenlockSampleRateI3D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GenlockSampleRateI3D(hDC: GDI_DC; uRate: UInt32): UInt32 := z_GenlockSampleRateI3D_ovr0(hDC, uRate);
private static function _z_GetGenlockSampleRateI3D_ovr0(hDC: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] uRate: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglGetGenlockSampleRateI3D';
public static z_GetGenlockSampleRateI3D_ovr0 := _z_GetGenlockSampleRateI3D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGenlockSampleRateI3D(hDC: GDI_DC; uRate: array of UInt32): UInt32 := z_GetGenlockSampleRateI3D_ovr0(hDC, uRate);
private static function _z_GetGenlockSampleRateI3D_ovr1(hDC: GDI_DC; var uRate: UInt32): UInt32;
external 'opengl32.dll' name 'wglGetGenlockSampleRateI3D';
public static z_GetGenlockSampleRateI3D_ovr1 := _z_GetGenlockSampleRateI3D_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGenlockSampleRateI3D(hDC: GDI_DC; var uRate: UInt32): UInt32 := z_GetGenlockSampleRateI3D_ovr1(hDC, uRate);
private static function _z_GetGenlockSampleRateI3D_ovr2(hDC: GDI_DC; uRate: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGenlockSampleRateI3D';
public static z_GetGenlockSampleRateI3D_ovr2 := _z_GetGenlockSampleRateI3D_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGenlockSampleRateI3D(hDC: GDI_DC; uRate: IntPtr): UInt32 := z_GetGenlockSampleRateI3D_ovr2(hDC, uRate);
private static function _z_GenlockSourceDelayI3D_ovr0(hDC: GDI_DC; uDelay: UInt32): UInt32;
external 'opengl32.dll' name 'wglGenlockSourceDelayI3D';
public static z_GenlockSourceDelayI3D_ovr0 := _z_GenlockSourceDelayI3D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GenlockSourceDelayI3D(hDC: GDI_DC; uDelay: UInt32): UInt32 := z_GenlockSourceDelayI3D_ovr0(hDC, uDelay);
private static function _z_GetGenlockSourceDelayI3D_ovr0(hDC: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] uDelay: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglGetGenlockSourceDelayI3D';
public static z_GetGenlockSourceDelayI3D_ovr0 := _z_GetGenlockSourceDelayI3D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGenlockSourceDelayI3D(hDC: GDI_DC; uDelay: array of UInt32): UInt32 := z_GetGenlockSourceDelayI3D_ovr0(hDC, uDelay);
private static function _z_GetGenlockSourceDelayI3D_ovr1(hDC: GDI_DC; var uDelay: UInt32): UInt32;
external 'opengl32.dll' name 'wglGetGenlockSourceDelayI3D';
public static z_GetGenlockSourceDelayI3D_ovr1 := _z_GetGenlockSourceDelayI3D_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGenlockSourceDelayI3D(hDC: GDI_DC; var uDelay: UInt32): UInt32 := z_GetGenlockSourceDelayI3D_ovr1(hDC, uDelay);
private static function _z_GetGenlockSourceDelayI3D_ovr2(hDC: GDI_DC; uDelay: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetGenlockSourceDelayI3D';
public static z_GetGenlockSourceDelayI3D_ovr2 := _z_GetGenlockSourceDelayI3D_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetGenlockSourceDelayI3D(hDC: GDI_DC; uDelay: IntPtr): UInt32 := z_GetGenlockSourceDelayI3D_ovr2(hDC, uDelay);
private static function _z_QueryGenlockMaxSourceDelayI3D_ovr0(hDC: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] uMaxLineDelay: array of UInt32; [MarshalAs(UnmanagedType.LPArray)] uMaxPixelDelay: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglQueryGenlockMaxSourceDelayI3D';
public static z_QueryGenlockMaxSourceDelayI3D_ovr0 := _z_QueryGenlockMaxSourceDelayI3D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryGenlockMaxSourceDelayI3D(hDC: GDI_DC; uMaxLineDelay: array of UInt32; uMaxPixelDelay: array of UInt32): UInt32 := z_QueryGenlockMaxSourceDelayI3D_ovr0(hDC, uMaxLineDelay, uMaxPixelDelay);
private static function _z_QueryGenlockMaxSourceDelayI3D_ovr1(hDC: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] uMaxLineDelay: array of UInt32; var uMaxPixelDelay: UInt32): UInt32;
external 'opengl32.dll' name 'wglQueryGenlockMaxSourceDelayI3D';
public static z_QueryGenlockMaxSourceDelayI3D_ovr1 := _z_QueryGenlockMaxSourceDelayI3D_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryGenlockMaxSourceDelayI3D(hDC: GDI_DC; uMaxLineDelay: array of UInt32; var uMaxPixelDelay: UInt32): UInt32 := z_QueryGenlockMaxSourceDelayI3D_ovr1(hDC, uMaxLineDelay, uMaxPixelDelay);
private static function _z_QueryGenlockMaxSourceDelayI3D_ovr2(hDC: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] uMaxLineDelay: array of UInt32; uMaxPixelDelay: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryGenlockMaxSourceDelayI3D';
public static z_QueryGenlockMaxSourceDelayI3D_ovr2 := _z_QueryGenlockMaxSourceDelayI3D_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryGenlockMaxSourceDelayI3D(hDC: GDI_DC; uMaxLineDelay: array of UInt32; uMaxPixelDelay: IntPtr): UInt32 := z_QueryGenlockMaxSourceDelayI3D_ovr2(hDC, uMaxLineDelay, uMaxPixelDelay);
private static function _z_QueryGenlockMaxSourceDelayI3D_ovr3(hDC: GDI_DC; var uMaxLineDelay: UInt32; [MarshalAs(UnmanagedType.LPArray)] uMaxPixelDelay: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglQueryGenlockMaxSourceDelayI3D';
public static z_QueryGenlockMaxSourceDelayI3D_ovr3 := _z_QueryGenlockMaxSourceDelayI3D_ovr3;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryGenlockMaxSourceDelayI3D(hDC: GDI_DC; var uMaxLineDelay: UInt32; uMaxPixelDelay: array of UInt32): UInt32 := z_QueryGenlockMaxSourceDelayI3D_ovr3(hDC, uMaxLineDelay, uMaxPixelDelay);
private static function _z_QueryGenlockMaxSourceDelayI3D_ovr4(hDC: GDI_DC; var uMaxLineDelay: UInt32; var uMaxPixelDelay: UInt32): UInt32;
external 'opengl32.dll' name 'wglQueryGenlockMaxSourceDelayI3D';
public static z_QueryGenlockMaxSourceDelayI3D_ovr4 := _z_QueryGenlockMaxSourceDelayI3D_ovr4;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryGenlockMaxSourceDelayI3D(hDC: GDI_DC; var uMaxLineDelay: UInt32; var uMaxPixelDelay: UInt32): UInt32 := z_QueryGenlockMaxSourceDelayI3D_ovr4(hDC, uMaxLineDelay, uMaxPixelDelay);
private static function _z_QueryGenlockMaxSourceDelayI3D_ovr5(hDC: GDI_DC; var uMaxLineDelay: UInt32; uMaxPixelDelay: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryGenlockMaxSourceDelayI3D';
public static z_QueryGenlockMaxSourceDelayI3D_ovr5 := _z_QueryGenlockMaxSourceDelayI3D_ovr5;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryGenlockMaxSourceDelayI3D(hDC: GDI_DC; var uMaxLineDelay: UInt32; uMaxPixelDelay: IntPtr): UInt32 := z_QueryGenlockMaxSourceDelayI3D_ovr5(hDC, uMaxLineDelay, uMaxPixelDelay);
private static function _z_QueryGenlockMaxSourceDelayI3D_ovr6(hDC: GDI_DC; uMaxLineDelay: IntPtr; [MarshalAs(UnmanagedType.LPArray)] uMaxPixelDelay: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglQueryGenlockMaxSourceDelayI3D';
public static z_QueryGenlockMaxSourceDelayI3D_ovr6 := _z_QueryGenlockMaxSourceDelayI3D_ovr6;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryGenlockMaxSourceDelayI3D(hDC: GDI_DC; uMaxLineDelay: IntPtr; uMaxPixelDelay: array of UInt32): UInt32 := z_QueryGenlockMaxSourceDelayI3D_ovr6(hDC, uMaxLineDelay, uMaxPixelDelay);
private static function _z_QueryGenlockMaxSourceDelayI3D_ovr7(hDC: GDI_DC; uMaxLineDelay: IntPtr; var uMaxPixelDelay: UInt32): UInt32;
external 'opengl32.dll' name 'wglQueryGenlockMaxSourceDelayI3D';
public static z_QueryGenlockMaxSourceDelayI3D_ovr7 := _z_QueryGenlockMaxSourceDelayI3D_ovr7;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryGenlockMaxSourceDelayI3D(hDC: GDI_DC; uMaxLineDelay: IntPtr; var uMaxPixelDelay: UInt32): UInt32 := z_QueryGenlockMaxSourceDelayI3D_ovr7(hDC, uMaxLineDelay, uMaxPixelDelay);
private static function _z_QueryGenlockMaxSourceDelayI3D_ovr8(hDC: GDI_DC; uMaxLineDelay: IntPtr; uMaxPixelDelay: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryGenlockMaxSourceDelayI3D';
public static z_QueryGenlockMaxSourceDelayI3D_ovr8 := _z_QueryGenlockMaxSourceDelayI3D_ovr8;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryGenlockMaxSourceDelayI3D(hDC: GDI_DC; uMaxLineDelay: IntPtr; uMaxPixelDelay: IntPtr): UInt32 := z_QueryGenlockMaxSourceDelayI3D_ovr8(hDC, uMaxLineDelay, uMaxPixelDelay);
end;
wglImageBufferI3D = static class
private static function _z_CreateImageBufferI3D_ovr0(hDC: GDI_DC; dwSize: UInt32; uFlags: UInt32): IntPtr;
external 'opengl32.dll' name 'wglCreateImageBufferI3D';
public static z_CreateImageBufferI3D_ovr0 := _z_CreateImageBufferI3D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateImageBufferI3D(hDC: GDI_DC; dwSize: UInt32; uFlags: UInt32): IntPtr := z_CreateImageBufferI3D_ovr0(hDC, dwSize, uFlags);
private static function _z_DestroyImageBufferI3D_ovr0(hDC: GDI_DC; pAddress: IntPtr): UInt32;
external 'opengl32.dll' name 'wglDestroyImageBufferI3D';
public static z_DestroyImageBufferI3D_ovr0 := _z_DestroyImageBufferI3D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DestroyImageBufferI3D(hDC: GDI_DC; pAddress: IntPtr): UInt32 := z_DestroyImageBufferI3D_ovr0(hDC, pAddress);
private static function _z_AssociateImageBufferEventsI3D_ovr0(hDC: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] pEvent: array of IntPtr; [MarshalAs(UnmanagedType.LPArray)] pAddress: array of IntPtr; [MarshalAs(UnmanagedType.LPArray)] pSize: array of UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public static z_AssociateImageBufferEventsI3D_ovr0 := _z_AssociateImageBufferEventsI3D_ovr0;
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 := z_AssociateImageBufferEventsI3D_ovr0(hDC, pEvent, pAddress, pSize, count);
private static function _z_AssociateImageBufferEventsI3D_ovr1(hDC: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] pEvent: array of IntPtr; [MarshalAs(UnmanagedType.LPArray)] pAddress: array of IntPtr; var pSize: UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public static z_AssociateImageBufferEventsI3D_ovr1 := _z_AssociateImageBufferEventsI3D_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: array of IntPtr; pAddress: array of IntPtr; var pSize: UInt32; count: UInt32): UInt32 := z_AssociateImageBufferEventsI3D_ovr1(hDC, pEvent, pAddress, pSize, count);
private static function _z_AssociateImageBufferEventsI3D_ovr2(hDC: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] pEvent: array of IntPtr; [MarshalAs(UnmanagedType.LPArray)] pAddress: array of IntPtr; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public static z_AssociateImageBufferEventsI3D_ovr2 := _z_AssociateImageBufferEventsI3D_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: array of IntPtr; pAddress: array of IntPtr; pSize: IntPtr; count: UInt32): UInt32 := z_AssociateImageBufferEventsI3D_ovr2(hDC, pEvent, pAddress, pSize, count);
private static function _z_AssociateImageBufferEventsI3D_ovr3(hDC: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] pEvent: array of IntPtr; var pAddress: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pSize: array of UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public static z_AssociateImageBufferEventsI3D_ovr3 := _z_AssociateImageBufferEventsI3D_ovr3;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: array of IntPtr; var pAddress: IntPtr; pSize: array of UInt32; count: UInt32): UInt32 := z_AssociateImageBufferEventsI3D_ovr3(hDC, pEvent, pAddress, pSize, count);
private static function _z_AssociateImageBufferEventsI3D_ovr4(hDC: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] pEvent: array of IntPtr; var pAddress: IntPtr; var pSize: UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public static z_AssociateImageBufferEventsI3D_ovr4 := _z_AssociateImageBufferEventsI3D_ovr4;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: array of IntPtr; var pAddress: IntPtr; var pSize: UInt32; count: UInt32): UInt32 := z_AssociateImageBufferEventsI3D_ovr4(hDC, pEvent, pAddress, pSize, count);
private static function _z_AssociateImageBufferEventsI3D_ovr5(hDC: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] pEvent: array of IntPtr; var pAddress: IntPtr; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public static z_AssociateImageBufferEventsI3D_ovr5 := _z_AssociateImageBufferEventsI3D_ovr5;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: array of IntPtr; var pAddress: IntPtr; pSize: IntPtr; count: UInt32): UInt32 := z_AssociateImageBufferEventsI3D_ovr5(hDC, pEvent, pAddress, pSize, count);
private static function _z_AssociateImageBufferEventsI3D_ovr6(hDC: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] pEvent: array of IntPtr; pAddress: pointer; [MarshalAs(UnmanagedType.LPArray)] pSize: array of UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public static z_AssociateImageBufferEventsI3D_ovr6 := _z_AssociateImageBufferEventsI3D_ovr6;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: array of IntPtr; pAddress: pointer; pSize: array of UInt32; count: UInt32): UInt32 := z_AssociateImageBufferEventsI3D_ovr6(hDC, pEvent, pAddress, pSize, count);
private static function _z_AssociateImageBufferEventsI3D_ovr7(hDC: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] pEvent: array of IntPtr; pAddress: pointer; var pSize: UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public static z_AssociateImageBufferEventsI3D_ovr7 := _z_AssociateImageBufferEventsI3D_ovr7;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: array of IntPtr; pAddress: pointer; var pSize: UInt32; count: UInt32): UInt32 := z_AssociateImageBufferEventsI3D_ovr7(hDC, pEvent, pAddress, pSize, count);
private static function _z_AssociateImageBufferEventsI3D_ovr8(hDC: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] pEvent: array of IntPtr; pAddress: pointer; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public static z_AssociateImageBufferEventsI3D_ovr8 := _z_AssociateImageBufferEventsI3D_ovr8;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: array of IntPtr; pAddress: pointer; pSize: IntPtr; count: UInt32): UInt32 := z_AssociateImageBufferEventsI3D_ovr8(hDC, pEvent, pAddress, pSize, count);
private static function _z_AssociateImageBufferEventsI3D_ovr9(hDC: GDI_DC; var pEvent: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pAddress: array of IntPtr; [MarshalAs(UnmanagedType.LPArray)] pSize: array of UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public static z_AssociateImageBufferEventsI3D_ovr9 := _z_AssociateImageBufferEventsI3D_ovr9;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; var pEvent: IntPtr; pAddress: array of IntPtr; pSize: array of UInt32; count: UInt32): UInt32 := z_AssociateImageBufferEventsI3D_ovr9(hDC, pEvent, pAddress, pSize, count);
private static function _z_AssociateImageBufferEventsI3D_ovr10(hDC: GDI_DC; var pEvent: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pAddress: array of IntPtr; var pSize: UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public static z_AssociateImageBufferEventsI3D_ovr10 := _z_AssociateImageBufferEventsI3D_ovr10;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; var pEvent: IntPtr; pAddress: array of IntPtr; var pSize: UInt32; count: UInt32): UInt32 := z_AssociateImageBufferEventsI3D_ovr10(hDC, pEvent, pAddress, pSize, count);
private static function _z_AssociateImageBufferEventsI3D_ovr11(hDC: GDI_DC; var pEvent: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pAddress: array of IntPtr; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public static z_AssociateImageBufferEventsI3D_ovr11 := _z_AssociateImageBufferEventsI3D_ovr11;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; var pEvent: IntPtr; pAddress: array of IntPtr; pSize: IntPtr; count: UInt32): UInt32 := z_AssociateImageBufferEventsI3D_ovr11(hDC, pEvent, pAddress, pSize, count);
private static function _z_AssociateImageBufferEventsI3D_ovr12(hDC: GDI_DC; var pEvent: IntPtr; var pAddress: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pSize: array of UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public static z_AssociateImageBufferEventsI3D_ovr12 := _z_AssociateImageBufferEventsI3D_ovr12;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; var pEvent: IntPtr; var pAddress: IntPtr; pSize: array of UInt32; count: UInt32): UInt32 := z_AssociateImageBufferEventsI3D_ovr12(hDC, pEvent, pAddress, pSize, count);
private static function _z_AssociateImageBufferEventsI3D_ovr13(hDC: GDI_DC; var pEvent: IntPtr; var pAddress: IntPtr; var pSize: UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public static z_AssociateImageBufferEventsI3D_ovr13 := _z_AssociateImageBufferEventsI3D_ovr13;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; var pEvent: IntPtr; var pAddress: IntPtr; var pSize: UInt32; count: UInt32): UInt32 := z_AssociateImageBufferEventsI3D_ovr13(hDC, pEvent, pAddress, pSize, count);
private static function _z_AssociateImageBufferEventsI3D_ovr14(hDC: GDI_DC; var pEvent: IntPtr; var pAddress: IntPtr; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public static z_AssociateImageBufferEventsI3D_ovr14 := _z_AssociateImageBufferEventsI3D_ovr14;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; var pEvent: IntPtr; var pAddress: IntPtr; pSize: IntPtr; count: UInt32): UInt32 := z_AssociateImageBufferEventsI3D_ovr14(hDC, pEvent, pAddress, pSize, count);
private static function _z_AssociateImageBufferEventsI3D_ovr15(hDC: GDI_DC; var pEvent: IntPtr; pAddress: pointer; [MarshalAs(UnmanagedType.LPArray)] pSize: array of UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public static z_AssociateImageBufferEventsI3D_ovr15 := _z_AssociateImageBufferEventsI3D_ovr15;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; var pEvent: IntPtr; pAddress: pointer; pSize: array of UInt32; count: UInt32): UInt32 := z_AssociateImageBufferEventsI3D_ovr15(hDC, pEvent, pAddress, pSize, count);
private static function _z_AssociateImageBufferEventsI3D_ovr16(hDC: GDI_DC; var pEvent: IntPtr; pAddress: pointer; var pSize: UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public static z_AssociateImageBufferEventsI3D_ovr16 := _z_AssociateImageBufferEventsI3D_ovr16;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; var pEvent: IntPtr; pAddress: pointer; var pSize: UInt32; count: UInt32): UInt32 := z_AssociateImageBufferEventsI3D_ovr16(hDC, pEvent, pAddress, pSize, count);
private static function _z_AssociateImageBufferEventsI3D_ovr17(hDC: GDI_DC; var pEvent: IntPtr; pAddress: pointer; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public static z_AssociateImageBufferEventsI3D_ovr17 := _z_AssociateImageBufferEventsI3D_ovr17;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; var pEvent: IntPtr; pAddress: pointer; pSize: IntPtr; count: UInt32): UInt32 := z_AssociateImageBufferEventsI3D_ovr17(hDC, pEvent, pAddress, pSize, count);
private static function _z_AssociateImageBufferEventsI3D_ovr18(hDC: GDI_DC; pEvent: pointer; [MarshalAs(UnmanagedType.LPArray)] pAddress: array of IntPtr; [MarshalAs(UnmanagedType.LPArray)] pSize: array of UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public static z_AssociateImageBufferEventsI3D_ovr18 := _z_AssociateImageBufferEventsI3D_ovr18;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: pointer; pAddress: array of IntPtr; pSize: array of UInt32; count: UInt32): UInt32 := z_AssociateImageBufferEventsI3D_ovr18(hDC, pEvent, pAddress, pSize, count);
private static function _z_AssociateImageBufferEventsI3D_ovr19(hDC: GDI_DC; pEvent: pointer; [MarshalAs(UnmanagedType.LPArray)] pAddress: array of IntPtr; var pSize: UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public static z_AssociateImageBufferEventsI3D_ovr19 := _z_AssociateImageBufferEventsI3D_ovr19;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: pointer; pAddress: array of IntPtr; var pSize: UInt32; count: UInt32): UInt32 := z_AssociateImageBufferEventsI3D_ovr19(hDC, pEvent, pAddress, pSize, count);
private static function _z_AssociateImageBufferEventsI3D_ovr20(hDC: GDI_DC; pEvent: pointer; [MarshalAs(UnmanagedType.LPArray)] pAddress: array of IntPtr; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public static z_AssociateImageBufferEventsI3D_ovr20 := _z_AssociateImageBufferEventsI3D_ovr20;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: pointer; pAddress: array of IntPtr; pSize: IntPtr; count: UInt32): UInt32 := z_AssociateImageBufferEventsI3D_ovr20(hDC, pEvent, pAddress, pSize, count);
private static function _z_AssociateImageBufferEventsI3D_ovr21(hDC: GDI_DC; pEvent: pointer; var pAddress: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pSize: array of UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public static z_AssociateImageBufferEventsI3D_ovr21 := _z_AssociateImageBufferEventsI3D_ovr21;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: pointer; var pAddress: IntPtr; pSize: array of UInt32; count: UInt32): UInt32 := z_AssociateImageBufferEventsI3D_ovr21(hDC, pEvent, pAddress, pSize, count);
private static function _z_AssociateImageBufferEventsI3D_ovr22(hDC: GDI_DC; pEvent: pointer; var pAddress: IntPtr; var pSize: UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public static z_AssociateImageBufferEventsI3D_ovr22 := _z_AssociateImageBufferEventsI3D_ovr22;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: pointer; var pAddress: IntPtr; var pSize: UInt32; count: UInt32): UInt32 := z_AssociateImageBufferEventsI3D_ovr22(hDC, pEvent, pAddress, pSize, count);
private static function _z_AssociateImageBufferEventsI3D_ovr23(hDC: GDI_DC; pEvent: pointer; var pAddress: IntPtr; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public static z_AssociateImageBufferEventsI3D_ovr23 := _z_AssociateImageBufferEventsI3D_ovr23;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: pointer; var pAddress: IntPtr; pSize: IntPtr; count: UInt32): UInt32 := z_AssociateImageBufferEventsI3D_ovr23(hDC, pEvent, pAddress, pSize, count);
private static function _z_AssociateImageBufferEventsI3D_ovr24(hDC: GDI_DC; pEvent: pointer; pAddress: pointer; [MarshalAs(UnmanagedType.LPArray)] pSize: array of UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public static z_AssociateImageBufferEventsI3D_ovr24 := _z_AssociateImageBufferEventsI3D_ovr24;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: pointer; pAddress: pointer; pSize: array of UInt32; count: UInt32): UInt32 := z_AssociateImageBufferEventsI3D_ovr24(hDC, pEvent, pAddress, pSize, count);
private static function _z_AssociateImageBufferEventsI3D_ovr25(hDC: GDI_DC; pEvent: pointer; pAddress: pointer; var pSize: UInt32; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public static z_AssociateImageBufferEventsI3D_ovr25 := _z_AssociateImageBufferEventsI3D_ovr25;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: pointer; pAddress: pointer; var pSize: UInt32; count: UInt32): UInt32 := z_AssociateImageBufferEventsI3D_ovr25(hDC, pEvent, pAddress, pSize, count);
private static function _z_AssociateImageBufferEventsI3D_ovr26(hDC: GDI_DC; pEvent: pointer; pAddress: pointer; pSize: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglAssociateImageBufferEventsI3D';
public static z_AssociateImageBufferEventsI3D_ovr26 := _z_AssociateImageBufferEventsI3D_ovr26;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AssociateImageBufferEventsI3D(hDC: GDI_DC; pEvent: pointer; pAddress: pointer; pSize: IntPtr; count: UInt32): UInt32 := z_AssociateImageBufferEventsI3D_ovr26(hDC, pEvent, pAddress, pSize, count);
private static function _z_ReleaseImageBufferEventsI3D_ovr0(hDC: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] pAddress: array of IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglReleaseImageBufferEventsI3D';
public static z_ReleaseImageBufferEventsI3D_ovr0 := _z_ReleaseImageBufferEventsI3D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleaseImageBufferEventsI3D(hDC: GDI_DC; pAddress: array of IntPtr; count: UInt32): UInt32 := z_ReleaseImageBufferEventsI3D_ovr0(hDC, pAddress, count);
private static function _z_ReleaseImageBufferEventsI3D_ovr1(hDC: GDI_DC; var pAddress: IntPtr; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglReleaseImageBufferEventsI3D';
public static z_ReleaseImageBufferEventsI3D_ovr1 := _z_ReleaseImageBufferEventsI3D_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleaseImageBufferEventsI3D(hDC: GDI_DC; var pAddress: IntPtr; count: UInt32): UInt32 := z_ReleaseImageBufferEventsI3D_ovr1(hDC, pAddress, count);
private static function _z_ReleaseImageBufferEventsI3D_ovr2(hDC: GDI_DC; pAddress: pointer; count: UInt32): UInt32;
external 'opengl32.dll' name 'wglReleaseImageBufferEventsI3D';
public static z_ReleaseImageBufferEventsI3D_ovr2 := _z_ReleaseImageBufferEventsI3D_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleaseImageBufferEventsI3D(hDC: GDI_DC; pAddress: pointer; count: UInt32): UInt32 := z_ReleaseImageBufferEventsI3D_ovr2(hDC, pAddress, count);
end;
wglSwapFrameLockI3D = static class
private static function _z_EnableFrameLockI3D_ovr0: UInt32;
external 'opengl32.dll' name 'wglEnableFrameLockI3D';
public static z_EnableFrameLockI3D_ovr0: function: UInt32 := _z_EnableFrameLockI3D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnableFrameLockI3D: UInt32 := z_EnableFrameLockI3D_ovr0;
private static function _z_DisableFrameLockI3D_ovr0: UInt32;
external 'opengl32.dll' name 'wglDisableFrameLockI3D';
public static z_DisableFrameLockI3D_ovr0: function: UInt32 := _z_DisableFrameLockI3D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DisableFrameLockI3D: UInt32 := z_DisableFrameLockI3D_ovr0;
private static function _z_IsEnabledFrameLockI3D_ovr0([MarshalAs(UnmanagedType.LPArray)] pFlag: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglIsEnabledFrameLockI3D';
public static z_IsEnabledFrameLockI3D_ovr0 := _z_IsEnabledFrameLockI3D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function IsEnabledFrameLockI3D(pFlag: array of UInt32): UInt32 := z_IsEnabledFrameLockI3D_ovr0(pFlag);
private static function _z_IsEnabledFrameLockI3D_ovr1(var pFlag: UInt32): UInt32;
external 'opengl32.dll' name 'wglIsEnabledFrameLockI3D';
public static z_IsEnabledFrameLockI3D_ovr1 := _z_IsEnabledFrameLockI3D_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function IsEnabledFrameLockI3D(var pFlag: UInt32): UInt32 := z_IsEnabledFrameLockI3D_ovr1(pFlag);
private static function _z_IsEnabledFrameLockI3D_ovr2(pFlag: IntPtr): UInt32;
external 'opengl32.dll' name 'wglIsEnabledFrameLockI3D';
public static z_IsEnabledFrameLockI3D_ovr2 := _z_IsEnabledFrameLockI3D_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function IsEnabledFrameLockI3D(pFlag: IntPtr): UInt32 := z_IsEnabledFrameLockI3D_ovr2(pFlag);
private static function _z_QueryFrameLockMasterI3D_ovr0([MarshalAs(UnmanagedType.LPArray)] pFlag: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglQueryFrameLockMasterI3D';
public static z_QueryFrameLockMasterI3D_ovr0 := _z_QueryFrameLockMasterI3D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameLockMasterI3D(pFlag: array of UInt32): UInt32 := z_QueryFrameLockMasterI3D_ovr0(pFlag);
private static function _z_QueryFrameLockMasterI3D_ovr1(var pFlag: UInt32): UInt32;
external 'opengl32.dll' name 'wglQueryFrameLockMasterI3D';
public static z_QueryFrameLockMasterI3D_ovr1 := _z_QueryFrameLockMasterI3D_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameLockMasterI3D(var pFlag: UInt32): UInt32 := z_QueryFrameLockMasterI3D_ovr1(pFlag);
private static function _z_QueryFrameLockMasterI3D_ovr2(pFlag: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameLockMasterI3D';
public static z_QueryFrameLockMasterI3D_ovr2 := _z_QueryFrameLockMasterI3D_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameLockMasterI3D(pFlag: IntPtr): UInt32 := z_QueryFrameLockMasterI3D_ovr2(pFlag);
end;
wglSwapFrameUsageI3D = static class
private static function _z_GetFrameUsageI3D_ovr0([MarshalAs(UnmanagedType.LPArray)] pUsage: array of single): UInt32;
external 'opengl32.dll' name 'wglGetFrameUsageI3D';
public static z_GetFrameUsageI3D_ovr0 := _z_GetFrameUsageI3D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetFrameUsageI3D(pUsage: array of single): UInt32 := z_GetFrameUsageI3D_ovr0(pUsage);
private static function _z_GetFrameUsageI3D_ovr1(var pUsage: single): UInt32;
external 'opengl32.dll' name 'wglGetFrameUsageI3D';
public static z_GetFrameUsageI3D_ovr1 := _z_GetFrameUsageI3D_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetFrameUsageI3D(var pUsage: single): UInt32 := z_GetFrameUsageI3D_ovr1(pUsage);
private static function _z_GetFrameUsageI3D_ovr2(pUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetFrameUsageI3D';
public static z_GetFrameUsageI3D_ovr2 := _z_GetFrameUsageI3D_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetFrameUsageI3D(pUsage: IntPtr): UInt32 := z_GetFrameUsageI3D_ovr2(pUsage);
private static function _z_BeginFrameTrackingI3D_ovr0: UInt32;
external 'opengl32.dll' name 'wglBeginFrameTrackingI3D';
public static z_BeginFrameTrackingI3D_ovr0: function: UInt32 := _z_BeginFrameTrackingI3D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function BeginFrameTrackingI3D: UInt32 := z_BeginFrameTrackingI3D_ovr0;
private static function _z_EndFrameTrackingI3D_ovr0: UInt32;
external 'opengl32.dll' name 'wglEndFrameTrackingI3D';
public static z_EndFrameTrackingI3D_ovr0: function: UInt32 := _z_EndFrameTrackingI3D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EndFrameTrackingI3D: UInt32 := z_EndFrameTrackingI3D_ovr0;
private static function _z_QueryFrameTrackingI3D_ovr0([MarshalAs(UnmanagedType.LPArray)] pFrameCount: array of UInt32; [MarshalAs(UnmanagedType.LPArray)] pMissedFrames: array of UInt32; [MarshalAs(UnmanagedType.LPArray)] pLastMissedUsage: array of single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public static z_QueryFrameTrackingI3D_ovr0 := _z_QueryFrameTrackingI3D_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: array of UInt32; pMissedFrames: array of UInt32; pLastMissedUsage: array of single): UInt32 := z_QueryFrameTrackingI3D_ovr0(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function _z_QueryFrameTrackingI3D_ovr1([MarshalAs(UnmanagedType.LPArray)] pFrameCount: array of UInt32; [MarshalAs(UnmanagedType.LPArray)] pMissedFrames: array of UInt32; var pLastMissedUsage: single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public static z_QueryFrameTrackingI3D_ovr1 := _z_QueryFrameTrackingI3D_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: array of UInt32; pMissedFrames: array of UInt32; var pLastMissedUsage: single): UInt32 := z_QueryFrameTrackingI3D_ovr1(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function _z_QueryFrameTrackingI3D_ovr2([MarshalAs(UnmanagedType.LPArray)] pFrameCount: array of UInt32; [MarshalAs(UnmanagedType.LPArray)] pMissedFrames: array of UInt32; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public static z_QueryFrameTrackingI3D_ovr2 := _z_QueryFrameTrackingI3D_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: array of UInt32; pMissedFrames: array of UInt32; pLastMissedUsage: IntPtr): UInt32 := z_QueryFrameTrackingI3D_ovr2(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function _z_QueryFrameTrackingI3D_ovr3([MarshalAs(UnmanagedType.LPArray)] pFrameCount: array of UInt32; var pMissedFrames: UInt32; [MarshalAs(UnmanagedType.LPArray)] pLastMissedUsage: array of single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public static z_QueryFrameTrackingI3D_ovr3 := _z_QueryFrameTrackingI3D_ovr3;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: array of UInt32; var pMissedFrames: UInt32; pLastMissedUsage: array of single): UInt32 := z_QueryFrameTrackingI3D_ovr3(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function _z_QueryFrameTrackingI3D_ovr4([MarshalAs(UnmanagedType.LPArray)] pFrameCount: array of UInt32; var pMissedFrames: UInt32; var pLastMissedUsage: single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public static z_QueryFrameTrackingI3D_ovr4 := _z_QueryFrameTrackingI3D_ovr4;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: array of UInt32; var pMissedFrames: UInt32; var pLastMissedUsage: single): UInt32 := z_QueryFrameTrackingI3D_ovr4(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function _z_QueryFrameTrackingI3D_ovr5([MarshalAs(UnmanagedType.LPArray)] pFrameCount: array of UInt32; var pMissedFrames: UInt32; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public static z_QueryFrameTrackingI3D_ovr5 := _z_QueryFrameTrackingI3D_ovr5;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: array of UInt32; var pMissedFrames: UInt32; pLastMissedUsage: IntPtr): UInt32 := z_QueryFrameTrackingI3D_ovr5(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function _z_QueryFrameTrackingI3D_ovr6([MarshalAs(UnmanagedType.LPArray)] pFrameCount: array of UInt32; pMissedFrames: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pLastMissedUsage: array of single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public static z_QueryFrameTrackingI3D_ovr6 := _z_QueryFrameTrackingI3D_ovr6;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: array of UInt32; pMissedFrames: IntPtr; pLastMissedUsage: array of single): UInt32 := z_QueryFrameTrackingI3D_ovr6(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function _z_QueryFrameTrackingI3D_ovr7([MarshalAs(UnmanagedType.LPArray)] pFrameCount: array of UInt32; pMissedFrames: IntPtr; var pLastMissedUsage: single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public static z_QueryFrameTrackingI3D_ovr7 := _z_QueryFrameTrackingI3D_ovr7;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: array of UInt32; pMissedFrames: IntPtr; var pLastMissedUsage: single): UInt32 := z_QueryFrameTrackingI3D_ovr7(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function _z_QueryFrameTrackingI3D_ovr8([MarshalAs(UnmanagedType.LPArray)] pFrameCount: array of UInt32; pMissedFrames: IntPtr; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public static z_QueryFrameTrackingI3D_ovr8 := _z_QueryFrameTrackingI3D_ovr8;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: array of UInt32; pMissedFrames: IntPtr; pLastMissedUsage: IntPtr): UInt32 := z_QueryFrameTrackingI3D_ovr8(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function _z_QueryFrameTrackingI3D_ovr9(var pFrameCount: UInt32; [MarshalAs(UnmanagedType.LPArray)] pMissedFrames: array of UInt32; [MarshalAs(UnmanagedType.LPArray)] pLastMissedUsage: array of single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public static z_QueryFrameTrackingI3D_ovr9 := _z_QueryFrameTrackingI3D_ovr9;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(var pFrameCount: UInt32; pMissedFrames: array of UInt32; pLastMissedUsage: array of single): UInt32 := z_QueryFrameTrackingI3D_ovr9(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function _z_QueryFrameTrackingI3D_ovr10(var pFrameCount: UInt32; [MarshalAs(UnmanagedType.LPArray)] pMissedFrames: array of UInt32; var pLastMissedUsage: single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public static z_QueryFrameTrackingI3D_ovr10 := _z_QueryFrameTrackingI3D_ovr10;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(var pFrameCount: UInt32; pMissedFrames: array of UInt32; var pLastMissedUsage: single): UInt32 := z_QueryFrameTrackingI3D_ovr10(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function _z_QueryFrameTrackingI3D_ovr11(var pFrameCount: UInt32; [MarshalAs(UnmanagedType.LPArray)] pMissedFrames: array of UInt32; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public static z_QueryFrameTrackingI3D_ovr11 := _z_QueryFrameTrackingI3D_ovr11;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(var pFrameCount: UInt32; pMissedFrames: array of UInt32; pLastMissedUsage: IntPtr): UInt32 := z_QueryFrameTrackingI3D_ovr11(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function _z_QueryFrameTrackingI3D_ovr12(var pFrameCount: UInt32; var pMissedFrames: UInt32; [MarshalAs(UnmanagedType.LPArray)] pLastMissedUsage: array of single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public static z_QueryFrameTrackingI3D_ovr12 := _z_QueryFrameTrackingI3D_ovr12;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(var pFrameCount: UInt32; var pMissedFrames: UInt32; pLastMissedUsage: array of single): UInt32 := z_QueryFrameTrackingI3D_ovr12(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function _z_QueryFrameTrackingI3D_ovr13(var pFrameCount: UInt32; var pMissedFrames: UInt32; var pLastMissedUsage: single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public static z_QueryFrameTrackingI3D_ovr13 := _z_QueryFrameTrackingI3D_ovr13;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(var pFrameCount: UInt32; var pMissedFrames: UInt32; var pLastMissedUsage: single): UInt32 := z_QueryFrameTrackingI3D_ovr13(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function _z_QueryFrameTrackingI3D_ovr14(var pFrameCount: UInt32; var pMissedFrames: UInt32; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public static z_QueryFrameTrackingI3D_ovr14 := _z_QueryFrameTrackingI3D_ovr14;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(var pFrameCount: UInt32; var pMissedFrames: UInt32; pLastMissedUsage: IntPtr): UInt32 := z_QueryFrameTrackingI3D_ovr14(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function _z_QueryFrameTrackingI3D_ovr15(var pFrameCount: UInt32; pMissedFrames: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pLastMissedUsage: array of single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public static z_QueryFrameTrackingI3D_ovr15 := _z_QueryFrameTrackingI3D_ovr15;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(var pFrameCount: UInt32; pMissedFrames: IntPtr; pLastMissedUsage: array of single): UInt32 := z_QueryFrameTrackingI3D_ovr15(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function _z_QueryFrameTrackingI3D_ovr16(var pFrameCount: UInt32; pMissedFrames: IntPtr; var pLastMissedUsage: single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public static z_QueryFrameTrackingI3D_ovr16 := _z_QueryFrameTrackingI3D_ovr16;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(var pFrameCount: UInt32; pMissedFrames: IntPtr; var pLastMissedUsage: single): UInt32 := z_QueryFrameTrackingI3D_ovr16(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function _z_QueryFrameTrackingI3D_ovr17(var pFrameCount: UInt32; pMissedFrames: IntPtr; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public static z_QueryFrameTrackingI3D_ovr17 := _z_QueryFrameTrackingI3D_ovr17;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(var pFrameCount: UInt32; pMissedFrames: IntPtr; pLastMissedUsage: IntPtr): UInt32 := z_QueryFrameTrackingI3D_ovr17(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function _z_QueryFrameTrackingI3D_ovr18(pFrameCount: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pMissedFrames: array of UInt32; [MarshalAs(UnmanagedType.LPArray)] pLastMissedUsage: array of single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public static z_QueryFrameTrackingI3D_ovr18 := _z_QueryFrameTrackingI3D_ovr18;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: IntPtr; pMissedFrames: array of UInt32; pLastMissedUsage: array of single): UInt32 := z_QueryFrameTrackingI3D_ovr18(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function _z_QueryFrameTrackingI3D_ovr19(pFrameCount: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pMissedFrames: array of UInt32; var pLastMissedUsage: single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public static z_QueryFrameTrackingI3D_ovr19 := _z_QueryFrameTrackingI3D_ovr19;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: IntPtr; pMissedFrames: array of UInt32; var pLastMissedUsage: single): UInt32 := z_QueryFrameTrackingI3D_ovr19(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function _z_QueryFrameTrackingI3D_ovr20(pFrameCount: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pMissedFrames: array of UInt32; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public static z_QueryFrameTrackingI3D_ovr20 := _z_QueryFrameTrackingI3D_ovr20;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: IntPtr; pMissedFrames: array of UInt32; pLastMissedUsage: IntPtr): UInt32 := z_QueryFrameTrackingI3D_ovr20(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function _z_QueryFrameTrackingI3D_ovr21(pFrameCount: IntPtr; var pMissedFrames: UInt32; [MarshalAs(UnmanagedType.LPArray)] pLastMissedUsage: array of single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public static z_QueryFrameTrackingI3D_ovr21 := _z_QueryFrameTrackingI3D_ovr21;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: IntPtr; var pMissedFrames: UInt32; pLastMissedUsage: array of single): UInt32 := z_QueryFrameTrackingI3D_ovr21(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function _z_QueryFrameTrackingI3D_ovr22(pFrameCount: IntPtr; var pMissedFrames: UInt32; var pLastMissedUsage: single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public static z_QueryFrameTrackingI3D_ovr22 := _z_QueryFrameTrackingI3D_ovr22;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: IntPtr; var pMissedFrames: UInt32; var pLastMissedUsage: single): UInt32 := z_QueryFrameTrackingI3D_ovr22(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function _z_QueryFrameTrackingI3D_ovr23(pFrameCount: IntPtr; var pMissedFrames: UInt32; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public static z_QueryFrameTrackingI3D_ovr23 := _z_QueryFrameTrackingI3D_ovr23;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: IntPtr; var pMissedFrames: UInt32; pLastMissedUsage: IntPtr): UInt32 := z_QueryFrameTrackingI3D_ovr23(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function _z_QueryFrameTrackingI3D_ovr24(pFrameCount: IntPtr; pMissedFrames: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pLastMissedUsage: array of single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public static z_QueryFrameTrackingI3D_ovr24 := _z_QueryFrameTrackingI3D_ovr24;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: IntPtr; pMissedFrames: IntPtr; pLastMissedUsage: array of single): UInt32 := z_QueryFrameTrackingI3D_ovr24(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function _z_QueryFrameTrackingI3D_ovr25(pFrameCount: IntPtr; pMissedFrames: IntPtr; var pLastMissedUsage: single): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public static z_QueryFrameTrackingI3D_ovr25 := _z_QueryFrameTrackingI3D_ovr25;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: IntPtr; pMissedFrames: IntPtr; var pLastMissedUsage: single): UInt32 := z_QueryFrameTrackingI3D_ovr25(pFrameCount, pMissedFrames, pLastMissedUsage);
private static function _z_QueryFrameTrackingI3D_ovr26(pFrameCount: IntPtr; pMissedFrames: IntPtr; pLastMissedUsage: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameTrackingI3D';
public static z_QueryFrameTrackingI3D_ovr26 := _z_QueryFrameTrackingI3D_ovr26;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameTrackingI3D(pFrameCount: IntPtr; pMissedFrames: IntPtr; pLastMissedUsage: IntPtr): UInt32 := z_QueryFrameTrackingI3D_ovr26(pFrameCount, pMissedFrames, pLastMissedUsage);
end;
wglCopyImageNV = static class
private static function _z_CopyImageSubDataNV_ovr0(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 static z_CopyImageSubDataNV_ovr0 := _z_CopyImageSubDataNV_ovr0;
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_ovr0(hSrcRC, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, hDstRC, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth);
end;
wglDelayBeforeSwapNV = static class
private static function _z_DelayBeforeSwapNV_ovr0(hDC: GDI_DC; seconds: single): UInt32;
external 'opengl32.dll' name 'wglDelayBeforeSwapNV';
public static z_DelayBeforeSwapNV_ovr0 := _z_DelayBeforeSwapNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DelayBeforeSwapNV(hDC: GDI_DC; seconds: single): UInt32 := z_DelayBeforeSwapNV_ovr0(hDC, seconds);
end;
wglDXInteropNV = static class
private static function _z_DXSetResourceShareHandleNV_ovr0(dxObject: IntPtr; shareHandle: IntPtr): UInt32;
external 'opengl32.dll' name 'wglDXSetResourceShareHandleNV';
public static z_DXSetResourceShareHandleNV_ovr0 := _z_DXSetResourceShareHandleNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DXSetResourceShareHandleNV(dxObject: IntPtr; shareHandle: IntPtr): UInt32 := z_DXSetResourceShareHandleNV_ovr0(dxObject, shareHandle);
private static function _z_DXOpenDeviceNV_ovr0(dxDevice: IntPtr): IntPtr;
external 'opengl32.dll' name 'wglDXOpenDeviceNV';
public static z_DXOpenDeviceNV_ovr0 := _z_DXOpenDeviceNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DXOpenDeviceNV(dxDevice: IntPtr): IntPtr := z_DXOpenDeviceNV_ovr0(dxDevice);
private static function _z_DXCloseDeviceNV_ovr0(hDevice: IntPtr): UInt32;
external 'opengl32.dll' name 'wglDXCloseDeviceNV';
public static z_DXCloseDeviceNV_ovr0 := _z_DXCloseDeviceNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DXCloseDeviceNV(hDevice: IntPtr): UInt32 := z_DXCloseDeviceNV_ovr0(hDevice);
private static function _z_DXRegisterObjectNV_ovr0(hDevice: IntPtr; dxObject: IntPtr; name: UInt32; &type: DummyEnum; access: DummyEnum): IntPtr;
external 'opengl32.dll' name 'wglDXRegisterObjectNV';
public static z_DXRegisterObjectNV_ovr0 := _z_DXRegisterObjectNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DXRegisterObjectNV(hDevice: IntPtr; dxObject: IntPtr; name: UInt32; &type: DummyEnum; access: DummyEnum): IntPtr := z_DXRegisterObjectNV_ovr0(hDevice, dxObject, name, &type, access);
private static function _z_DXUnregisterObjectNV_ovr0(hDevice: IntPtr; hObject: IntPtr): UInt32;
external 'opengl32.dll' name 'wglDXUnregisterObjectNV';
public static z_DXUnregisterObjectNV_ovr0 := _z_DXUnregisterObjectNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DXUnregisterObjectNV(hDevice: IntPtr; hObject: IntPtr): UInt32 := z_DXUnregisterObjectNV_ovr0(hDevice, hObject);
private static function _z_DXObjectAccessNV_ovr0(hObject: IntPtr; access: DummyEnum): UInt32;
external 'opengl32.dll' name 'wglDXObjectAccessNV';
public static z_DXObjectAccessNV_ovr0 := _z_DXObjectAccessNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DXObjectAccessNV(hObject: IntPtr; access: DummyEnum): UInt32 := z_DXObjectAccessNV_ovr0(hObject, access);
private static function _z_DXLockObjectsNV_ovr0(hDevice: IntPtr; count: Int32; [MarshalAs(UnmanagedType.LPArray)] hObjects: array of IntPtr): UInt32;
external 'opengl32.dll' name 'wglDXLockObjectsNV';
public static z_DXLockObjectsNV_ovr0 := _z_DXLockObjectsNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DXLockObjectsNV(hDevice: IntPtr; count: Int32; hObjects: array of IntPtr): UInt32 := z_DXLockObjectsNV_ovr0(hDevice, count, hObjects);
private static function _z_DXLockObjectsNV_ovr1(hDevice: IntPtr; count: Int32; var hObjects: IntPtr): UInt32;
external 'opengl32.dll' name 'wglDXLockObjectsNV';
public static z_DXLockObjectsNV_ovr1 := _z_DXLockObjectsNV_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DXLockObjectsNV(hDevice: IntPtr; count: Int32; var hObjects: IntPtr): UInt32 := z_DXLockObjectsNV_ovr1(hDevice, count, hObjects);
private static function _z_DXLockObjectsNV_ovr2(hDevice: IntPtr; count: Int32; hObjects: pointer): UInt32;
external 'opengl32.dll' name 'wglDXLockObjectsNV';
public static z_DXLockObjectsNV_ovr2 := _z_DXLockObjectsNV_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DXLockObjectsNV(hDevice: IntPtr; count: Int32; hObjects: pointer): UInt32 := z_DXLockObjectsNV_ovr2(hDevice, count, hObjects);
private static function _z_DXUnlockObjectsNV_ovr0(hDevice: IntPtr; count: Int32; [MarshalAs(UnmanagedType.LPArray)] hObjects: array of IntPtr): UInt32;
external 'opengl32.dll' name 'wglDXUnlockObjectsNV';
public static z_DXUnlockObjectsNV_ovr0 := _z_DXUnlockObjectsNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DXUnlockObjectsNV(hDevice: IntPtr; count: Int32; hObjects: array of IntPtr): UInt32 := z_DXUnlockObjectsNV_ovr0(hDevice, count, hObjects);
private static function _z_DXUnlockObjectsNV_ovr1(hDevice: IntPtr; count: Int32; var hObjects: IntPtr): UInt32;
external 'opengl32.dll' name 'wglDXUnlockObjectsNV';
public static z_DXUnlockObjectsNV_ovr1 := _z_DXUnlockObjectsNV_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DXUnlockObjectsNV(hDevice: IntPtr; count: Int32; var hObjects: IntPtr): UInt32 := z_DXUnlockObjectsNV_ovr1(hDevice, count, hObjects);
private static function _z_DXUnlockObjectsNV_ovr2(hDevice: IntPtr; count: Int32; hObjects: pointer): UInt32;
external 'opengl32.dll' name 'wglDXUnlockObjectsNV';
public static z_DXUnlockObjectsNV_ovr2 := _z_DXUnlockObjectsNV_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DXUnlockObjectsNV(hDevice: IntPtr; count: Int32; hObjects: pointer): UInt32 := z_DXUnlockObjectsNV_ovr2(hDevice, count, hObjects);
end;
wglGpuAffinityNV = static class
private static function _z_EnumGpusNV_ovr0(iGpuIndex: UInt32; [MarshalAs(UnmanagedType.LPArray)] phGpu: array of HGPUNV): UInt32;
external 'opengl32.dll' name 'wglEnumGpusNV';
public static z_EnumGpusNV_ovr0 := _z_EnumGpusNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnumGpusNV(iGpuIndex: UInt32; phGpu: array of HGPUNV): UInt32 := z_EnumGpusNV_ovr0(iGpuIndex, phGpu);
private static function _z_EnumGpusNV_ovr1(iGpuIndex: UInt32; var phGpu: HGPUNV): UInt32;
external 'opengl32.dll' name 'wglEnumGpusNV';
public static z_EnumGpusNV_ovr1 := _z_EnumGpusNV_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnumGpusNV(iGpuIndex: UInt32; var phGpu: HGPUNV): UInt32 := z_EnumGpusNV_ovr1(iGpuIndex, phGpu);
private static function _z_EnumGpusNV_ovr2(iGpuIndex: UInt32; phGpu: IntPtr): UInt32;
external 'opengl32.dll' name 'wglEnumGpusNV';
public static z_EnumGpusNV_ovr2 := _z_EnumGpusNV_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnumGpusNV(iGpuIndex: UInt32; phGpu: IntPtr): UInt32 := z_EnumGpusNV_ovr2(iGpuIndex, phGpu);
private static function _z_EnumGpuDevicesNV_ovr0(hGpu: HGPUNV; iDeviceIndex: UInt32; lpGpuDevice: PGPU_DEVICE): UInt32;
external 'opengl32.dll' name 'wglEnumGpuDevicesNV';
public static z_EnumGpuDevicesNV_ovr0 := _z_EnumGpuDevicesNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnumGpuDevicesNV(hGpu: HGPUNV; iDeviceIndex: UInt32; lpGpuDevice: PGPU_DEVICE): UInt32 := z_EnumGpuDevicesNV_ovr0(hGpu, iDeviceIndex, lpGpuDevice);
private static function _z_CreateAffinityDCNV_ovr0([MarshalAs(UnmanagedType.LPArray)] phGpuList: array of HGPUNV): GDI_DC;
external 'opengl32.dll' name 'wglCreateAffinityDCNV';
public static z_CreateAffinityDCNV_ovr0 := _z_CreateAffinityDCNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateAffinityDCNV(phGpuList: array of HGPUNV): GDI_DC := z_CreateAffinityDCNV_ovr0(phGpuList);
private static function _z_CreateAffinityDCNV_ovr1(var phGpuList: HGPUNV): GDI_DC;
external 'opengl32.dll' name 'wglCreateAffinityDCNV';
public static z_CreateAffinityDCNV_ovr1 := _z_CreateAffinityDCNV_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateAffinityDCNV(var phGpuList: HGPUNV): GDI_DC := z_CreateAffinityDCNV_ovr1(phGpuList);
private static function _z_CreateAffinityDCNV_ovr2(phGpuList: IntPtr): GDI_DC;
external 'opengl32.dll' name 'wglCreateAffinityDCNV';
public static z_CreateAffinityDCNV_ovr2 := _z_CreateAffinityDCNV_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function CreateAffinityDCNV(phGpuList: IntPtr): GDI_DC := z_CreateAffinityDCNV_ovr2(phGpuList);
private static function _z_EnumGpusFromAffinityDCNV_ovr0(hAffinityDC: GDI_DC; iGpuIndex: UInt32; [MarshalAs(UnmanagedType.LPArray)] hGpu: array of HGPUNV): UInt32;
external 'opengl32.dll' name 'wglEnumGpusFromAffinityDCNV';
public static z_EnumGpusFromAffinityDCNV_ovr0 := _z_EnumGpusFromAffinityDCNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnumGpusFromAffinityDCNV(hAffinityDC: GDI_DC; iGpuIndex: UInt32; hGpu: array of HGPUNV): UInt32 := z_EnumGpusFromAffinityDCNV_ovr0(hAffinityDC, iGpuIndex, hGpu);
private static function _z_EnumGpusFromAffinityDCNV_ovr1(hAffinityDC: GDI_DC; iGpuIndex: UInt32; var hGpu: HGPUNV): UInt32;
external 'opengl32.dll' name 'wglEnumGpusFromAffinityDCNV';
public static z_EnumGpusFromAffinityDCNV_ovr1 := _z_EnumGpusFromAffinityDCNV_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnumGpusFromAffinityDCNV(hAffinityDC: GDI_DC; iGpuIndex: UInt32; var hGpu: HGPUNV): UInt32 := z_EnumGpusFromAffinityDCNV_ovr1(hAffinityDC, iGpuIndex, hGpu);
private static function _z_EnumGpusFromAffinityDCNV_ovr2(hAffinityDC: GDI_DC; iGpuIndex: UInt32; hGpu: IntPtr): UInt32;
external 'opengl32.dll' name 'wglEnumGpusFromAffinityDCNV';
public static z_EnumGpusFromAffinityDCNV_ovr2 := _z_EnumGpusFromAffinityDCNV_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnumGpusFromAffinityDCNV(hAffinityDC: GDI_DC; iGpuIndex: UInt32; hGpu: IntPtr): UInt32 := z_EnumGpusFromAffinityDCNV_ovr2(hAffinityDC, iGpuIndex, hGpu);
private static function _z_DeleteDCNV_ovr0(hdc: GDI_DC): UInt32;
external 'opengl32.dll' name 'wglDeleteDCNV';
public static z_DeleteDCNV_ovr0 := _z_DeleteDCNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function DeleteDCNV(hdc: GDI_DC): UInt32 := z_DeleteDCNV_ovr0(hdc);
end;
wglPresentVideoNV = static class
private static function _z_EnumerateVideoDevicesNV_ovr0(hDc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] phDeviceList: array of HVIDEOOUTPUTDEVICENV): Int32;
external 'opengl32.dll' name 'wglEnumerateVideoDevicesNV';
public static z_EnumerateVideoDevicesNV_ovr0 := _z_EnumerateVideoDevicesNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnumerateVideoDevicesNV(hDc: GDI_DC; phDeviceList: array of HVIDEOOUTPUTDEVICENV): Int32 := z_EnumerateVideoDevicesNV_ovr0(hDc, phDeviceList);
private static function _z_EnumerateVideoDevicesNV_ovr1(hDc: GDI_DC; var phDeviceList: HVIDEOOUTPUTDEVICENV): Int32;
external 'opengl32.dll' name 'wglEnumerateVideoDevicesNV';
public static z_EnumerateVideoDevicesNV_ovr1 := _z_EnumerateVideoDevicesNV_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnumerateVideoDevicesNV(hDc: GDI_DC; var phDeviceList: HVIDEOOUTPUTDEVICENV): Int32 := z_EnumerateVideoDevicesNV_ovr1(hDc, phDeviceList);
private static function _z_EnumerateVideoDevicesNV_ovr2(hDc: GDI_DC; phDeviceList: IntPtr): Int32;
external 'opengl32.dll' name 'wglEnumerateVideoDevicesNV';
public static z_EnumerateVideoDevicesNV_ovr2 := _z_EnumerateVideoDevicesNV_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnumerateVideoDevicesNV(hDc: GDI_DC; phDeviceList: IntPtr): Int32 := z_EnumerateVideoDevicesNV_ovr2(hDc, phDeviceList);
private static function _z_BindVideoDeviceNV_ovr0(hDc: GDI_DC; uVideoSlot: UInt32; hVideoDevice: HVIDEOOUTPUTDEVICENV; [MarshalAs(UnmanagedType.LPArray)] piAttribList: array of Int32): UInt32;
external 'opengl32.dll' name 'wglBindVideoDeviceNV';
public static z_BindVideoDeviceNV_ovr0 := _z_BindVideoDeviceNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function BindVideoDeviceNV(hDc: GDI_DC; uVideoSlot: UInt32; hVideoDevice: HVIDEOOUTPUTDEVICENV; piAttribList: array of Int32): UInt32 := z_BindVideoDeviceNV_ovr0(hDc, uVideoSlot, hVideoDevice, piAttribList);
private static function _z_BindVideoDeviceNV_ovr1(hDc: GDI_DC; uVideoSlot: UInt32; hVideoDevice: HVIDEOOUTPUTDEVICENV; var piAttribList: Int32): UInt32;
external 'opengl32.dll' name 'wglBindVideoDeviceNV';
public static z_BindVideoDeviceNV_ovr1 := _z_BindVideoDeviceNV_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function BindVideoDeviceNV(hDc: GDI_DC; uVideoSlot: UInt32; hVideoDevice: HVIDEOOUTPUTDEVICENV; var piAttribList: Int32): UInt32 := z_BindVideoDeviceNV_ovr1(hDc, uVideoSlot, hVideoDevice, piAttribList);
private static function _z_BindVideoDeviceNV_ovr2(hDc: GDI_DC; uVideoSlot: UInt32; hVideoDevice: HVIDEOOUTPUTDEVICENV; piAttribList: IntPtr): UInt32;
external 'opengl32.dll' name 'wglBindVideoDeviceNV';
public static z_BindVideoDeviceNV_ovr2 := _z_BindVideoDeviceNV_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function BindVideoDeviceNV(hDc: GDI_DC; uVideoSlot: UInt32; hVideoDevice: HVIDEOOUTPUTDEVICENV; piAttribList: IntPtr): UInt32 := z_BindVideoDeviceNV_ovr2(hDc, uVideoSlot, hVideoDevice, piAttribList);
private static function _z_QueryCurrentContextNV_ovr0(iAttribute: Int32; [MarshalAs(UnmanagedType.LPArray)] piValue: array of Int32): UInt32;
external 'opengl32.dll' name 'wglQueryCurrentContextNV';
public static z_QueryCurrentContextNV_ovr0 := _z_QueryCurrentContextNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryCurrentContextNV(iAttribute: Int32; piValue: array of Int32): UInt32 := z_QueryCurrentContextNV_ovr0(iAttribute, piValue);
private static function _z_QueryCurrentContextNV_ovr1(iAttribute: Int32; var piValue: Int32): UInt32;
external 'opengl32.dll' name 'wglQueryCurrentContextNV';
public static z_QueryCurrentContextNV_ovr1 := _z_QueryCurrentContextNV_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryCurrentContextNV(iAttribute: Int32; var piValue: Int32): UInt32 := z_QueryCurrentContextNV_ovr1(iAttribute, piValue);
private static function _z_QueryCurrentContextNV_ovr2(iAttribute: Int32; piValue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryCurrentContextNV';
public static z_QueryCurrentContextNV_ovr2 := _z_QueryCurrentContextNV_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryCurrentContextNV(iAttribute: Int32; piValue: IntPtr): UInt32 := z_QueryCurrentContextNV_ovr2(iAttribute, piValue);
end;
wglSwapGroupNV = static class
private static function _z_JoinSwapGroupNV_ovr0(hDC: GDI_DC; group: UInt32): UInt32;
external 'opengl32.dll' name 'wglJoinSwapGroupNV';
public static z_JoinSwapGroupNV_ovr0 := _z_JoinSwapGroupNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function JoinSwapGroupNV(hDC: GDI_DC; group: UInt32): UInt32 := z_JoinSwapGroupNV_ovr0(hDC, group);
private static function _z_BindSwapBarrierNV_ovr0(group: UInt32; barrier: UInt32): UInt32;
external 'opengl32.dll' name 'wglBindSwapBarrierNV';
public static z_BindSwapBarrierNV_ovr0 := _z_BindSwapBarrierNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function BindSwapBarrierNV(group: UInt32; barrier: UInt32): UInt32 := z_BindSwapBarrierNV_ovr0(group, barrier);
private static function _z_QuerySwapGroupNV_ovr0(hDC: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] group: array of UInt32; [MarshalAs(UnmanagedType.LPArray)] barrier: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglQuerySwapGroupNV';
public static z_QuerySwapGroupNV_ovr0 := _z_QuerySwapGroupNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QuerySwapGroupNV(hDC: GDI_DC; group: array of UInt32; barrier: array of UInt32): UInt32 := z_QuerySwapGroupNV_ovr0(hDC, group, barrier);
private static function _z_QuerySwapGroupNV_ovr1(hDC: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] group: array of UInt32; var barrier: UInt32): UInt32;
external 'opengl32.dll' name 'wglQuerySwapGroupNV';
public static z_QuerySwapGroupNV_ovr1 := _z_QuerySwapGroupNV_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QuerySwapGroupNV(hDC: GDI_DC; group: array of UInt32; var barrier: UInt32): UInt32 := z_QuerySwapGroupNV_ovr1(hDC, group, barrier);
private static function _z_QuerySwapGroupNV_ovr2(hDC: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] group: array of UInt32; barrier: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQuerySwapGroupNV';
public static z_QuerySwapGroupNV_ovr2 := _z_QuerySwapGroupNV_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QuerySwapGroupNV(hDC: GDI_DC; group: array of UInt32; barrier: IntPtr): UInt32 := z_QuerySwapGroupNV_ovr2(hDC, group, barrier);
private static function _z_QuerySwapGroupNV_ovr3(hDC: GDI_DC; var group: UInt32; [MarshalAs(UnmanagedType.LPArray)] barrier: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglQuerySwapGroupNV';
public static z_QuerySwapGroupNV_ovr3 := _z_QuerySwapGroupNV_ovr3;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QuerySwapGroupNV(hDC: GDI_DC; var group: UInt32; barrier: array of UInt32): UInt32 := z_QuerySwapGroupNV_ovr3(hDC, group, barrier);
private static function _z_QuerySwapGroupNV_ovr4(hDC: GDI_DC; var group: UInt32; var barrier: UInt32): UInt32;
external 'opengl32.dll' name 'wglQuerySwapGroupNV';
public static z_QuerySwapGroupNV_ovr4 := _z_QuerySwapGroupNV_ovr4;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QuerySwapGroupNV(hDC: GDI_DC; var group: UInt32; var barrier: UInt32): UInt32 := z_QuerySwapGroupNV_ovr4(hDC, group, barrier);
private static function _z_QuerySwapGroupNV_ovr5(hDC: GDI_DC; var group: UInt32; barrier: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQuerySwapGroupNV';
public static z_QuerySwapGroupNV_ovr5 := _z_QuerySwapGroupNV_ovr5;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QuerySwapGroupNV(hDC: GDI_DC; var group: UInt32; barrier: IntPtr): UInt32 := z_QuerySwapGroupNV_ovr5(hDC, group, barrier);
private static function _z_QuerySwapGroupNV_ovr6(hDC: GDI_DC; group: IntPtr; [MarshalAs(UnmanagedType.LPArray)] barrier: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglQuerySwapGroupNV';
public static z_QuerySwapGroupNV_ovr6 := _z_QuerySwapGroupNV_ovr6;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QuerySwapGroupNV(hDC: GDI_DC; group: IntPtr; barrier: array of UInt32): UInt32 := z_QuerySwapGroupNV_ovr6(hDC, group, barrier);
private static function _z_QuerySwapGroupNV_ovr7(hDC: GDI_DC; group: IntPtr; var barrier: UInt32): UInt32;
external 'opengl32.dll' name 'wglQuerySwapGroupNV';
public static z_QuerySwapGroupNV_ovr7 := _z_QuerySwapGroupNV_ovr7;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QuerySwapGroupNV(hDC: GDI_DC; group: IntPtr; var barrier: UInt32): UInt32 := z_QuerySwapGroupNV_ovr7(hDC, group, barrier);
private static function _z_QuerySwapGroupNV_ovr8(hDC: GDI_DC; group: IntPtr; barrier: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQuerySwapGroupNV';
public static z_QuerySwapGroupNV_ovr8 := _z_QuerySwapGroupNV_ovr8;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QuerySwapGroupNV(hDC: GDI_DC; group: IntPtr; barrier: IntPtr): UInt32 := z_QuerySwapGroupNV_ovr8(hDC, group, barrier);
private static function _z_QueryMaxSwapGroupsNV_ovr0(hDC: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] maxGroups: array of UInt32; [MarshalAs(UnmanagedType.LPArray)] maxBarriers: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglQueryMaxSwapGroupsNV';
public static z_QueryMaxSwapGroupsNV_ovr0 := _z_QueryMaxSwapGroupsNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryMaxSwapGroupsNV(hDC: GDI_DC; maxGroups: array of UInt32; maxBarriers: array of UInt32): UInt32 := z_QueryMaxSwapGroupsNV_ovr0(hDC, maxGroups, maxBarriers);
private static function _z_QueryMaxSwapGroupsNV_ovr1(hDC: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] maxGroups: array of UInt32; var maxBarriers: UInt32): UInt32;
external 'opengl32.dll' name 'wglQueryMaxSwapGroupsNV';
public static z_QueryMaxSwapGroupsNV_ovr1 := _z_QueryMaxSwapGroupsNV_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryMaxSwapGroupsNV(hDC: GDI_DC; maxGroups: array of UInt32; var maxBarriers: UInt32): UInt32 := z_QueryMaxSwapGroupsNV_ovr1(hDC, maxGroups, maxBarriers);
private static function _z_QueryMaxSwapGroupsNV_ovr2(hDC: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] maxGroups: array of UInt32; maxBarriers: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryMaxSwapGroupsNV';
public static z_QueryMaxSwapGroupsNV_ovr2 := _z_QueryMaxSwapGroupsNV_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryMaxSwapGroupsNV(hDC: GDI_DC; maxGroups: array of UInt32; maxBarriers: IntPtr): UInt32 := z_QueryMaxSwapGroupsNV_ovr2(hDC, maxGroups, maxBarriers);
private static function _z_QueryMaxSwapGroupsNV_ovr3(hDC: GDI_DC; var maxGroups: UInt32; [MarshalAs(UnmanagedType.LPArray)] maxBarriers: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglQueryMaxSwapGroupsNV';
public static z_QueryMaxSwapGroupsNV_ovr3 := _z_QueryMaxSwapGroupsNV_ovr3;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryMaxSwapGroupsNV(hDC: GDI_DC; var maxGroups: UInt32; maxBarriers: array of UInt32): UInt32 := z_QueryMaxSwapGroupsNV_ovr3(hDC, maxGroups, maxBarriers);
private static function _z_QueryMaxSwapGroupsNV_ovr4(hDC: GDI_DC; var maxGroups: UInt32; var maxBarriers: UInt32): UInt32;
external 'opengl32.dll' name 'wglQueryMaxSwapGroupsNV';
public static z_QueryMaxSwapGroupsNV_ovr4 := _z_QueryMaxSwapGroupsNV_ovr4;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryMaxSwapGroupsNV(hDC: GDI_DC; var maxGroups: UInt32; var maxBarriers: UInt32): UInt32 := z_QueryMaxSwapGroupsNV_ovr4(hDC, maxGroups, maxBarriers);
private static function _z_QueryMaxSwapGroupsNV_ovr5(hDC: GDI_DC; var maxGroups: UInt32; maxBarriers: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryMaxSwapGroupsNV';
public static z_QueryMaxSwapGroupsNV_ovr5 := _z_QueryMaxSwapGroupsNV_ovr5;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryMaxSwapGroupsNV(hDC: GDI_DC; var maxGroups: UInt32; maxBarriers: IntPtr): UInt32 := z_QueryMaxSwapGroupsNV_ovr5(hDC, maxGroups, maxBarriers);
private static function _z_QueryMaxSwapGroupsNV_ovr6(hDC: GDI_DC; maxGroups: IntPtr; [MarshalAs(UnmanagedType.LPArray)] maxBarriers: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglQueryMaxSwapGroupsNV';
public static z_QueryMaxSwapGroupsNV_ovr6 := _z_QueryMaxSwapGroupsNV_ovr6;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryMaxSwapGroupsNV(hDC: GDI_DC; maxGroups: IntPtr; maxBarriers: array of UInt32): UInt32 := z_QueryMaxSwapGroupsNV_ovr6(hDC, maxGroups, maxBarriers);
private static function _z_QueryMaxSwapGroupsNV_ovr7(hDC: GDI_DC; maxGroups: IntPtr; var maxBarriers: UInt32): UInt32;
external 'opengl32.dll' name 'wglQueryMaxSwapGroupsNV';
public static z_QueryMaxSwapGroupsNV_ovr7 := _z_QueryMaxSwapGroupsNV_ovr7;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryMaxSwapGroupsNV(hDC: GDI_DC; maxGroups: IntPtr; var maxBarriers: UInt32): UInt32 := z_QueryMaxSwapGroupsNV_ovr7(hDC, maxGroups, maxBarriers);
private static function _z_QueryMaxSwapGroupsNV_ovr8(hDC: GDI_DC; maxGroups: IntPtr; maxBarriers: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryMaxSwapGroupsNV';
public static z_QueryMaxSwapGroupsNV_ovr8 := _z_QueryMaxSwapGroupsNV_ovr8;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryMaxSwapGroupsNV(hDC: GDI_DC; maxGroups: IntPtr; maxBarriers: IntPtr): UInt32 := z_QueryMaxSwapGroupsNV_ovr8(hDC, maxGroups, maxBarriers);
private static function _z_QueryFrameCountNV_ovr0(hDC: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] count: array of UInt32): UInt32;
external 'opengl32.dll' name 'wglQueryFrameCountNV';
public static z_QueryFrameCountNV_ovr0 := _z_QueryFrameCountNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameCountNV(hDC: GDI_DC; count: array of UInt32): UInt32 := z_QueryFrameCountNV_ovr0(hDC, count);
private static function _z_QueryFrameCountNV_ovr1(hDC: GDI_DC; var count: UInt32): UInt32;
external 'opengl32.dll' name 'wglQueryFrameCountNV';
public static z_QueryFrameCountNV_ovr1 := _z_QueryFrameCountNV_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameCountNV(hDC: GDI_DC; var count: UInt32): UInt32 := z_QueryFrameCountNV_ovr1(hDC, count);
private static function _z_QueryFrameCountNV_ovr2(hDC: GDI_DC; count: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryFrameCountNV';
public static z_QueryFrameCountNV_ovr2 := _z_QueryFrameCountNV_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryFrameCountNV(hDC: GDI_DC; count: IntPtr): UInt32 := z_QueryFrameCountNV_ovr2(hDC, count);
private static function _z_ResetFrameCountNV_ovr0(hDC: GDI_DC): UInt32;
external 'opengl32.dll' name 'wglResetFrameCountNV';
public static z_ResetFrameCountNV_ovr0 := _z_ResetFrameCountNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ResetFrameCountNV(hDC: GDI_DC): UInt32 := z_ResetFrameCountNV_ovr0(hDC);
end;
wglVideoCaptureNV = static class
private static function _z_BindVideoCaptureDeviceNV_ovr0(uVideoSlot: UInt32; hDevice: HVIDEOINPUTDEVICENV): UInt32;
external 'opengl32.dll' name 'wglBindVideoCaptureDeviceNV';
public static z_BindVideoCaptureDeviceNV_ovr0 := _z_BindVideoCaptureDeviceNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function BindVideoCaptureDeviceNV(uVideoSlot: UInt32; hDevice: HVIDEOINPUTDEVICENV): UInt32 := z_BindVideoCaptureDeviceNV_ovr0(uVideoSlot, hDevice);
private static function _z_EnumerateVideoCaptureDevicesNV_ovr0(hDc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] phDeviceList: array of HVIDEOINPUTDEVICENV): UInt32;
external 'opengl32.dll' name 'wglEnumerateVideoCaptureDevicesNV';
public static z_EnumerateVideoCaptureDevicesNV_ovr0 := _z_EnumerateVideoCaptureDevicesNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnumerateVideoCaptureDevicesNV(hDc: GDI_DC; phDeviceList: array of HVIDEOINPUTDEVICENV): UInt32 := z_EnumerateVideoCaptureDevicesNV_ovr0(hDc, phDeviceList);
private static function _z_EnumerateVideoCaptureDevicesNV_ovr1(hDc: GDI_DC; var phDeviceList: HVIDEOINPUTDEVICENV): UInt32;
external 'opengl32.dll' name 'wglEnumerateVideoCaptureDevicesNV';
public static z_EnumerateVideoCaptureDevicesNV_ovr1 := _z_EnumerateVideoCaptureDevicesNV_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnumerateVideoCaptureDevicesNV(hDc: GDI_DC; var phDeviceList: HVIDEOINPUTDEVICENV): UInt32 := z_EnumerateVideoCaptureDevicesNV_ovr1(hDc, phDeviceList);
private static function _z_EnumerateVideoCaptureDevicesNV_ovr2(hDc: GDI_DC; phDeviceList: IntPtr): UInt32;
external 'opengl32.dll' name 'wglEnumerateVideoCaptureDevicesNV';
public static z_EnumerateVideoCaptureDevicesNV_ovr2 := _z_EnumerateVideoCaptureDevicesNV_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function EnumerateVideoCaptureDevicesNV(hDc: GDI_DC; phDeviceList: IntPtr): UInt32 := z_EnumerateVideoCaptureDevicesNV_ovr2(hDc, phDeviceList);
private static function _z_LockVideoCaptureDeviceNV_ovr0(hDc: GDI_DC; hDevice: HVIDEOINPUTDEVICENV): UInt32;
external 'opengl32.dll' name 'wglLockVideoCaptureDeviceNV';
public static z_LockVideoCaptureDeviceNV_ovr0 := _z_LockVideoCaptureDeviceNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function LockVideoCaptureDeviceNV(hDc: GDI_DC; hDevice: HVIDEOINPUTDEVICENV): UInt32 := z_LockVideoCaptureDeviceNV_ovr0(hDc, hDevice);
private static function _z_QueryVideoCaptureDeviceNV_ovr0(hDc: GDI_DC; hDevice: HVIDEOINPUTDEVICENV; iAttribute: Int32; [MarshalAs(UnmanagedType.LPArray)] piValue: array of Int32): UInt32;
external 'opengl32.dll' name 'wglQueryVideoCaptureDeviceNV';
public static z_QueryVideoCaptureDeviceNV_ovr0 := _z_QueryVideoCaptureDeviceNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryVideoCaptureDeviceNV(hDc: GDI_DC; hDevice: HVIDEOINPUTDEVICENV; iAttribute: Int32; piValue: array of Int32): UInt32 := z_QueryVideoCaptureDeviceNV_ovr0(hDc, hDevice, iAttribute, piValue);
private static function _z_QueryVideoCaptureDeviceNV_ovr1(hDc: GDI_DC; hDevice: HVIDEOINPUTDEVICENV; iAttribute: Int32; var piValue: Int32): UInt32;
external 'opengl32.dll' name 'wglQueryVideoCaptureDeviceNV';
public static z_QueryVideoCaptureDeviceNV_ovr1 := _z_QueryVideoCaptureDeviceNV_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryVideoCaptureDeviceNV(hDc: GDI_DC; hDevice: HVIDEOINPUTDEVICENV; iAttribute: Int32; var piValue: Int32): UInt32 := z_QueryVideoCaptureDeviceNV_ovr1(hDc, hDevice, iAttribute, piValue);
private static function _z_QueryVideoCaptureDeviceNV_ovr2(hDc: GDI_DC; hDevice: HVIDEOINPUTDEVICENV; iAttribute: Int32; piValue: IntPtr): UInt32;
external 'opengl32.dll' name 'wglQueryVideoCaptureDeviceNV';
public static z_QueryVideoCaptureDeviceNV_ovr2 := _z_QueryVideoCaptureDeviceNV_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function QueryVideoCaptureDeviceNV(hDc: GDI_DC; hDevice: HVIDEOINPUTDEVICENV; iAttribute: Int32; piValue: IntPtr): UInt32 := z_QueryVideoCaptureDeviceNV_ovr2(hDc, hDevice, iAttribute, piValue);
private static function _z_ReleaseVideoCaptureDeviceNV_ovr0(hDc: GDI_DC; hDevice: HVIDEOINPUTDEVICENV): UInt32;
external 'opengl32.dll' name 'wglReleaseVideoCaptureDeviceNV';
public static z_ReleaseVideoCaptureDeviceNV_ovr0 := _z_ReleaseVideoCaptureDeviceNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleaseVideoCaptureDeviceNV(hDc: GDI_DC; hDevice: HVIDEOINPUTDEVICENV): UInt32 := z_ReleaseVideoCaptureDeviceNV_ovr0(hDc, hDevice);
end;
wglVideoOutputNV = static class
private static function _z_GetVideoDeviceNV_ovr0(hDC: GDI_DC; numDevices: Int32; [MarshalAs(UnmanagedType.LPArray)] hVideoDevice: array of HPVIDEODEV): UInt32;
external 'opengl32.dll' name 'wglGetVideoDeviceNV';
public static z_GetVideoDeviceNV_ovr0 := _z_GetVideoDeviceNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetVideoDeviceNV(hDC: GDI_DC; numDevices: Int32; hVideoDevice: array of HPVIDEODEV): UInt32 := z_GetVideoDeviceNV_ovr0(hDC, numDevices, hVideoDevice);
private static function _z_GetVideoDeviceNV_ovr1(hDC: GDI_DC; numDevices: Int32; var hVideoDevice: HPVIDEODEV): UInt32;
external 'opengl32.dll' name 'wglGetVideoDeviceNV';
public static z_GetVideoDeviceNV_ovr1 := _z_GetVideoDeviceNV_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetVideoDeviceNV(hDC: GDI_DC; numDevices: Int32; var hVideoDevice: HPVIDEODEV): UInt32 := z_GetVideoDeviceNV_ovr1(hDC, numDevices, hVideoDevice);
private static function _z_GetVideoDeviceNV_ovr2(hDC: GDI_DC; numDevices: Int32; hVideoDevice: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetVideoDeviceNV';
public static z_GetVideoDeviceNV_ovr2 := _z_GetVideoDeviceNV_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetVideoDeviceNV(hDC: GDI_DC; numDevices: Int32; hVideoDevice: IntPtr): UInt32 := z_GetVideoDeviceNV_ovr2(hDC, numDevices, hVideoDevice);
private static function _z_ReleaseVideoDeviceNV_ovr0(hVideoDevice: HPVIDEODEV): UInt32;
external 'opengl32.dll' name 'wglReleaseVideoDeviceNV';
public static z_ReleaseVideoDeviceNV_ovr0 := _z_ReleaseVideoDeviceNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleaseVideoDeviceNV(hVideoDevice: HPVIDEODEV): UInt32 := z_ReleaseVideoDeviceNV_ovr0(hVideoDevice);
private static function _z_BindVideoImageNV_ovr0(hVideoDevice: HPVIDEODEV; _hPbuffer: HPBUFFER; iVideoBuffer: Int32): UInt32;
external 'opengl32.dll' name 'wglBindVideoImageNV';
public static z_BindVideoImageNV_ovr0 := _z_BindVideoImageNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function BindVideoImageNV(hVideoDevice: HPVIDEODEV; _hPbuffer: HPBUFFER; iVideoBuffer: Int32): UInt32 := z_BindVideoImageNV_ovr0(hVideoDevice, _hPbuffer, iVideoBuffer);
private static function _z_ReleaseVideoImageNV_ovr0(_hPbuffer: HPBUFFER; iVideoBuffer: Int32): UInt32;
external 'opengl32.dll' name 'wglReleaseVideoImageNV';
public static z_ReleaseVideoImageNV_ovr0 := _z_ReleaseVideoImageNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function ReleaseVideoImageNV(_hPbuffer: HPBUFFER; iVideoBuffer: Int32): UInt32 := z_ReleaseVideoImageNV_ovr0(_hPbuffer, iVideoBuffer);
private static function _z_SendPbufferToVideoNV_ovr0(_hPbuffer: HPBUFFER; iBufferType: Int32; [MarshalAs(UnmanagedType.LPArray)] pulCounterPbuffer: array of UInt64; bBlock: UInt32): UInt32;
external 'opengl32.dll' name 'wglSendPbufferToVideoNV';
public static z_SendPbufferToVideoNV_ovr0 := _z_SendPbufferToVideoNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SendPbufferToVideoNV(_hPbuffer: HPBUFFER; iBufferType: Int32; pulCounterPbuffer: array of UInt64; bBlock: UInt32): UInt32 := z_SendPbufferToVideoNV_ovr0(_hPbuffer, iBufferType, pulCounterPbuffer, bBlock);
private static function _z_SendPbufferToVideoNV_ovr1(_hPbuffer: HPBUFFER; iBufferType: Int32; var pulCounterPbuffer: UInt64; bBlock: UInt32): UInt32;
external 'opengl32.dll' name 'wglSendPbufferToVideoNV';
public static z_SendPbufferToVideoNV_ovr1 := _z_SendPbufferToVideoNV_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SendPbufferToVideoNV(_hPbuffer: HPBUFFER; iBufferType: Int32; var pulCounterPbuffer: UInt64; bBlock: UInt32): UInt32 := z_SendPbufferToVideoNV_ovr1(_hPbuffer, iBufferType, pulCounterPbuffer, bBlock);
private static function _z_SendPbufferToVideoNV_ovr2(_hPbuffer: HPBUFFER; iBufferType: Int32; pulCounterPbuffer: IntPtr; bBlock: UInt32): UInt32;
external 'opengl32.dll' name 'wglSendPbufferToVideoNV';
public static z_SendPbufferToVideoNV_ovr2 := _z_SendPbufferToVideoNV_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SendPbufferToVideoNV(_hPbuffer: HPBUFFER; iBufferType: Int32; pulCounterPbuffer: IntPtr; bBlock: UInt32): UInt32 := z_SendPbufferToVideoNV_ovr2(_hPbuffer, iBufferType, pulCounterPbuffer, bBlock);
private static function _z_GetVideoInfoNV_ovr0(hpVideoDevice: HPVIDEODEV; [MarshalAs(UnmanagedType.LPArray)] pulCounterOutputPbuffer: array of UInt64; [MarshalAs(UnmanagedType.LPArray)] pulCounterOutputVideo: array of UInt64): UInt32;
external 'opengl32.dll' name 'wglGetVideoInfoNV';
public static z_GetVideoInfoNV_ovr0 := _z_GetVideoInfoNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetVideoInfoNV(hpVideoDevice: HPVIDEODEV; pulCounterOutputPbuffer: array of UInt64; pulCounterOutputVideo: array of UInt64): UInt32 := z_GetVideoInfoNV_ovr0(hpVideoDevice, pulCounterOutputPbuffer, pulCounterOutputVideo);
private static function _z_GetVideoInfoNV_ovr1(hpVideoDevice: HPVIDEODEV; [MarshalAs(UnmanagedType.LPArray)] pulCounterOutputPbuffer: array of UInt64; var pulCounterOutputVideo: UInt64): UInt32;
external 'opengl32.dll' name 'wglGetVideoInfoNV';
public static z_GetVideoInfoNV_ovr1 := _z_GetVideoInfoNV_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetVideoInfoNV(hpVideoDevice: HPVIDEODEV; pulCounterOutputPbuffer: array of UInt64; var pulCounterOutputVideo: UInt64): UInt32 := z_GetVideoInfoNV_ovr1(hpVideoDevice, pulCounterOutputPbuffer, pulCounterOutputVideo);
private static function _z_GetVideoInfoNV_ovr2(hpVideoDevice: HPVIDEODEV; [MarshalAs(UnmanagedType.LPArray)] pulCounterOutputPbuffer: array of UInt64; pulCounterOutputVideo: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetVideoInfoNV';
public static z_GetVideoInfoNV_ovr2 := _z_GetVideoInfoNV_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetVideoInfoNV(hpVideoDevice: HPVIDEODEV; pulCounterOutputPbuffer: array of UInt64; pulCounterOutputVideo: IntPtr): UInt32 := z_GetVideoInfoNV_ovr2(hpVideoDevice, pulCounterOutputPbuffer, pulCounterOutputVideo);
private static function _z_GetVideoInfoNV_ovr3(hpVideoDevice: HPVIDEODEV; var pulCounterOutputPbuffer: UInt64; [MarshalAs(UnmanagedType.LPArray)] pulCounterOutputVideo: array of UInt64): UInt32;
external 'opengl32.dll' name 'wglGetVideoInfoNV';
public static z_GetVideoInfoNV_ovr3 := _z_GetVideoInfoNV_ovr3;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetVideoInfoNV(hpVideoDevice: HPVIDEODEV; var pulCounterOutputPbuffer: UInt64; pulCounterOutputVideo: array of UInt64): UInt32 := z_GetVideoInfoNV_ovr3(hpVideoDevice, pulCounterOutputPbuffer, pulCounterOutputVideo);
private static function _z_GetVideoInfoNV_ovr4(hpVideoDevice: HPVIDEODEV; var pulCounterOutputPbuffer: UInt64; var pulCounterOutputVideo: UInt64): UInt32;
external 'opengl32.dll' name 'wglGetVideoInfoNV';
public static z_GetVideoInfoNV_ovr4 := _z_GetVideoInfoNV_ovr4;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetVideoInfoNV(hpVideoDevice: HPVIDEODEV; var pulCounterOutputPbuffer: UInt64; var pulCounterOutputVideo: UInt64): UInt32 := z_GetVideoInfoNV_ovr4(hpVideoDevice, pulCounterOutputPbuffer, pulCounterOutputVideo);
private static function _z_GetVideoInfoNV_ovr5(hpVideoDevice: HPVIDEODEV; var pulCounterOutputPbuffer: UInt64; pulCounterOutputVideo: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetVideoInfoNV';
public static z_GetVideoInfoNV_ovr5 := _z_GetVideoInfoNV_ovr5;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetVideoInfoNV(hpVideoDevice: HPVIDEODEV; var pulCounterOutputPbuffer: UInt64; pulCounterOutputVideo: IntPtr): UInt32 := z_GetVideoInfoNV_ovr5(hpVideoDevice, pulCounterOutputPbuffer, pulCounterOutputVideo);
private static function _z_GetVideoInfoNV_ovr6(hpVideoDevice: HPVIDEODEV; pulCounterOutputPbuffer: IntPtr; [MarshalAs(UnmanagedType.LPArray)] pulCounterOutputVideo: array of UInt64): UInt32;
external 'opengl32.dll' name 'wglGetVideoInfoNV';
public static z_GetVideoInfoNV_ovr6 := _z_GetVideoInfoNV_ovr6;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetVideoInfoNV(hpVideoDevice: HPVIDEODEV; pulCounterOutputPbuffer: IntPtr; pulCounterOutputVideo: array of UInt64): UInt32 := z_GetVideoInfoNV_ovr6(hpVideoDevice, pulCounterOutputPbuffer, pulCounterOutputVideo);
private static function _z_GetVideoInfoNV_ovr7(hpVideoDevice: HPVIDEODEV; pulCounterOutputPbuffer: IntPtr; var pulCounterOutputVideo: UInt64): UInt32;
external 'opengl32.dll' name 'wglGetVideoInfoNV';
public static z_GetVideoInfoNV_ovr7 := _z_GetVideoInfoNV_ovr7;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetVideoInfoNV(hpVideoDevice: HPVIDEODEV; pulCounterOutputPbuffer: IntPtr; var pulCounterOutputVideo: UInt64): UInt32 := z_GetVideoInfoNV_ovr7(hpVideoDevice, pulCounterOutputPbuffer, pulCounterOutputVideo);
private static function _z_GetVideoInfoNV_ovr8(hpVideoDevice: HPVIDEODEV; pulCounterOutputPbuffer: IntPtr; pulCounterOutputVideo: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetVideoInfoNV';
public static z_GetVideoInfoNV_ovr8 := _z_GetVideoInfoNV_ovr8;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetVideoInfoNV(hpVideoDevice: HPVIDEODEV; pulCounterOutputPbuffer: IntPtr; pulCounterOutputVideo: IntPtr): UInt32 := z_GetVideoInfoNV_ovr8(hpVideoDevice, pulCounterOutputPbuffer, pulCounterOutputVideo);
end;
wglVertexArrayRangeNV = static class
private static function _z_AllocateMemoryNV_ovr0(size: Int32; readfreq: single; writefreq: single; priority: single): IntPtr;
external 'opengl32.dll' name 'wglAllocateMemoryNV';
public static z_AllocateMemoryNV_ovr0 := _z_AllocateMemoryNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function AllocateMemoryNV(size: Int32; readfreq: single; writefreq: single; priority: single): IntPtr := z_AllocateMemoryNV_ovr0(size, readfreq, writefreq, priority);
private static procedure _z_FreeMemoryNV_ovr0(pointer: IntPtr);
external 'opengl32.dll' name 'wglFreeMemoryNV';
public static z_FreeMemoryNV_ovr0 := _z_FreeMemoryNV_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static procedure FreeMemoryNV(pointer: IntPtr) := z_FreeMemoryNV_ovr0(pointer);
end;
wglSyncControlOML = static class
private static function _z_GetSyncValuesOML_ovr0(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] ust: array of Int64; [MarshalAs(UnmanagedType.LPArray)] msc: array of Int64; [MarshalAs(UnmanagedType.LPArray)] sbc: array of Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public static z_GetSyncValuesOML_ovr0 := _z_GetSyncValuesOML_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: array of Int64; msc: array of Int64; sbc: array of Int64): UInt32 := z_GetSyncValuesOML_ovr0(hdc, ust, msc, sbc);
private static function _z_GetSyncValuesOML_ovr1(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] ust: array of Int64; [MarshalAs(UnmanagedType.LPArray)] msc: array of Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public static z_GetSyncValuesOML_ovr1 := _z_GetSyncValuesOML_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: array of Int64; msc: array of Int64; var sbc: Int64): UInt32 := z_GetSyncValuesOML_ovr1(hdc, ust, msc, sbc);
private static function _z_GetSyncValuesOML_ovr2(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] ust: array of Int64; [MarshalAs(UnmanagedType.LPArray)] msc: array of Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public static z_GetSyncValuesOML_ovr2 := _z_GetSyncValuesOML_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: array of Int64; msc: array of Int64; sbc: IntPtr): UInt32 := z_GetSyncValuesOML_ovr2(hdc, ust, msc, sbc);
private static function _z_GetSyncValuesOML_ovr3(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] ust: array of Int64; var msc: Int64; [MarshalAs(UnmanagedType.LPArray)] sbc: array of Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public static z_GetSyncValuesOML_ovr3 := _z_GetSyncValuesOML_ovr3;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: array of Int64; var msc: Int64; sbc: array of Int64): UInt32 := z_GetSyncValuesOML_ovr3(hdc, ust, msc, sbc);
private static function _z_GetSyncValuesOML_ovr4(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] ust: array of Int64; var msc: Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public static z_GetSyncValuesOML_ovr4 := _z_GetSyncValuesOML_ovr4;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: array of Int64; var msc: Int64; var sbc: Int64): UInt32 := z_GetSyncValuesOML_ovr4(hdc, ust, msc, sbc);
private static function _z_GetSyncValuesOML_ovr5(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] ust: array of Int64; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public static z_GetSyncValuesOML_ovr5 := _z_GetSyncValuesOML_ovr5;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: array of Int64; var msc: Int64; sbc: IntPtr): UInt32 := z_GetSyncValuesOML_ovr5(hdc, ust, msc, sbc);
private static function _z_GetSyncValuesOML_ovr6(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] ust: array of Int64; msc: IntPtr; [MarshalAs(UnmanagedType.LPArray)] sbc: array of Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public static z_GetSyncValuesOML_ovr6 := _z_GetSyncValuesOML_ovr6;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: array of Int64; msc: IntPtr; sbc: array of Int64): UInt32 := z_GetSyncValuesOML_ovr6(hdc, ust, msc, sbc);
private static function _z_GetSyncValuesOML_ovr7(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] ust: array of Int64; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public static z_GetSyncValuesOML_ovr7 := _z_GetSyncValuesOML_ovr7;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: array of Int64; msc: IntPtr; var sbc: Int64): UInt32 := z_GetSyncValuesOML_ovr7(hdc, ust, msc, sbc);
private static function _z_GetSyncValuesOML_ovr8(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] ust: array of Int64; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public static z_GetSyncValuesOML_ovr8 := _z_GetSyncValuesOML_ovr8;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: array of Int64; msc: IntPtr; sbc: IntPtr): UInt32 := z_GetSyncValuesOML_ovr8(hdc, ust, msc, sbc);
private static function _z_GetSyncValuesOML_ovr9(hdc: GDI_DC; var ust: Int64; [MarshalAs(UnmanagedType.LPArray)] msc: array of Int64; [MarshalAs(UnmanagedType.LPArray)] sbc: array of Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public static z_GetSyncValuesOML_ovr9 := _z_GetSyncValuesOML_ovr9;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; var ust: Int64; msc: array of Int64; sbc: array of Int64): UInt32 := z_GetSyncValuesOML_ovr9(hdc, ust, msc, sbc);
private static function _z_GetSyncValuesOML_ovr10(hdc: GDI_DC; var ust: Int64; [MarshalAs(UnmanagedType.LPArray)] msc: array of Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public static z_GetSyncValuesOML_ovr10 := _z_GetSyncValuesOML_ovr10;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; var ust: Int64; msc: array of Int64; var sbc: Int64): UInt32 := z_GetSyncValuesOML_ovr10(hdc, ust, msc, sbc);
private static function _z_GetSyncValuesOML_ovr11(hdc: GDI_DC; var ust: Int64; [MarshalAs(UnmanagedType.LPArray)] msc: array of Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public static z_GetSyncValuesOML_ovr11 := _z_GetSyncValuesOML_ovr11;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; var ust: Int64; msc: array of Int64; sbc: IntPtr): UInt32 := z_GetSyncValuesOML_ovr11(hdc, ust, msc, sbc);
private static function _z_GetSyncValuesOML_ovr12(hdc: GDI_DC; var ust: Int64; var msc: Int64; [MarshalAs(UnmanagedType.LPArray)] sbc: array of Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public static z_GetSyncValuesOML_ovr12 := _z_GetSyncValuesOML_ovr12;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; var ust: Int64; var msc: Int64; sbc: array of Int64): UInt32 := z_GetSyncValuesOML_ovr12(hdc, ust, msc, sbc);
private static function _z_GetSyncValuesOML_ovr13(hdc: GDI_DC; var ust: Int64; var msc: Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public static z_GetSyncValuesOML_ovr13 := _z_GetSyncValuesOML_ovr13;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; var ust: Int64; var msc: Int64; var sbc: Int64): UInt32 := z_GetSyncValuesOML_ovr13(hdc, ust, msc, sbc);
private static function _z_GetSyncValuesOML_ovr14(hdc: GDI_DC; var ust: Int64; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public static z_GetSyncValuesOML_ovr14 := _z_GetSyncValuesOML_ovr14;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; var ust: Int64; var msc: Int64; sbc: IntPtr): UInt32 := z_GetSyncValuesOML_ovr14(hdc, ust, msc, sbc);
private static function _z_GetSyncValuesOML_ovr15(hdc: GDI_DC; var ust: Int64; msc: IntPtr; [MarshalAs(UnmanagedType.LPArray)] sbc: array of Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public static z_GetSyncValuesOML_ovr15 := _z_GetSyncValuesOML_ovr15;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; var ust: Int64; msc: IntPtr; sbc: array of Int64): UInt32 := z_GetSyncValuesOML_ovr15(hdc, ust, msc, sbc);
private static function _z_GetSyncValuesOML_ovr16(hdc: GDI_DC; var ust: Int64; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public static z_GetSyncValuesOML_ovr16 := _z_GetSyncValuesOML_ovr16;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; var ust: Int64; msc: IntPtr; var sbc: Int64): UInt32 := z_GetSyncValuesOML_ovr16(hdc, ust, msc, sbc);
private static function _z_GetSyncValuesOML_ovr17(hdc: GDI_DC; var ust: Int64; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public static z_GetSyncValuesOML_ovr17 := _z_GetSyncValuesOML_ovr17;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; var ust: Int64; msc: IntPtr; sbc: IntPtr): UInt32 := z_GetSyncValuesOML_ovr17(hdc, ust, msc, sbc);
private static function _z_GetSyncValuesOML_ovr18(hdc: GDI_DC; ust: IntPtr; [MarshalAs(UnmanagedType.LPArray)] msc: array of Int64; [MarshalAs(UnmanagedType.LPArray)] sbc: array of Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public static z_GetSyncValuesOML_ovr18 := _z_GetSyncValuesOML_ovr18;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: IntPtr; msc: array of Int64; sbc: array of Int64): UInt32 := z_GetSyncValuesOML_ovr18(hdc, ust, msc, sbc);
private static function _z_GetSyncValuesOML_ovr19(hdc: GDI_DC; ust: IntPtr; [MarshalAs(UnmanagedType.LPArray)] msc: array of Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public static z_GetSyncValuesOML_ovr19 := _z_GetSyncValuesOML_ovr19;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: IntPtr; msc: array of Int64; var sbc: Int64): UInt32 := z_GetSyncValuesOML_ovr19(hdc, ust, msc, sbc);
private static function _z_GetSyncValuesOML_ovr20(hdc: GDI_DC; ust: IntPtr; [MarshalAs(UnmanagedType.LPArray)] msc: array of Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public static z_GetSyncValuesOML_ovr20 := _z_GetSyncValuesOML_ovr20;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: IntPtr; msc: array of Int64; sbc: IntPtr): UInt32 := z_GetSyncValuesOML_ovr20(hdc, ust, msc, sbc);
private static function _z_GetSyncValuesOML_ovr21(hdc: GDI_DC; ust: IntPtr; var msc: Int64; [MarshalAs(UnmanagedType.LPArray)] sbc: array of Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public static z_GetSyncValuesOML_ovr21 := _z_GetSyncValuesOML_ovr21;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: IntPtr; var msc: Int64; sbc: array of Int64): UInt32 := z_GetSyncValuesOML_ovr21(hdc, ust, msc, sbc);
private static function _z_GetSyncValuesOML_ovr22(hdc: GDI_DC; ust: IntPtr; var msc: Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public static z_GetSyncValuesOML_ovr22 := _z_GetSyncValuesOML_ovr22;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: IntPtr; var msc: Int64; var sbc: Int64): UInt32 := z_GetSyncValuesOML_ovr22(hdc, ust, msc, sbc);
private static function _z_GetSyncValuesOML_ovr23(hdc: GDI_DC; ust: IntPtr; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public static z_GetSyncValuesOML_ovr23 := _z_GetSyncValuesOML_ovr23;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: IntPtr; var msc: Int64; sbc: IntPtr): UInt32 := z_GetSyncValuesOML_ovr23(hdc, ust, msc, sbc);
private static function _z_GetSyncValuesOML_ovr24(hdc: GDI_DC; ust: IntPtr; msc: IntPtr; [MarshalAs(UnmanagedType.LPArray)] sbc: array of Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public static z_GetSyncValuesOML_ovr24 := _z_GetSyncValuesOML_ovr24;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: IntPtr; msc: IntPtr; sbc: array of Int64): UInt32 := z_GetSyncValuesOML_ovr24(hdc, ust, msc, sbc);
private static function _z_GetSyncValuesOML_ovr25(hdc: GDI_DC; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public static z_GetSyncValuesOML_ovr25 := _z_GetSyncValuesOML_ovr25;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32 := z_GetSyncValuesOML_ovr25(hdc, ust, msc, sbc);
private static function _z_GetSyncValuesOML_ovr26(hdc: GDI_DC; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetSyncValuesOML';
public static z_GetSyncValuesOML_ovr26 := _z_GetSyncValuesOML_ovr26;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetSyncValuesOML(hdc: GDI_DC; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32 := z_GetSyncValuesOML_ovr26(hdc, ust, msc, sbc);
private static function _z_GetMscRateOML_ovr0(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] numerator: array of Int32; [MarshalAs(UnmanagedType.LPArray)] denominator: array of Int32): UInt32;
external 'opengl32.dll' name 'wglGetMscRateOML';
public static z_GetMscRateOML_ovr0 := _z_GetMscRateOML_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMscRateOML(hdc: GDI_DC; numerator: array of Int32; denominator: array of Int32): UInt32 := z_GetMscRateOML_ovr0(hdc, numerator, denominator);
private static function _z_GetMscRateOML_ovr1(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] numerator: array of Int32; var denominator: Int32): UInt32;
external 'opengl32.dll' name 'wglGetMscRateOML';
public static z_GetMscRateOML_ovr1 := _z_GetMscRateOML_ovr1;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMscRateOML(hdc: GDI_DC; numerator: array of Int32; var denominator: Int32): UInt32 := z_GetMscRateOML_ovr1(hdc, numerator, denominator);
private static function _z_GetMscRateOML_ovr2(hdc: GDI_DC; [MarshalAs(UnmanagedType.LPArray)] numerator: array of Int32; denominator: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetMscRateOML';
public static z_GetMscRateOML_ovr2 := _z_GetMscRateOML_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMscRateOML(hdc: GDI_DC; numerator: array of Int32; denominator: IntPtr): UInt32 := z_GetMscRateOML_ovr2(hdc, numerator, denominator);
private static function _z_GetMscRateOML_ovr3(hdc: GDI_DC; var numerator: Int32; [MarshalAs(UnmanagedType.LPArray)] denominator: array of Int32): UInt32;
external 'opengl32.dll' name 'wglGetMscRateOML';
public static z_GetMscRateOML_ovr3 := _z_GetMscRateOML_ovr3;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMscRateOML(hdc: GDI_DC; var numerator: Int32; denominator: array of Int32): UInt32 := z_GetMscRateOML_ovr3(hdc, numerator, denominator);
private static function _z_GetMscRateOML_ovr4(hdc: GDI_DC; var numerator: Int32; var denominator: Int32): UInt32;
external 'opengl32.dll' name 'wglGetMscRateOML';
public static z_GetMscRateOML_ovr4 := _z_GetMscRateOML_ovr4;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMscRateOML(hdc: GDI_DC; var numerator: Int32; var denominator: Int32): UInt32 := z_GetMscRateOML_ovr4(hdc, numerator, denominator);
private static function _z_GetMscRateOML_ovr5(hdc: GDI_DC; var numerator: Int32; denominator: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetMscRateOML';
public static z_GetMscRateOML_ovr5 := _z_GetMscRateOML_ovr5;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMscRateOML(hdc: GDI_DC; var numerator: Int32; denominator: IntPtr): UInt32 := z_GetMscRateOML_ovr5(hdc, numerator, denominator);
private static function _z_GetMscRateOML_ovr6(hdc: GDI_DC; numerator: IntPtr; [MarshalAs(UnmanagedType.LPArray)] denominator: array of Int32): UInt32;
external 'opengl32.dll' name 'wglGetMscRateOML';
public static z_GetMscRateOML_ovr6 := _z_GetMscRateOML_ovr6;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMscRateOML(hdc: GDI_DC; numerator: IntPtr; denominator: array of Int32): UInt32 := z_GetMscRateOML_ovr6(hdc, numerator, denominator);
private static function _z_GetMscRateOML_ovr7(hdc: GDI_DC; numerator: IntPtr; var denominator: Int32): UInt32;
external 'opengl32.dll' name 'wglGetMscRateOML';
public static z_GetMscRateOML_ovr7 := _z_GetMscRateOML_ovr7;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMscRateOML(hdc: GDI_DC; numerator: IntPtr; var denominator: Int32): UInt32 := z_GetMscRateOML_ovr7(hdc, numerator, denominator);
private static function _z_GetMscRateOML_ovr8(hdc: GDI_DC; numerator: IntPtr; denominator: IntPtr): UInt32;
external 'opengl32.dll' name 'wglGetMscRateOML';
public static z_GetMscRateOML_ovr8 := _z_GetMscRateOML_ovr8;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function GetMscRateOML(hdc: GDI_DC; numerator: IntPtr; denominator: IntPtr): UInt32 := z_GetMscRateOML_ovr8(hdc, numerator, denominator);
private static function _z_SwapBuffersMscOML_ovr0(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64): Int64;
external 'opengl32.dll' name 'wglSwapBuffersMscOML';
public static z_SwapBuffersMscOML_ovr0 := _z_SwapBuffersMscOML_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SwapBuffersMscOML(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64): Int64 := z_SwapBuffersMscOML_ovr0(hdc, target_msc, divisor, remainder);
private static function _z_SwapLayerBuffersMscOML_ovr0(hdc: GDI_DC; fuPlanes: Int32; target_msc: Int64; divisor: Int64; remainder: Int64): Int64;
external 'opengl32.dll' name 'wglSwapLayerBuffersMscOML';
public static z_SwapLayerBuffersMscOML_ovr0 := _z_SwapLayerBuffersMscOML_ovr0;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function SwapLayerBuffersMscOML(hdc: GDI_DC; fuPlanes: Int32; target_msc: Int64; divisor: Int64; remainder: Int64): Int64 := z_SwapLayerBuffersMscOML_ovr0(hdc, fuPlanes, target_msc, divisor, remainder);
private static function _z_WaitForMscOML_ovr0(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; [MarshalAs(UnmanagedType.LPArray)] ust: array of Int64; [MarshalAs(UnmanagedType.LPArray)] msc: array of Int64; [MarshalAs(UnmanagedType.LPArray)] sbc: array of Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public static z_WaitForMscOML_ovr0 := _z_WaitForMscOML_ovr0;
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 := z_WaitForMscOML_ovr0(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function _z_WaitForMscOML_ovr1(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; [MarshalAs(UnmanagedType.LPArray)] ust: array of Int64; [MarshalAs(UnmanagedType.LPArray)] msc: array of Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public static z_WaitForMscOML_ovr1 := _z_WaitForMscOML_ovr1;
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 := z_WaitForMscOML_ovr1(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function _z_WaitForMscOML_ovr2(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; [MarshalAs(UnmanagedType.LPArray)] ust: array of Int64; [MarshalAs(UnmanagedType.LPArray)] msc: array of Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public static z_WaitForMscOML_ovr2 := _z_WaitForMscOML_ovr2;
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 := z_WaitForMscOML_ovr2(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function _z_WaitForMscOML_ovr3(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; [MarshalAs(UnmanagedType.LPArray)] ust: array of Int64; var msc: Int64; [MarshalAs(UnmanagedType.LPArray)] sbc: array of Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public static z_WaitForMscOML_ovr3 := _z_WaitForMscOML_ovr3;
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 := z_WaitForMscOML_ovr3(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function _z_WaitForMscOML_ovr4(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; [MarshalAs(UnmanagedType.LPArray)] ust: array of Int64; var msc: Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public static z_WaitForMscOML_ovr4 := _z_WaitForMscOML_ovr4;
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 := z_WaitForMscOML_ovr4(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function _z_WaitForMscOML_ovr5(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; [MarshalAs(UnmanagedType.LPArray)] ust: array of Int64; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public static z_WaitForMscOML_ovr5 := _z_WaitForMscOML_ovr5;
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 := z_WaitForMscOML_ovr5(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function _z_WaitForMscOML_ovr6(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; [MarshalAs(UnmanagedType.LPArray)] ust: array of Int64; msc: IntPtr; [MarshalAs(UnmanagedType.LPArray)] sbc: array of Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public static z_WaitForMscOML_ovr6 := _z_WaitForMscOML_ovr6;
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 := z_WaitForMscOML_ovr6(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function _z_WaitForMscOML_ovr7(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; [MarshalAs(UnmanagedType.LPArray)] ust: array of Int64; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public static z_WaitForMscOML_ovr7 := _z_WaitForMscOML_ovr7;
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 := z_WaitForMscOML_ovr7(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function _z_WaitForMscOML_ovr8(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; [MarshalAs(UnmanagedType.LPArray)] ust: array of Int64; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public static z_WaitForMscOML_ovr8 := _z_WaitForMscOML_ovr8;
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 := z_WaitForMscOML_ovr8(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function _z_WaitForMscOML_ovr9(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; var ust: Int64; [MarshalAs(UnmanagedType.LPArray)] msc: array of Int64; [MarshalAs(UnmanagedType.LPArray)] sbc: array of Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public static z_WaitForMscOML_ovr9 := _z_WaitForMscOML_ovr9;
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 := z_WaitForMscOML_ovr9(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function _z_WaitForMscOML_ovr10(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; var ust: Int64; [MarshalAs(UnmanagedType.LPArray)] msc: array of Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public static z_WaitForMscOML_ovr10 := _z_WaitForMscOML_ovr10;
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 := z_WaitForMscOML_ovr10(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function _z_WaitForMscOML_ovr11(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; var ust: Int64; [MarshalAs(UnmanagedType.LPArray)] msc: array of Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public static z_WaitForMscOML_ovr11 := _z_WaitForMscOML_ovr11;
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 := z_WaitForMscOML_ovr11(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function _z_WaitForMscOML_ovr12(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; var ust: Int64; var msc: Int64; [MarshalAs(UnmanagedType.LPArray)] sbc: array of Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public static z_WaitForMscOML_ovr12 := _z_WaitForMscOML_ovr12;
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 := z_WaitForMscOML_ovr12(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function _z_WaitForMscOML_ovr13(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';
public static z_WaitForMscOML_ovr13 := _z_WaitForMscOML_ovr13;
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_ovr13(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function _z_WaitForMscOML_ovr14(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; var ust: Int64; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public static z_WaitForMscOML_ovr14 := _z_WaitForMscOML_ovr14;
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_ovr14(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function _z_WaitForMscOML_ovr15(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; var ust: Int64; msc: IntPtr; [MarshalAs(UnmanagedType.LPArray)] sbc: array of Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public static z_WaitForMscOML_ovr15 := _z_WaitForMscOML_ovr15;
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 := z_WaitForMscOML_ovr15(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function _z_WaitForMscOML_ovr16(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; var ust: Int64; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public static z_WaitForMscOML_ovr16 := _z_WaitForMscOML_ovr16;
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_ovr16(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function _z_WaitForMscOML_ovr17(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; var ust: Int64; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public static z_WaitForMscOML_ovr17 := _z_WaitForMscOML_ovr17;
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_ovr17(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function _z_WaitForMscOML_ovr18(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; [MarshalAs(UnmanagedType.LPArray)] msc: array of Int64; [MarshalAs(UnmanagedType.LPArray)] sbc: array of Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public static z_WaitForMscOML_ovr18 := _z_WaitForMscOML_ovr18;
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 := z_WaitForMscOML_ovr18(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function _z_WaitForMscOML_ovr19(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; [MarshalAs(UnmanagedType.LPArray)] msc: array of Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public static z_WaitForMscOML_ovr19 := _z_WaitForMscOML_ovr19;
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 := z_WaitForMscOML_ovr19(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function _z_WaitForMscOML_ovr20(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; [MarshalAs(UnmanagedType.LPArray)] msc: array of Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public static z_WaitForMscOML_ovr20 := _z_WaitForMscOML_ovr20;
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 := z_WaitForMscOML_ovr20(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function _z_WaitForMscOML_ovr21(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; var msc: Int64; [MarshalAs(UnmanagedType.LPArray)] sbc: array of Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public static z_WaitForMscOML_ovr21 := _z_WaitForMscOML_ovr21;
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 := z_WaitForMscOML_ovr21(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function _z_WaitForMscOML_ovr22(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 static z_WaitForMscOML_ovr22 := _z_WaitForMscOML_ovr22;
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_ovr22(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function _z_WaitForMscOML_ovr23(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public static z_WaitForMscOML_ovr23 := _z_WaitForMscOML_ovr23;
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_ovr23(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function _z_WaitForMscOML_ovr24(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; msc: IntPtr; [MarshalAs(UnmanagedType.LPArray)] sbc: array of Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public static z_WaitForMscOML_ovr24 := _z_WaitForMscOML_ovr24;
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 := z_WaitForMscOML_ovr24(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function _z_WaitForMscOML_ovr25(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public static z_WaitForMscOML_ovr25 := _z_WaitForMscOML_ovr25;
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_ovr25(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function _z_WaitForMscOML_ovr26(hdc: GDI_DC; target_msc: Int64; divisor: Int64; remainder: Int64; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForMscOML';
public static z_WaitForMscOML_ovr26 := _z_WaitForMscOML_ovr26;
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_ovr26(hdc, target_msc, divisor, remainder, ust, msc, sbc);
private static function _z_WaitForSbcOML_ovr0(hdc: GDI_DC; target_sbc: Int64; [MarshalAs(UnmanagedType.LPArray)] ust: array of Int64; [MarshalAs(UnmanagedType.LPArray)] msc: array of Int64; [MarshalAs(UnmanagedType.LPArray)] sbc: array of Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public static z_WaitForSbcOML_ovr0 := _z_WaitForSbcOML_ovr0;
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 := z_WaitForSbcOML_ovr0(hdc, target_sbc, ust, msc, sbc);
private static function _z_WaitForSbcOML_ovr1(hdc: GDI_DC; target_sbc: Int64; [MarshalAs(UnmanagedType.LPArray)] ust: array of Int64; [MarshalAs(UnmanagedType.LPArray)] msc: array of Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public static z_WaitForSbcOML_ovr1 := _z_WaitForSbcOML_ovr1;
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 := z_WaitForSbcOML_ovr1(hdc, target_sbc, ust, msc, sbc);
private static function _z_WaitForSbcOML_ovr2(hdc: GDI_DC; target_sbc: Int64; [MarshalAs(UnmanagedType.LPArray)] ust: array of Int64; [MarshalAs(UnmanagedType.LPArray)] msc: array of Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public static z_WaitForSbcOML_ovr2 := _z_WaitForSbcOML_ovr2;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: array of Int64; msc: array of Int64; sbc: IntPtr): UInt32 := z_WaitForSbcOML_ovr2(hdc, target_sbc, ust, msc, sbc);
private static function _z_WaitForSbcOML_ovr3(hdc: GDI_DC; target_sbc: Int64; [MarshalAs(UnmanagedType.LPArray)] ust: array of Int64; var msc: Int64; [MarshalAs(UnmanagedType.LPArray)] sbc: array of Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public static z_WaitForSbcOML_ovr3 := _z_WaitForSbcOML_ovr3;
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 := z_WaitForSbcOML_ovr3(hdc, target_sbc, ust, msc, sbc);
private static function _z_WaitForSbcOML_ovr4(hdc: GDI_DC; target_sbc: Int64; [MarshalAs(UnmanagedType.LPArray)] ust: array of Int64; var msc: Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public static z_WaitForSbcOML_ovr4 := _z_WaitForSbcOML_ovr4;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: array of Int64; var msc: Int64; var sbc: Int64): UInt32 := z_WaitForSbcOML_ovr4(hdc, target_sbc, ust, msc, sbc);
private static function _z_WaitForSbcOML_ovr5(hdc: GDI_DC; target_sbc: Int64; [MarshalAs(UnmanagedType.LPArray)] ust: array of Int64; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public static z_WaitForSbcOML_ovr5 := _z_WaitForSbcOML_ovr5;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: array of Int64; var msc: Int64; sbc: IntPtr): UInt32 := z_WaitForSbcOML_ovr5(hdc, target_sbc, ust, msc, sbc);
private static function _z_WaitForSbcOML_ovr6(hdc: GDI_DC; target_sbc: Int64; [MarshalAs(UnmanagedType.LPArray)] ust: array of Int64; msc: IntPtr; [MarshalAs(UnmanagedType.LPArray)] sbc: array of Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public static z_WaitForSbcOML_ovr6 := _z_WaitForSbcOML_ovr6;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: array of Int64; msc: IntPtr; sbc: array of Int64): UInt32 := z_WaitForSbcOML_ovr6(hdc, target_sbc, ust, msc, sbc);
private static function _z_WaitForSbcOML_ovr7(hdc: GDI_DC; target_sbc: Int64; [MarshalAs(UnmanagedType.LPArray)] ust: array of Int64; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public static z_WaitForSbcOML_ovr7 := _z_WaitForSbcOML_ovr7;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: array of Int64; msc: IntPtr; var sbc: Int64): UInt32 := z_WaitForSbcOML_ovr7(hdc, target_sbc, ust, msc, sbc);
private static function _z_WaitForSbcOML_ovr8(hdc: GDI_DC; target_sbc: Int64; [MarshalAs(UnmanagedType.LPArray)] ust: array of Int64; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public static z_WaitForSbcOML_ovr8 := _z_WaitForSbcOML_ovr8;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: array of Int64; msc: IntPtr; sbc: IntPtr): UInt32 := z_WaitForSbcOML_ovr8(hdc, target_sbc, ust, msc, sbc);
private static function _z_WaitForSbcOML_ovr9(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; [MarshalAs(UnmanagedType.LPArray)] msc: array of Int64; [MarshalAs(UnmanagedType.LPArray)] sbc: array of Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public static z_WaitForSbcOML_ovr9 := _z_WaitForSbcOML_ovr9;
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 := z_WaitForSbcOML_ovr9(hdc, target_sbc, ust, msc, sbc);
private static function _z_WaitForSbcOML_ovr10(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; [MarshalAs(UnmanagedType.LPArray)] msc: array of Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public static z_WaitForSbcOML_ovr10 := _z_WaitForSbcOML_ovr10;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; msc: array of Int64; var sbc: Int64): UInt32 := z_WaitForSbcOML_ovr10(hdc, target_sbc, ust, msc, sbc);
private static function _z_WaitForSbcOML_ovr11(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; [MarshalAs(UnmanagedType.LPArray)] msc: array of Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public static z_WaitForSbcOML_ovr11 := _z_WaitForSbcOML_ovr11;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; msc: array of Int64; sbc: IntPtr): UInt32 := z_WaitForSbcOML_ovr11(hdc, target_sbc, ust, msc, sbc);
private static function _z_WaitForSbcOML_ovr12(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; var msc: Int64; [MarshalAs(UnmanagedType.LPArray)] sbc: array of Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public static z_WaitForSbcOML_ovr12 := _z_WaitForSbcOML_ovr12;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; var msc: Int64; sbc: array of Int64): UInt32 := z_WaitForSbcOML_ovr12(hdc, target_sbc, ust, msc, sbc);
private static function _z_WaitForSbcOML_ovr13(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; var msc: Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public static z_WaitForSbcOML_ovr13 := _z_WaitForSbcOML_ovr13;
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_ovr13(hdc, target_sbc, ust, msc, sbc);
private static function _z_WaitForSbcOML_ovr14(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public static z_WaitForSbcOML_ovr14 := _z_WaitForSbcOML_ovr14;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; var msc: Int64; sbc: IntPtr): UInt32 := z_WaitForSbcOML_ovr14(hdc, target_sbc, ust, msc, sbc);
private static function _z_WaitForSbcOML_ovr15(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; msc: IntPtr; [MarshalAs(UnmanagedType.LPArray)] sbc: array of Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public static z_WaitForSbcOML_ovr15 := _z_WaitForSbcOML_ovr15;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; msc: IntPtr; sbc: array of Int64): UInt32 := z_WaitForSbcOML_ovr15(hdc, target_sbc, ust, msc, sbc);
private static function _z_WaitForSbcOML_ovr16(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public static z_WaitForSbcOML_ovr16 := _z_WaitForSbcOML_ovr16;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; msc: IntPtr; var sbc: Int64): UInt32 := z_WaitForSbcOML_ovr16(hdc, target_sbc, ust, msc, sbc);
private static function _z_WaitForSbcOML_ovr17(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public static z_WaitForSbcOML_ovr17 := _z_WaitForSbcOML_ovr17;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; var ust: Int64; msc: IntPtr; sbc: IntPtr): UInt32 := z_WaitForSbcOML_ovr17(hdc, target_sbc, ust, msc, sbc);
private static function _z_WaitForSbcOML_ovr18(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; [MarshalAs(UnmanagedType.LPArray)] msc: array of Int64; [MarshalAs(UnmanagedType.LPArray)] sbc: array of Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public static z_WaitForSbcOML_ovr18 := _z_WaitForSbcOML_ovr18;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: array of Int64; sbc: array of Int64): UInt32 := z_WaitForSbcOML_ovr18(hdc, target_sbc, ust, msc, sbc);
private static function _z_WaitForSbcOML_ovr19(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; [MarshalAs(UnmanagedType.LPArray)] msc: array of Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public static z_WaitForSbcOML_ovr19 := _z_WaitForSbcOML_ovr19;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: array of Int64; var sbc: Int64): UInt32 := z_WaitForSbcOML_ovr19(hdc, target_sbc, ust, msc, sbc);
private static function _z_WaitForSbcOML_ovr20(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; [MarshalAs(UnmanagedType.LPArray)] msc: array of Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public static z_WaitForSbcOML_ovr20 := _z_WaitForSbcOML_ovr20;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: array of Int64; sbc: IntPtr): UInt32 := z_WaitForSbcOML_ovr20(hdc, target_sbc, ust, msc, sbc);
private static function _z_WaitForSbcOML_ovr21(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; var msc: Int64; [MarshalAs(UnmanagedType.LPArray)] sbc: array of Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public static z_WaitForSbcOML_ovr21 := _z_WaitForSbcOML_ovr21;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; var msc: Int64; sbc: array of Int64): UInt32 := z_WaitForSbcOML_ovr21(hdc, target_sbc, ust, msc, sbc);
private static function _z_WaitForSbcOML_ovr22(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; var msc: Int64; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public static z_WaitForSbcOML_ovr22 := _z_WaitForSbcOML_ovr22;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; var msc: Int64; var sbc: Int64): UInt32 := z_WaitForSbcOML_ovr22(hdc, target_sbc, ust, msc, sbc);
private static function _z_WaitForSbcOML_ovr23(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; var msc: Int64; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public static z_WaitForSbcOML_ovr23 := _z_WaitForSbcOML_ovr23;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; var msc: Int64; sbc: IntPtr): UInt32 := z_WaitForSbcOML_ovr23(hdc, target_sbc, ust, msc, sbc);
private static function _z_WaitForSbcOML_ovr24(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: IntPtr; [MarshalAs(UnmanagedType.LPArray)] sbc: array of Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public static z_WaitForSbcOML_ovr24 := _z_WaitForSbcOML_ovr24;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: IntPtr; sbc: array of Int64): UInt32 := z_WaitForSbcOML_ovr24(hdc, target_sbc, ust, msc, sbc);
private static function _z_WaitForSbcOML_ovr25(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public static z_WaitForSbcOML_ovr25 := _z_WaitForSbcOML_ovr25;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: IntPtr; var sbc: Int64): UInt32 := z_WaitForSbcOML_ovr25(hdc, target_sbc, ust, msc, sbc);
private static function _z_WaitForSbcOML_ovr26(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32;
external 'opengl32.dll' name 'wglWaitForSbcOML';
public static z_WaitForSbcOML_ovr26 := _z_WaitForSbcOML_ovr26;
public [MethodImpl(MethodImplOptions.AggressiveInlining)] static function WaitForSbcOML(hdc: GDI_DC; target_sbc: Int64; ust: IntPtr; msc: IntPtr; sbc: IntPtr): UInt32 := z_WaitForSbcOML_ovr26(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. |
{$A+,B-,D+,E-,F-,G+,I+,L+,N+,O-,P-,Q-,R-,S-,T-,V+,X+,Y+}
{$M 1024,0,0}
{
by Behdad Esfahbod
Algorithmic Problems Book
August '1999
Problem 14 O(N2) Bfs Algorithm
}
program
ShortestPath;
const
MaxN = 100;
var
N, U, V : Integer;
A : array [1 .. MaxN, 1 .. MaxN] of Integer;
Q, P : array [1 .. MaxN] of Integer;
M : array [1 .. MaxN] of Boolean;
I, J, L, R : Integer;
F : Text;
procedure ReadInput;
begin
Assign(F, 'input.txt');
Reset(F);
Readln(F, N, U, V);
for I := 2 to N do
begin
for J := 1 to I - 1 do
begin
Read(F, A[I, J]); A[J, I] := A[I, J];
end;
Readln(F);
end;
Close(F);
end;
procedure Bfs;
begin
L := 1;
R := 1;
Q[1] := V;
M[V] := True;
while L <= R do
begin
for I := 1 to N do
if (A[I, Q[L]] = 1) and not M[I] then
begin
Inc(R);
Q[R] := I;
M[I] := True;
P[I] := Q[L];
end;
Inc(L);
end;
end;
procedure WriteOutput;
begin
Assign(F, 'output.txt');
ReWrite(F);
I := U;
J := 1;
while I <> V do
begin
I := P[I];
Inc(J);
end;
Writeln(F, J);
I := U;
Write(F, I, ' ');
while I <> V do
begin
I := P[I];
Write(F, I, ' ');
end;
Close(F);
end;
begin
ReadInput;
Bfs;
WriteOutput;
end. |
{ Copyright (C) 1998-2011, written by Mike Shkolnik, Scalabium Software
E-Mail: mshkolnik@scalabium
WEB: http://www.scalabium.com
Türkçeleştirme: M. Özgür UĞUR
Data Yazılım Ltd. İzmir/Turkiye
Const strings for localization
freeware SMComponent library
}
unit SMCnst;
interface
{Turkish strings}
const
strMessage = 'Yazdır...';
strSaveChanges = 'Değişiklikleri kaydetmek istediğinize emin misiniz?';
strErrSaveChanges = 'Veriler kaydedilemedi! Veritabanı bağlantısını veya bilgilerinizi kontrol ediniz.';
strDeleteWarning = '%s tablosunu gerçekten silmek istiyor musunuz?';
strEmptyWarning = '%s tablosunu gerçekten boşaltmak istiyor musunuz?';
const
PopUpCaption: array [0..24] of string =
('Ekle',
'Araya ekle',
'Düzenle',
'Sil',
'-',
'Yazdır ...',
'Export ...',
'Filtrele',
'Ara ...',
'-',
'Kaydet',
'Vazgeç',
'Yenile',
'-',
'Seç/Seçimi kaldır',
'Seç',
'Tümünü seç',
'-',
'Seçimi kaldır',
'Tümünü kaldır',
'-',
'Sütun yapısını kaydet',
'Sütun yapısını yükle',
'-',
'Ayarlar...');
const //for TSMSetDBGridDialog
SgbTitle = ' Kolon ';
SgbData = ' Veri ';
STitleCaption ='Kolon İsmi:';
STitleAlignment = 'Başlığı Yasla:';
STitleColor = 'Arka plan:';
STitleFont = 'Yazı karakteri:';
SWidth = 'Genişlik:';
SWidthFix = 'Karakter Sayısı:';
SAlignLeft = 'Sola';
SAlignRight = 'Sağa';
SAlignCenter = 'Ortaya';
const //for TSMDBFilterDialog
strEqual = 'eşit';
strNonEqual = 'eşit değil';
strNonMore = 'büyük değil';
strNonLess = 'küçük değil';
strLessThan = 'küçük';
strLargeThan = 'büyük';
strExist = 'boş';
strNonExist = 'boş değil';
strIn = 'içeren';
strBetween = 'arasında';
strLike = 'benzer';
strOR = 'VEYA';
strAND = 'VE';
strField = 'Alan';
strCondition = 'Koşul';
strValue = 'Değer';
strAddCondition = ' Koşul ekle:';
strSelection = ' Sonraki koşullara uyan kayıtları seç: ';
strAddToList = 'Listeye ekle';
strEditInList = 'Listede düzenle';
strDeleteFromList = 'Listeden kaldır';
strTemplate = 'Filtre şablonu seçimi ';
strFLoadFrom = 'Yükle...';
strFSaveAs = 'Farklı kaydet...';
strFDescription = 'Açıklama';
strFFileName = 'Dosya ismi';
strFCreate = '%s oluşturuldu.';
strFModify = '%s değiştirildi.';
strFProtect = 'Yazmaya karşı korumalı';
strFProtectErr = 'Korumalı dosya!';
const //for SMDBNavigator
SFirstRecord = 'İlk kayıt';
SPriorRecord = 'Önceki kayıt';
SNextRecord = 'Sonraki kayıt';
SLastRecord = 'Son kayıt';
SInsertRecord = 'Ekle';
SCopyRecord = 'Kopyala';
SDeleteRecord = 'Sil';
SEditRecord = 'Düzenle';
SFilterRecord = 'Kriterlere göre süz';
SFindRecord = 'Kaydı ara';
SPrintRecord = 'Yazdır';
SExportRecord = 'Dışa ver ...';
SImportRecord = 'İçeri al ...';
SPostEdit = 'Kaydet';
SCancelEdit = 'Vazgeç';
SRefreshRecord = 'Yenile';
SChoice ='Seç';
SClear = 'Seçimi kaldır';
SDeleteRecordQuestion = 'Kayıt silinsin mi?';
SDeleteMultipleRecordsQuestion ='Seçili kayıtları silmek istediğinizden emin misiniz?';
SRecordNotFound = 'Kayıt bulunamadı';
SFirstName = 'İlk';
SPriorName = 'Önceki';
SNextName = 'Sonraki';
SLastName = 'Son';
SInsertName = 'Ekle';
SCopyName = 'Kopyala';
SDeleteName = 'Sil';
SEditName = 'Düzenle';
SFilterName = 'Süz';
SFindName = 'Bul';
SPrintName = 'Yazdır';
SExportName = 'Dışa aktar';
SImportName = 'İçe aktar';
SPostName = 'Kaydet';
SCancelName = 'Vazgeç';
SRefreshName = 'Yenile';
SChoiceName ='Seç';
SClearName = 'Temizle';
SBtnOk = '&TAMAM';
SBtnCancel = '&İptal';
SBtnLoad = 'Yükle';
SBtnSave = 'Kaydet';
SBtnCopy = 'Kopyala';
SBtnPaste = 'Yapıştır';
SBtnClear = 'Temizle';
SRecNo = 'Kayıt no.';
SRecOf = ' / ';
const //for EditTyped
etValidNumber = 'sayı';
etValidInteger = 'tamsayı';
etValidDateTime = 'tarih/saat';
etValidDate = 'tarih';
etValidTime = 'saat';
etValid = 'geçerli';
etIsNot = 'hatalı';
etOutOfRange = '%s değeri (%s..%s aralığında değil)';
SApplyAll = 'Tümüne Uygula';
SNoDataToDisplay = '<Görüntülenecek bilgi bulunamadı>';
SPrevYear = 'önceki yıl';
SPrevMonth = 'önceki ay';
SNextMonth = 'sonraki ay';
SNextYear = 'sonraki yıl';
implementation
end.
|
{**********************************************************************}
{* Иллюстрация к книге "OpenGL в проектах Delphi" *}
{* Краснов М.В. softgl@chat.ru *}
{**********************************************************************}
unit Unit1;
interface
uses
Windows, Messages, Forms, Dialogs, Classes, Controls, ExtCtrls, StdCtrls,
OpenGL;
type
TForm1 = class(TForm)
Panel1: TPanel;
procedure FormPaint(Sender: TObject);
procedure FormDestroy(Sender: TObject);
procedure FormCreate(Sender: TObject);
private
dc : HDC;
hrc: HGLRC;
end;
var
Form1: TForm1;
implementation
{$R *.DFM}
{=======================================================================
Рисование окна}
procedure TForm1.FormPaint(Sender: TObject);
var
ps : TPaintStruct;
begin
BeginPaint (Panel1.Handle, ps); // для более устойчивой работы
wglMakeCurrent(dc, hrc);
glClearColor (1.0, 0.0, 0.0, 1.0);
glClear (GL_COLOR_BUFFER_BIT);
wglMakeCurrent(0, 0);
EndPaint (Panel1.Handle, ps);
end;
{=======================================================================
Формат пикселя}
procedure SetDCPixelFormat (hdc : HDC);
var
pfd : TPIXELFORMATDESCRIPTOR;
nPixelFormat : Integer;
begin
FillChar(pfd, SizeOf(pfd), 0);
nPixelFormat := ChoosePixelFormat (hdc, @pfd);
SetPixelFormat (hdc, nPixelFormat, @pfd);
end;
{=======================================================================
Начало работы приложения}
procedure TForm1.FormCreate(Sender: TObject);
begin
dc := GetDC (Panel1.Handle);
SetDCPixelFormat(dc);
hrc := wglCreateContext(dc);
end;
{=======================================================================
Конец работы приложения}
procedure TForm1.FormDestroy(Sender: TObject);
begin
wglDeleteContext(hrc);
end;
end.
|
unit FC.StockChart.UnitTask.Calendar.NavigatorDialog;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, ufmDialogClose_B, StdCtrls, CheckLst, ComCtrls, ExtCtrls, ExtendControls,
StockChart.Definitions.Units,
FC.Definitions, Mask, Spin, ActnList, FC.StockChart.CustomDialog_B, ImgList, JvCaptionButton, JvComponentBase,
JvDockControlForm;
type
TfmCalendarNavigatorDialog = class(TfmStockChartCustomDialog_B)
Panel2: TPanel;
Panel1: TPanel;
pbProgress: TProgressBar;
buSearchNext: TButton;
buReset: TButton;
buPrev: TButton;
Button1: TButton;
Button2: TButton;
ActionList1: TActionList;
acPrev: TAction;
acNext: TAction;
ckCopyToClipboard: TExtendCheckBox;
ckSyncAllCharts: TExtendCheckBox;
Label2: TLabel;
cbWeekday: TExtendComboBox;
edData: TExtendMemo;
procedure acNextUpdate(Sender: TObject);
procedure acPrevUpdate(Sender: TObject);
procedure Button2Click(Sender: TObject);
procedure Button1Click(Sender: TObject);
procedure buPrevClick(Sender: TObject);
procedure buSearchNextClick(Sender: TObject);
procedure buResetClick(Sender: TObject);
procedure buOKClick(Sender: TObject);
private
FIndicator: ISCIndicatorCalendar;
FIndex: integer;
FCurrentCalendarItem: integer;
FCalendarMin,FCalendarMax: integer;
function IsAppropriate(aCurrentCalendarItem: integer): boolean;
procedure SetPosition;
public
constructor Create(const aExpert: ISCIndicatorCalendar; const aStockChart: IStockChart); reintroduce;
class procedure Run(const aExpert: ISCIndicatorCalendar; const aStockChart: IStockChart);
end;
implementation
uses ufmDialog_B,BaseUtils,DateUtils, Application.Definitions,StockChart.Definitions,StockChart.Definitions.Drawing, ClipBrd,
ufmForm_B;
{$R *.dfm}
{ TfmCalendarNavigatorDialog }
constructor TfmCalendarNavigatorDialog.Create(const aExpert: ISCIndicatorCalendar; const aStockChart: IStockChart);
var
aList: TStringList;
i: integer;
aFirstDate,aLastDate: TDateTime;
begin
inherited Create(aStockChart);
FIndicator:=aExpert;
Caption:=IndicatorFactory.GetIndicatorInfo(FIndicator.GetIID).Name+': '+Caption;
if StockChart.GetInputData.Count=0 then
exit;
aFirstDate:=StockChart.GetInputData.DirectGetItem_DataDateTime(0);
aLastDate:=StockChart.GetInputData.DirectGetItem_DataDateTime(StockChart.GetInputData.Count-1);
FCalendarMin:=0;
for i := 0 to FIndicator.GetData.Count - 1 do
if FIndicator.GetData.GetItem(i).GetDateTime<aFirstDate then
FCalendarMin:=i
else
break;
FCalendarMax:=0;
for i := FIndicator.GetData.Count - 1 downto 0 do
if FIndicator.GetData.GetItem(i).GetDateTime>aLastDate then
FCalendarMax:=i
else
break;
aList:=TStringList.Create;
try
aList.Sorted:=true;
aList.Duplicates:=dupIgnore;
i:=FCalendarMin-1;
repeat
i:=FIndicator.GetNextItem(i);
if (i<>-1) and (i<=FCalendarMax) then
aList.Add(FIndicator.GetData.GetItem(i).GetIndicator);
until (i=-1) or(i>FCalendarMax);
cbWeekday.Items.Assign(aList);
finally
aList.Free;
end;
buResetClick(nil);
end;
function TfmCalendarNavigatorDialog.IsAppropriate(
aCurrentCalendarItem: integer): boolean;
begin
result:=StrIPos(cbWeekday.CurrentItem,FIndicator.GetData.GetItem(aCurrentCalendarItem).GetIndicator)<>0;
end;
procedure TfmCalendarNavigatorDialog.SetPosition;
function GetTextFromCalendarItem: string;
var
aItem: ISCCalendarItem;
begin
aItem:=FIndicator.GetData.GetItem(FCurrentCalendarItem);
result:='Date:' +DefaultFormatter.DateTimeToStr(aItem.GetDateTime,false,true)+ #13#10+
'Country:'+aItem.GetCountry+#13#10+
'Name: '+aItem.GetIndicator+#13#10+
'Priority: '+aItem.GetPriority+#13#10+
'Period: '+aItem.GetPeriod+#13#10+
'Previous Value: '+aItem.GetPreviousValue+#13#10+
'Forecast Value: '+aItem.GetForecastValue+#13#10+
'Fact Value: '+aItem.GetFactValue+#13#10+#13#10;
end;
var
aInputData:ISCInputDataCollection;
aData: ISCInputData;
aX1,aX2: TDateTime;
begin
if ((FIndex<0) or (FIndex>StockChart.GetInputData.Count-1)) and
((FCurrentCalendarItem<FCalendarMin) or (FCurrentCalendarItem>FCalendarMax)) then
begin
pbProgress.Visible:=false;
exit;
end;
if ((FIndex<0) or (FIndex>StockChart.GetInputData.Count-1)) then
begin
edData.Text:=GetTextFromCalendarItem+'Cannot find bar';
exit;
end;
pbProgress.Visible:=true;
aInputData:=StockChart.GetInputData;
pbProgress.Max:=aInputData.Count;
pbProgress.Position:=FIndex;
aData:=aInputData.Items[FIndex];
StockChart.LocateTo(aData.DataDateTime,lmCenter);
StockChart.Hilight(aData.DataDateTime,aData.DataDateTime+1/MinsPerDay);
edData.Text:=GetTextFromCalendarItem+
'OC = '+ IntToStr(aInputData.PriceToPoint(Abs(aData.DataClose-aData.DataOpen)))+
'; HL = '+ IntToStr(aInputData.PriceToPoint(Abs(aData.DataHigh-aData.DataLow)));
if ckCopyToClipboard.Checked then
begin
Clipboard.Open;
Clipboard.AsText:=edData.Text;
Clipboard.Close;
end;
if ckSyncAllCharts.Checked then
begin
aX1:=aData.DataDateTime;
aX2:=aX1+StockChart.StockSymbol.GetTimeIntervalValue/MinsPerDay;
StockChart.GetProject.HilightOnCharts(aX1,aX2,true,StockChart);
end;
end;
procedure TfmCalendarNavigatorDialog.acNextUpdate(Sender: TObject);
begin
acNext.Enabled:=FIndex<StockChart.GetInputData.Count-1;
end;
procedure TfmCalendarNavigatorDialog.acPrevUpdate(Sender: TObject);
begin
acPrev.Enabled:=FIndex>0;
end;
procedure TfmCalendarNavigatorDialog.buOKClick(Sender: TObject);
begin
inherited;
Close;
end;
procedure TfmCalendarNavigatorDialog.buPrevClick(Sender: TObject);
begin
edData.Text:='';
if FCurrentCalendarItem>FIndicator.GetData.Count then
FCurrentCalendarItem:=FIndicator.GetData.Count;
while true do
begin
FCurrentCalendarItem:=FIndicator.GetPrevItem(FCurrentCalendarItem);
if (FCurrentCalendarItem=-1) then
begin
FIndex:=-1;
break;
end
else begin
if IsAppropriate(FCurrentCalendarItem) then
begin
FIndex:=StockChart.GetInputData.FindExactMatched(FIndicator.GetData.GetItem(FCurrentCalendarItem).GetDateTime);
break;
end;
end;
end;
SetPosition;
end;
procedure TfmCalendarNavigatorDialog.buResetClick(Sender: TObject);
begin
inherited;
FCurrentCalendarItem:=FCalendarMin-1;
FIndex:=-1;
end;
procedure TfmCalendarNavigatorDialog.buSearchNextClick(Sender: TObject);
begin
edData.Text:='';
if FCurrentCalendarItem<-1 then
FCurrentCalendarItem:=-1;
while true do
begin
FCurrentCalendarItem:=FIndicator.GetNextItem(FCurrentCalendarItem);
if (FCurrentCalendarItem=-1) then
begin
FCurrentCalendarItem:=FIndicator.GetData.Count;
FIndex:=StockChart.GetInputData.Count;
break;
end
else begin
if IsAppropriate(FCurrentCalendarItem) then
begin
FIndex:=StockChart.GetInputData.FindExactMatched(FIndicator.GetData.GetItem(FCurrentCalendarItem).GetDateTime);
break;
end;
end;
end;
SetPosition;
end;
procedure TfmCalendarNavigatorDialog.Button1Click(Sender: TObject);
begin
inherited;
FCurrentCalendarItem:=FCalendarMax+1;
FIndex:=StockChart.GetInputData.Count;
SetPosition;
end;
procedure TfmCalendarNavigatorDialog.Button2Click(Sender: TObject);
begin
inherited;
FCurrentCalendarItem:=FCalendarMin-1;
FIndex:=-1;
SetPosition;
end;
class procedure TfmCalendarNavigatorDialog.Run(const aExpert: ISCIndicatorCalendar; const aStockChart: IStockChart);
begin
with TfmCalendarNavigatorDialog.Create(aExpert,aStockChart) do
Show;
end;
end.
|
{
Copyright (c) 2021, Loginov Dmitry Sergeevich
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
}
{
Данный модуль был разработан при создании примера WaitWindowExample.
https://github.com/loginov-dmitry/multithread/tree/master/ExWaitWindow
Вы его можете применять в любых проектах!
Основу модуля ParamsUtils составляет структура (record) TParamsRec, которая хранит
именованный (либо неименованный) список параметров. Данная структура необходима
для работы функции DoOperationInThread. Однако Вы можете использовать её как
универсальный способ передачи параметров в функцию, принимающую произвольное количество
параметров различного типа. Это намного лучше, чем передавать
параметры в виде вариантного массива (либо массива вариантов), поскольку обеспечивается
доступ к параметру по имени (а не только по индексу).
Что лучше? Классический способ передачи параметров в виде массива с произвольным количеством элементов:
MyFunc(VarArrayOf([s, pr, cnt, v, crt, Now]))
при этом доступ к элементам массива возможен только по индексу, например:
sTovarName := Params[0];
sSumma := Params[1] * Params[2]
или с использованием структуры TParamsRec:
MyFunc(TParamsRec.Build(['Tovar', s, 'Price', pr, 'Count', cnt, 'VidOpl', v, 'CardNum', crt, 'SaleTime', Now]))
при этом доступ к элементам массива возможен по имени, например:
sTovarName := par.S('Tovar');
sSumma := par.C('Price') * par.C('Count');
Я считаю, что без сомнения, второй вариант намного более удобный, позволяет упростить
код программы, сделать его более читабельным и снизить вероятность ошибок.
Не используйте TParamsRec для передачи слишком большого количества параметров, т.к.
для доступа к значению параметра используется последовательный поиск строки в массиве
параметров, а это не самый быстрый способ доступа!
}
unit ParamsUtils;
interface
uses
SysUtils, Classes, Variants;
type
TParamDesc = record
ParamName: string;
ParamValue: Variant;
end;
TParamsStringArray = array of string;
TParamsVariantArray = array of Variant;
PParamsRec = ^TParamsRec;
TParamsRec = record
Params: array of TParamDesc;
{Устанавливает значение заданного параметра. Если необходимо установить значения
нескольких параметров (с именем), то используйте функцию SetParams}
procedure SetParam(const ParamName: string; const Value: Variant);
{Записывает указанные параметры (названия и значения) в массив Params. Каждый
чётный элемент - имя параметра, нечётный - значение параметра. Пример:
ParamsRec.SetParams(['Name1', Value1, 'Name2', Value2])}
procedure SetParams(ParamNamesAndValues: array of Variant);
{Загружает в Params параметры из вариантного массива. Может быть
полезным при взаимодействии между модулями с использованием типа Variant, например:
var V: Variant := VarArrayOf(['Name1', Value1, 'Name2', Value2]);
ParamsRec.SetParamsFromVariant(V);
К сожалению, не получается объявить функцию с тем же именем (SetParams), т.к.
Delphi автоматически преобразует массив вариантов в вариантный массив, а затем
вызывает версию функции, где параметр объявлен как Variant }
procedure SetParamsFromVariant(ParamNamesAndValues: Variant);
{Добавляет значения параметров (без имени) в массив Params. Для доступа к значениям
параметров без имени необходимо обращаться по индексу с помощью соответствующего
набора функций}
procedure AddParamsNoNames(ParamValues: array of Variant);
{Очищает массив Params}
procedure Clear;
{Проверяет, есть ли параметр с указанным именем}
function HasParam(const ParamName: string): Boolean;
function GetParamIndex(const ParamName: string): Integer;
// Возвращает тип параметра. Если параметр отсутствует, то возвращает varEmpty
// Описание типов см. в System.pas (varEmpty, varInteger, varDouble, varDate, varString и т.д.)
function GetParamType(const ParamName: string): TVarType; overload;
// Если индекс некорректный, то выбрасывает Exception
function GetParamType(Idx: Integer): TVarType; overload;
function ExtractParamNames: TParamsStringArray;
function ExtractParamValues: TParamsVariantArray;
{ Возвращает список наименований и значений параметров в виде вариантного массива.
По сути, выполняет сериализацию параметров в вариантный массив.
Это может быть полезным при организации взаимодействия между модулями.
Например, один модуль записывает наименования и значения параметров в TParamsRec,
затем извлекает их в виде варианта с помощью метода ExtractAsVarArray,
затем передаёт во второй модуль.
Второй модуль принимает параметры в виде Variant и выполняет их десериализацию
с помощью метода SetParamsFromVariant}
function ExtractAsVarArray: Variant;
function Count: Integer;
{Возвращает значение параметра (в формате Variant) по его имени.
Внимание! Не рекомендуется иметь дело в типом Variant. Вместо этого используйте
типизированные методы: I, U, D, C, S, B, DT}
function GetValue(const ParamName: string): Variant; overload;
function GetValue(const ParamName: string; DefValue: Variant): Variant; overload;
// Короткие методы для извлечения значения параметра по его имени
// Группа методов без "DefValue". Если параметр отсутствует, то будет выдано исключение
function I(const ParamName: string): Int64; overload;
function U(const ParamName: string): Cardinal; overload;
function D(const ParamName: string): Double; overload;
function C(const ParamName: string): Currency; overload;
function S(const ParamName: string): string; overload;
function B(const ParamName: string): Boolean; overload;
function DT(const ParamName: string): TDateTime; overload;
// Группа методов с "DefValue". Если параметр отсутствует, то вернёт DefValue
function I(const ParamName: string; DefValue: Int64): Int64; overload;
function U(const ParamName: string; DefValue: Cardinal): Cardinal; overload;
function D(const ParamName: string; DefValue: Double): Double; overload;
function C(const ParamName: string; DefValue: Currency): Currency; overload;
function S(const ParamName: string; DefValue: string): string; overload;
function B(const ParamName: string; DefValue: Boolean): Boolean; overload;
function DT(const ParamName: string; DefValue: TDateTime): TDateTime; overload;
function GetValue(Idx: Integer): Variant; overload;
// Короткие методы для извлечения значения параметра по его интексу
// Внимание! Параметр должен существовать! Если парамет с указанным индексом
// отсутствует, то будет сгенерировано исключение!
function I(Idx: Integer): Int64; overload;
function U(Idx: Integer): Cardinal; overload;
function D(Idx: Integer): Double; overload;
function C(Idx: Integer): Currency; overload;
function S(Idx: Integer): string; overload;
function B(Idx: Integer): Boolean; overload;
function DT(Idx: Integer): TDateTime; overload;
// Методы для передачи параметров в функцию DoOperationInThread без объявления
// переменной TParamsRec
class function Build(ParamNamesAndValues: array of Variant): TParamsRec; static;
class function BuildFromVariant(ParamNamesAndValues: Variant): TParamsRec; static;
class function BuildNoNames(ParamValues: array of Variant): TParamsRec; static;
class function ParamNamesToString(ParamNames: array of string; DelimChar: Char = ','): string; static;
end;
var
// Глобальная переменная, которую следует использовать, если передача переметров не требуется
ParamsEmpty: TParamsRec;
implementation
{ TParamsRec }
procedure TParamsRec.SetParams(ParamNamesAndValues: array of Variant);
const
ErrPrefix = 'TParamsRec.SetParams';
var
I, CurIdx, Idx, MaxLen: Integer;
NewParams: array of TParamDesc;
begin
if Odd(Length(ParamNamesAndValues)) then
raise Exception.Create(ErrPrefix + ': Число элементов должно быть чётным');
SetLength(NewParams, Length(ParamNamesAndValues) div 2);
CurIdx := 0;
for I := 0 to High(ParamNamesAndValues) do
begin
if not Odd(I) then // Если Чётное (0, 2, 4, ...)
begin
if not VarIsStr(ParamNamesAndValues[I]) then
raise Exception.CreateFmt('%s: Элемент %d массива ParamNamesAndValues должен быть строкой', [ErrPrefix, I]);
if ParamNamesAndValues[I] = '' then
raise Exception.CreateFmt('%s: Название элемена %d массива ParamNamesAndValues не указано', [ErrPrefix, I]);
NewParams[CurIdx].ParamName := ParamNamesAndValues[I];
end else // Если нечётное (1, 3, 5, ...)
begin
NewParams[CurIdx].ParamValue := ParamNamesAndValues[I];
Inc(CurIdx);
end;
end;
CurIdx := High(Params) + 1;
MaxLen := Length(Params) + Length(NewParams);
SetLength(Params, MaxLen); // Устанавливаем сначала максимальную длину
for I := 0 to High(NewParams) do
begin
Idx := GetParamIndex(NewParams[I].ParamName);
if Idx >= 0 then
Params[Idx] := NewParams[I]
else
begin
Params[CurIdx] := NewParams[I];
Inc(CurIdx);
end;
end;
if CurIdx <> MaxLen then
SetLength(Params, CurIdx);
end;
procedure TParamsRec.AddParamsNoNames(ParamValues: array of Variant);
var
I, CurIdx: Integer;
begin
CurIdx := High(Params);
SetLength(Params, Length(Params) + Length(ParamValues));
for I := 0 to High(ParamValues) do
begin
Inc(CurIdx);
Params[CurIdx].ParamValue := ParamValues[I];
end;
end;
function TParamsRec.B(const ParamName: string): Boolean;
begin
Result := GetValue(ParamName);
end;
function TParamsRec.B(Idx: Integer): Boolean;
begin
Result := GetValue(Idx);
end;
function TParamsRec.B(const ParamName: string; DefValue: Boolean): Boolean;
begin
Result := GetValue(ParamName, DefValue);
end;
class function TParamsRec.Build(
ParamNamesAndValues: array of Variant): TParamsRec;
begin
try
Result.Clear;
Result.SetParams(ParamNamesAndValues);
except
on E: Exception do
raise Exception.Create('TParamsRec.Build: ' + E.Message);
end;
end;
class function TParamsRec.BuildFromVariant(ParamNamesAndValues: Variant): TParamsRec;
begin
Result.Clear;
Result.SetParamsFromVariant(ParamNamesAndValues);
end;
class function TParamsRec.BuildNoNames(
ParamValues: array of Variant): TParamsRec;
begin
Result.Clear;
Result.AddParamsNoNames(ParamValues);
end;
function TParamsRec.C(const ParamName: string): Currency;
begin
Result := GetValue(ParamName);
end;
function TParamsRec.C(Idx: Integer): Currency;
begin
Result := GetValue(Idx);
end;
function TParamsRec.C(const ParamName: string; DefValue: Currency): Currency;
begin
Result := GetValue(ParamName, DefValue);
end;
procedure TParamsRec.Clear;
begin
Params := nil;
end;
function TParamsRec.Count: Integer;
begin
Result := Length(Params);
end;
function TParamsRec.D(const ParamName: string): Double;
begin
Result := GetValue(ParamName);
end;
function TParamsRec.DT(const ParamName: string): TDateTime;
begin
Result := GetValue(ParamName);
end;
function TParamsRec.GetParamIndex(const ParamName: string): Integer;
var
I: Integer;
begin
if ParamName = '' then
raise Exception.Create('TParamsRec.GetParamIndex: не указано имя параметра');
Result := -1;
for I := 0 to High(Params) do
if Params[I].ParamName = ParamName then
begin
Result := I;
Exit;
end;
end;
function TParamsRec.GetParamType(Idx: Integer): TVarType;
const
ErrPrefix = 'TParamsRec.GetParamType (by index)';
begin
if (Idx < 0) or (Idx > High(Params)) then
raise Exception.CreateFmt('%s: указан недопустимый индекс параметра (%d)', [ErrPrefix, Idx]);
Result := VarType(Params[Idx].ParamValue);
end;
function TParamsRec.GetParamType(const ParamName: string): TVarType;
var
Idx: Integer;
begin
Idx := GetParamIndex(ParamName);
if Idx >= 0 then
Result := VarType(Params[Idx].ParamValue)
else
Result := varEmpty;
end;
function TParamsRec.GetValue(Idx: Integer): Variant;
const
ErrPrefix = 'TParamsRec.GetValue (by index)';
begin
if (Idx < 0) or (Idx > High(Params)) then
raise Exception.CreateFmt('%s: указан недопустимый индекс параметра (%d)', [ErrPrefix, Idx]);
Result := Params[Idx].ParamValue;
end;
function TParamsRec.GetValue(const ParamName: string;
DefValue: Variant): Variant;
const
ErrPrefix = 'TParamsRec.GetValue';
var
Idx: Integer;
begin
if ParamName = '' then
raise Exception.CreateFmt('%s: не указано имя параметра', [ErrPrefix]);
Idx := GetParamIndex(ParamName);
if Idx >= 0 then
Result := Params[Idx].ParamValue
else
Result := DefValue;
end;
function TParamsRec.HasParam(const ParamName: string): Boolean;
begin
Result := GetParamIndex(ParamName) >= 0;
end;
function TParamsRec.I(const ParamName: string; DefValue: Int64): Int64;
begin
Result := GetValue(ParamName, DefValue);
end;
function TParamsRec.I(Idx: Integer): Int64;
begin
Result := GetValue(Idx);
end;
function TParamsRec.I(const ParamName: string): Int64;
begin
Result := GetValue(ParamName);
end;
function TParamsRec.S(const ParamName: string): string;
begin
Result := GetValue(ParamName);
end;
function TParamsRec.U(const ParamName: string): Cardinal;
begin
Result := GetValue(ParamName);
end;
function TParamsRec.GetValue(const ParamName: string): Variant;
const
ErrPrefix = 'TParamsRec.GetValue';
var
Idx: Integer;
begin
if ParamName = '' then
raise Exception.CreateFmt('%s: не указано имя параметра', [ErrPrefix]);
Idx := GetParamIndex(ParamName);
if Idx >= 0 then
Result := Params[Idx].ParamValue
else
raise Exception.CreateFmt('%s: не удалось найти параметр "%s"', [ErrPrefix, ParamName]);
end;
function TParamsRec.D(Idx: Integer): Double;
begin
Result := GetValue(Idx);
end;
function TParamsRec.D(const ParamName: string; DefValue: Double): Double;
begin
Result := GetValue(ParamName, DefValue);
end;
function TParamsRec.DT(Idx: Integer): TDateTime;
begin
Result := GetValue(Idx);
end;
function TParamsRec.DT(const ParamName: string; DefValue: TDateTime): TDateTime;
begin
Result := GetValue(ParamName, DefValue);
end;
function TParamsRec.ExtractAsVarArray: Variant;
var
Idx, I: Integer;
begin
if Count = 0 then
Result := VarArrayOf([])
else
begin
Result := VarArrayCreate([0, Count * 2 - 1], varVariant);
Idx := 0;
for I := 0 to High(Params) do
begin
Result[Idx] := Params[I].ParamName;
Inc(Idx);
Result[Idx] := Params[I].ParamValue;
Inc(Idx);
end;
end;
end;
function TParamsRec.ExtractParamNames: TParamsStringArray;
var
I: Integer;
begin
SetLength(Result, Length(Params));
for I := 0 to High(Params) do
Result[I] := Params[I].ParamName;
end;
function TParamsRec.ExtractParamValues: TParamsVariantArray;
var
I: Integer;
begin
SetLength(Result, Length(Params));
for I := 0 to High(Params) do
Result[I] := Params[I].ParamValue;
end;
function TParamsRec.S(Idx: Integer): string;
begin
Result := GetValue(Idx);
end;
function TParamsRec.S(const ParamName: string; DefValue: string): string;
begin
Result := GetValue(ParamName, DefValue);
end;
procedure TParamsRec.SetParam(const ParamName: string; const Value: Variant);
begin
SetParams([ParamName, Value]);
end;
procedure TParamsRec.SetParamsFromVariant(ParamNamesAndValues: Variant);
var
AParams: array of Variant;
I: Integer;
begin
if not VarIsArray(ParamNamesAndValues) then
raise Exception.Create('TParamsRec.SetParams: входящий параметр должен быть вариантным массивом!');
SetLength(AParams, VarArrayHighBound(ParamNamesAndValues, 1) + 1);
for I := 0 to VarArrayHighBound(ParamNamesAndValues, 1) do
AParams[I] := ParamNamesAndValues[I];
SetParams(AParams);
end;
class function TParamsRec.ParamNamesToString(ParamNames: array of string;
DelimChar: Char): string;
var
s: string;
begin
Result := '';
for s in ParamNames do
begin
if Result <> '' then
Result := Result + DelimChar;
Result := Result + s;
end;
end;
function TParamsRec.U(const ParamName: string; DefValue: Cardinal): Cardinal;
begin
Result := GetValue(ParamName, DefValue);
end;
function TParamsRec.U(Idx: Integer): Cardinal;
begin
Result := GetValue(Idx);
end;
end.
|
{ *************************************************************************** }
{ }
{ Delphi and Kylix Cross-Platform Visual Component Library }
{ }
{ Copyright (c) 2000, 2001 Borland Software Corporation }
{ }
{ *************************************************************************** }
unit QSearch;
{$R-,T-,X+,H+}
interface
uses SysUtils, QStdCtrls, QDialogs;
const
{ Default word delimiters are any character except the core alphanumerics. }
WordDelimiters: set of Char = [#0..#255] - ['a'..'z','A'..'Z','1'..'9','0'];
{ TSearchRec contains information prepared about the search to increase
performance of the search is multiple searchs are performed. See
PrepareSearch. }
type
TSearchRec = record
Options: TFindOptions;
BMTable: array[Byte] of Integer;
end;
{ SearchMemo scans the text of a TCustomEdit-derived component for a given
search string. The search starts at the current caret position in the
control. The Options parameter determines whether the search runs forward
(frDown) or backward from the caret position, whether or not the text
comparison is case sensitive, and whether the matching string must be a
whole word. If text is already selected in the control, the search starts
at the 'far end' of the selection (SelStart if searching backwards, SelEnd
if searching forwards). If a match is found, the control's text selection
is changed to select the found text and the function returns True. If no
match is found, the function returns False. }
function Search(EditControl: TCustomEdit; const SearchString: WideString;
Options: TFindOptions): Boolean; overload;
function Search(EditControl: TCustomEdit; const SearchString: WideString;
const SearchRec: TSearchRec): Boolean; overload;
function Search(MemoControl: TCustomMemo; const SearchString: WideString;
Options: TFindOptions): Boolean; overload;
function Search(MemoControl: TCustomMemo; const SearchString: WideString;
const SearchRec: TSearchRec): Boolean; overload;
{ SearchBuf is a lower-level search routine for arbitrary text buffers. Same
rules as SearchMemo above. If a match is found, the function returns a
pointer to the start of the matching string in the buffer. If no match,
the function returns nil. }
function Search(const Text: WideString; SelStart, SelLength: Integer;
const SearchString: WideString; Options: TFindOptions): Integer; overload;
function Search(const Text: WideString; SelStart, SelLength: Integer;
const SearchString: WideString; const SearchRec: TSearchRec): Integer; overload;
{ PrepareSearch can be used to speed the search by collection information about
the search string once, instead of every time the search is performed. If
multiple searches are going to be performed with the same search string,
PrepareSearch should be called and the resulting record be used instead of
passing the options }
function PrepareSearch(const SearchString: WideString;
Options: TFindOptions): TSearchRec;
implementation
uses QForms,
{$IFDEF LINUX}
Libc;
{$ENDIF}
{$IFDEF MSWINDOWS}
Windows;
{$ENDIF}
function UpperCaseWideChar(C: WideChar): WideChar;
begin
{$IFDEF MSWINDOWS}
CharUpperBuffW(@C, 1);
Result := C;
{$ENDIF}
{$IFDEF LINUX}
Result := WideChar(towupper(UCS4Char(C)));
{$ENDIF}
end;
{ These search routines use a modified Boyer-Moore search algorithm. It was
modified to adapt it to be used effectively with Unicode characters. The
Unicode characters are hashed into a 0..255 range by xor'ing the high and low
bytes of the Unicode character. It will perform more compares than a true
Boyer-Moore but the skip table still has 256 entries instead of
the 65536 entries in an unmodified Boyer-Moore. Thus hashing a character that
is not in the search string to a character in the search string's entry,
the skip will be smaller than if the real entry was used. }
function PrepareSearch(const SearchString: WideString;
Options: TFindOptions): TSearchRec;
var
I, L, N: Integer;
W: Word;
begin
L := Length(SearchString);
N := L;
Result.Options := Options;
// Set up the Boyer-Moore table
if not (frDown in Options) then
N := -L;
for I := Low(Result.BMTable) to High(Result.BMTable) do
Result.BMTable[I] := N;
if frDown in Options then
for I := 1 to L - 1 do
begin
W := Word(SearchString[I]);
if not (frMatchCase in Options) then
W := Word(UpperCaseWideChar(WideChar(W)));
Result.BMTable[Hi(W) xor Lo(W)] := L - I
end
else
for I := 2 to L do
begin
W := Word(SearchString[I]);
if not (frMatchCase in Options) then
W := Word(UpperCaseWideChar(WideChar(W)));
Result.BMTable[Hi(W) xor Lo(W)] := -I + 1;
end
end;
function SearchForward(const Text: WideString; SelStart, SelLength: Integer;
const SearchString: WideString; const SearchRec: TSearchRec): Integer;
var
K, L, PL: Integer;
I, J: Integer;
W: Word;
begin
L := Length(Text);
PL := Length(SearchString);
K := SelStart + PL;
while K <= L do
begin
I := K;
J := PL;
while J >= 1 do
if Text[I] = SearchString[J] then
begin
Dec(I);
Dec(J);
end
else
Break;
if J = 0 then
begin
Result := I + 1;
Exit;
end;
W := Word(Text[K]);
Inc(K, SearchRec.BMTable[Hi(W) xor Lo(W)]);
end;
Result := 0;
end;
function SearchBackward(const Text: WideString; SelStart, SelLength: Integer;
const SearchString: WideString; const SearchRec: TSearchRec): Integer;
var
K, PL: Integer;
I, J: Integer;
W: Word;
begin
PL := Length(SearchString);
K := SelStart - PL;
while K > 0 do
begin
I := K;
J := 1;
while J < PL do
if Text[I] = SearchString[J] then
begin
Inc(I);
Inc(J);
end
else
Break;
if J = PL then
begin
Result := K;
Exit;
end;
W := Word(Text[K]);
Inc(K, SearchRec.BMTable[Hi(W) xor Lo(W)]);
end;
Result := 0;
end;
function SearchForwardIgnoreCase(const Text: WideString; SelStart,
SelLength: Integer; const SearchString: WideString;
const SearchRec: TSearchRec): Integer;
var
K, L, PL: Integer;
I, J: Integer;
W: Word;
begin
L := Length(Text);
PL := Length(SearchString);
K := SelStart + PL;
while K <= L do
begin
I := K;
J := PL;
while J >= 1 do
if UpperCaseWideChar(Text[I]) = UpperCaseWideChar(SearchString[J]) then
begin
Dec(I);
Dec(J);
end
else
Break;
if J = 0 then
begin
Result := I + 1;
Exit;
end;
W := Word(UpperCaseWideChar(Text[K]));
Inc(K, SearchRec.BMTable[Hi(W) xor Lo(W)]);
end;
Result := 0;
end;
function SearchBackwardIgnoreCase(const Text: WideString; SelStart,
SelLength: Integer; const SearchString: WideString;
const SearchRec: TSearchRec): Integer;
var
K, PL: Integer;
I, J: Integer;
W: Word;
begin
PL := Length(SearchString);
K := SelStart - PL;
while K > 0 do
begin
I := K;
J := 1;
while J < PL do
if UpperCaseWideChar(Text[I]) = UpperCaseWideChar(SearchString[J]) then
begin
Inc(I);
Inc(J);
end
else
Break;
if J = PL then
begin
Result := K;
Exit;
end;
W := Word(UpperCaseWideChar(Text[K]));
Inc(K, SearchRec.BMTable[Hi(W) xor Lo(W)]);
end;
Result := 0;
end;
function Search(const Text: WideString; SelStart, SelLength: Integer;
const SearchString: WideString; const SearchRec: TSearchRec): Integer; overload;
begin
while True do
begin
if frDown in SearchRec.Options then
if frMatchCase in SearchRec.Options then
Result := SearchForward(Text, SelStart, SelLength, SearchString, SearchRec)
else
Result := SearchForwardIgnoreCase(Text, SelStart, SelLength, SearchString,
SearchRec)
else
if frMatchCase in SearchRec.Options then
Result := SearchBackward(Text, SelStart, SelLength, SearchString, SearchRec)
else
Result := SearchBackwardIgnoreCase(Text, SelStart, SelLength, SearchString,
SearchRec);
if Result = 0 then Exit;
if frWholeWord in SearchRec.Options then
// Make sure we found a whole word, if not continue searching
if ((Result = 1) or (Ord(Text[Result - 1]) > 255) or
(Char(Text[Result - 1]) in WordDelimiters)) and
((Result = Length(Text) - Length(SearchString) + 1) or (Ord(Text[Result +
Length(SearchString)]) > 255) or (Char(Text[Result + Length(SearchString)]) in
WordDelimiters)) then
Exit
else
begin
SelStart := Result;
SelLength := 0;
end
else
Exit;
end;
end;
function Search(const Text: WideString; SelStart, SelLength: Integer;
const SearchString: WideString; Options: TFindOptions): Integer; overload;
begin
Result := Search(Text, SelStart, SelLength, SearchString,
PrepareSearch(SearchString, Options));
end;
function Search(EditControl: TCustomEdit; const SearchString: WideString;
const SearchRec: TSearchRec): Boolean; overload;
var
Text: WideString;
Index: Integer;
begin
Result := False;
if (Length(SearchString) = 0) then Exit;
Text := EditControl.Text;
if Length(Text) = 0 then Exit;
Index := Search(Text, EditControl.SelStart, EditControl.SelLength,
SearchString, SearchRec);
if Index > 0 then
begin
EditControl.SelStart := Index;
EditControl.SelLength := Length(SearchString);
Result := True;
end;
end;
function Search(EditControl: TCustomEdit; const SearchString: WideString;
Options: TFindOptions): Boolean; overload;
begin
Result := Search(EditControl, SearchString, PrepareSearch(SearchString,
Options));
end;
function Search(MemoControl: TCustomMemo; const SearchString: WideString;
const SearchRec: TSearchRec): Boolean; overload;
var
Text: WideString;
Index: Integer;
begin
Result := False;
if (Length(SearchString) = 0) then Exit;
Text := MemoControl.Text;
if Length(Text) = 0 then Exit;
Index := Search(Text, MemoControl.SelStart, MemoControl.SelLength,
SearchString, SearchRec);
if Index > 0 then
begin
MemoControl.SelStart := Index;
MemoControl.SelLength := Length(SearchString);
Result := True;
end;
end;
function Search(MemoControl: TCustomMemo; const SearchString: WideString;
Options: TFindOptions): Boolean; overload;
begin
Result := Search(MemoControl, SearchString, PrepareSearch(SearchString,
Options));
end;
end.
|
unit BrickCamp.Repositories.TProduct;
interface
uses
System.JSON,
Spring.Container.Injection,
Spring.Container.Common,
BrickCamp.IDB,
BrickCamp.Model.TProduct,
BrickCamp.Repositories.IProduct;
type
TProductRepository = class(TInterfacedObject, IProductRepository)
protected
[Inject]
FDb: IBrickCampDb;
public
function GetOne(const Id: Integer): TProduct;
function GetList: TJSONArray;
procedure Insert(const Product: TProduct);
procedure Update(const Product: TProduct);
procedure Delete(const Id: Integer);
end;
implementation
uses
Spring.Collections,
MARS.Core.Utils;
{ TProductRepository }
procedure TProductRepository.Delete(const Id: Integer);
var
Product: TProduct;
begin
Product := FDb.GetSession.FindOne<TProduct>(Id);
if Assigned(Product) then
FDb.GetSession.Delete(Product);
end;
function TProductRepository.GetList: TJSONArray;
var
LList: IList<TProduct>;
LItem: TProduct;
begin
LList := FDb.GetSession.FindAll<TProduct>;
result := TJSONArray.Create;
for LItem in LList do
Result.Add(ObjectToJson(LItem));
end;
function TProductRepository.GetOne(const Id: Integer): TProduct;
begin
result := FDb.GetSession.FindOne<TProduct>(Id);
end;
procedure TProductRepository.Insert(const Product: TProduct);
begin
FDb.GetSession.Insert(Product);
end;
procedure TProductRepository.Update(const Product: TProduct);
begin
FDb.GetSession.Update(Product);
end;
end.
|
(* Syntaxtree Abstract: MM, 2020-05-01 *)
(* ------ *)
(* A unit to display syntax trees in abstract form *)
(* ========================================================================= *)
UNIT syntaxtree_abstract;
INTERFACE
TYPE SynTree = POINTER;
PROCEDURE NewTree(VAR t: SynTree);
PROCEDURE DisposeTree(VAR t: SynTree);
PROCEDURE WriteTree(t: SynTree);
PROCEDURE WriteTreePreOrder(t: SynTree);
PROCEDURE WriteTreeInOrder(t: SynTree);
PROCEDURE WriteTreePostOrder(t: SynTree);
FUNCTION ValueOf(t: Syntree): INTEGER;
PROCEDURE S(VAR t: SynTree);
VAR line: STRING;
IMPLEMENTATION
TYPE
NodePtr = ^Node;
Node = RECORD
left, right: NodePtr;
val: STRING;
END;
TreePtr = NodePtr;
(*-- Functions for Tree --*)
PROCEDURE NewTree(VAR t: SynTree);
BEGIN (* NewTree *)
TreePtr(t) := NIL;
END; (* NewTree *)
PROCEDURE DisposeTree(VAR t: SynTree);
BEGIN (* DisposeTree *)
IF (TreePtr(t) <> NIL) THEN BEGIN
DisposeTree(TreePtr(t)^.left);
DisposeTree(TreePtr(t)^.right);
Dispose(TreePtr(t));
END; (* IF *)
END; (* DisposeTree *)
FUNCTION NewNode(x: STRING): NodePtr;
VAR n: NodePtr;
BEGIN (* NewNode *)
New(n);
n^.val := x;
n^.left := NIL;
n^.right := NIL;
NewNode := n;
END; (* NewNode *)
PROCEDURE WriteTreeRec(t: SynTree; space: INTEGER);
VAR i: INTEGER;
BEGIN (* WriteTree *)
IF (t <> NIL) THEN BEGIN
space := space + 10;
WriteTreeRec(TreePtr(t)^.right, space);
WriteLn;
FOR i := 10 TO space DO BEGIN
Write(' ');
END; (* FOR *)
WriteLn(TreePtr(t)^.val);
WriteTreeRec(TreePtr(t)^.left, space);
END; (* IF *)
END; (* WriteTree *)
PROCEDURE WriteTree(t: Syntree);
BEGIN (* WriteTree *)
WriteTreeRec(t, 0);
END; (* WriteTree *)
FUNCTION TreeOf(s: STRING; t1, t2: TreePtr): TreePtr;
VAR n: NodePtr;
BEGIN (* TreeOf *)
n := NewNode(s);
n^.left := t1;
n^.right := t2;
TreeOf := n;
END; (* TreeOf *)
PROCEDURE WriteTreePreOrder(t: SynTree);
BEGIN (* WriteTreePreOrder *)
IF (TreePtr(t) <> NIL) THEN BEGIN
WriteLn(TreePtr(t)^.val);
WriteTreePreOrder(TreePtr(t)^.left);
WriteTreePreOrder(TreePtr(t)^.right);
END; (* IF *)
END; (* WriteTreePreOrder *)
PROCEDURE WriteTreeInOrder(t: SynTree);
BEGIN (* WriteTreeInOrder *)
IF (t <> NIL) THEN BEGIN
WriteTreeInOrder(TreePtr(t)^.left);
WriteLn(TreePtr(t)^.val);
WriteTreeInOrder(TreePtr(t)^.right);
END; (* IF *)
END; (* WriteTreeInOrder *)
PROCEDURE WriteTreePostOrder(t: SynTree);
BEGIN (* WriteTreePostOrder *)
IF (t <> NIL) THEN BEGIN
WriteTreePostOrder(TreePtr(t)^.left);
WriteTreePostOrder(TreePtr(t)^.right);
WriteLn(TreePtr(t)^.val);
END; (* IF *)
END; (* WriteTreePostOrder *)
FUNCTION ToInt(s: STRING): INTEGER;
VAR i, sum: INTEGER;
BEGIN (* ToInt *)
sum := 0;
FOR i := 1 TO Length(s) DO BEGIN
sum := sum * 10 + Ord(s[i]) - Ord('0');
END; (* FOR *)
ToInt := sum;
END; (* ToInt *)
FUNCTION ValueOfTreePtr(t: TreePtr): INTEGER;
BEGIN (* ValueOfTreePtr *)
IF (t <> NIL) THEN BEGIN
CASE t^.val[1] OF
'+': BEGIN ValueOfTreePtr := ValueOfTreePtr(t^.left) + ValueOfTreePtr(t^.right); END;
'-': BEGIN ValueOfTreePtr := ValueOfTreePtr(t^.left) - ValueOfTreePtr(t^.right); END;
'*': BEGIN ValueOfTreePtr := ValueOfTreePtr(t^.left) * ValueOfTreePtr(t^.right); END;
'/': BEGIN ValueOfTreePtr := ValueOfTreePtr(t^.left) DIV ValueOfTreePtr(t^.right); END;
ELSE BEGIN
ValueOfTreePtr := ToInt(t^.val);
END; (* ELSE *)
END; (* CASE *)
END; (* IF *)
END; (* ValueOfTreePtr *)
FUNCTION ValueOf(t: SynTree): INTEGER;
BEGIN (* ValueOf *)
ValueOf := ValueOfTreePtr(TreePtr(t));
END; (* ValueOf *)
(*-- END Functions for Tree --*)
(*-- Functions for Data Analysis --*)
CONST
EOS_CH = Chr(0);
TYPE
SymbolCode = (noSy, (* error symbol *)
eosSy, (* end of string symbol*)
plusSy, minusSy, timesSy, divSy,
leftParSy, rightParSy,
number);
VAR
ch: CHAR;
cnr: INTEGER;
sy: SymbolCode;
numberVal: INTEGER;
success: BOOLEAN;
PROCEDURE Expr(VAR e: TreePtr) FORWARD;
PROCEDURE Term(VAR t: TreePtr) FORWARD;
PROCEDURE Fact(VAR f: TreePtr) FORWARD;
(* SCANNER *)
PROCEDURE NewCh;
BEGIN (* NewCh *)
IF (cnr < Length(line)) THEN BEGIN
Inc(cnr);
ch := line[cnr];
END ELSE BEGIN
ch := EOS_CH;
END; (* IF *)
END; (* NewCh *)
PROCEDURE NewSy;
BEGIN (* NewSy *)
WHILE (ch = ' ') DO BEGIN
NewCh;
END; (* WHILE *)
CASE ch OF
EOS_CH: BEGIN sy := eosSy; END;
'+': BEGIN sy := plusSy; NewCh; END;
'-': BEGIN sy := minusSy; NewCh; END;
'*': BEGIN sy := timesSy; NewCh; END;
'/': BEGIN sy := divSy; NewCh; END;
'(': BEGIN sy := leftParSy; NewCh; END;
')': BEGIN sy := rightParSy; NewCh; END;
'0'..'9': BEGIN
sy := number;
numberVal := 0;
WHILE ((ch >= '0') AND (ch <= '9')) DO BEGIN
numberVal := numberVal * 10 + Ord(ch) - Ord('0');
NewCh;
END; (* WHILE *)
END;
ELSE BEGIN
sy := noSy;
END;
END; (* CASE *)
END; (* NewSy *)
(* END SCANNER *)
(* PARSER *)
PROCEDURE InitParser;
BEGIN (* InitParser *)
success := TRUE;
cnr := 0;
END; (* InitParser *)
PROCEDURE S(VAR t: SynTree);
BEGIN (* S *)
InitParser;
NewCh;
NewSy;
Expr(TreePtr(t)); IF (NOT success) THEN Exit;
IF (NOT success) THEN BEGIN
DisposeTree(t);
t := NIL;
Exit;
END; (* IF *)
IF (sy <> eosSy) THEN BEGIN
success := FALSE;
EXIT;
END; (* IF *)
END; (* S *)
PROCEDURE Expr(VAR e: TreePtr);
VAR t: TreePtr;
BEGIN (* Expr *)
Term(e); IF (NOT success) THEN Exit;
WHILE ((sy = plusSy) OR (sy = minusSy)) DO BEGIN
CASE sy OF
plusSy: BEGIN
NewSy;
Term(t); IF (NOT success) THEN Exit;
e := TreeOf('+', e, t);
END;
minusSy: BEGIN
NewSy;
Term(t); IF (NOT success) THEN Exit;
e := TreeOf('-', e, t);
END;
END; (* CASE *)
END; (* WHILE *)
END; (* Expr *)
PROCEDURE Term(VAR t: TreePtr);
VAR f: TreePtr;
BEGIN (* Term *)
Fact(t); IF (NOT success) THEN Exit;
WHILE ((sy = timesSy) OR (sy = divSy)) DO BEGIN
CASE sy OF
timesSy: BEGIN
NewSy;
Fact(f); IF (NOT success) THEN Exit;
t := TreeOf('*', t, f);
END;
divSy: BEGIN
NewSy;
Fact(f); IF (NOT success) THEN Exit;
t := TreeOf('/', t, f);
END;
END; (* CASE *)
END; (* WHILE *)
END; (* Term *)
PROCEDURE Fact(VAR f: TreePtr);
VAR n: STRING;
BEGIN (* Fact *)
CASE sy OF
number: BEGIN
n := Chr(Ord(numberVal) + Ord('0'));
f := TreeOf(n, NIL, NIL);
NewSy;
END;
leftParSy: BEGIN
NewSy;
Expr(f); IF (NOT success) THEN Exit;
IF (sy <> rightParSy) THEN BEGIN
success := FALSE;
Exit;
END; (* IF *)
NewSy;
END;
ELSE BEGIN
success := FALSE;
Exit;
END;
END; (* CASE *)
END; (* Fact *)
(* END PARSER *)
BEGIN (* syntaxtree_canon *)
END. (* syntaxtree_canon *) |
unit sysutils_getcallstack_3;
interface
implementation
uses sys.rtti, sys.utils;
type
TStrArray = array of string;
var CS: TCallStack;
Names: TStrArray;
function GetProcNames(CS: TCallStack): TStrArray;
begin
SetLength(Result, Length(CS));
for var i := 0 to Length(CS) - 1 do
Result[i] := CS[i].ProcInfo.Name;
end;
procedure TestInner(c: integer);
begin
if c < 3 then
begin
inc(c);
TestInner(c);
end else if c = 3 then
begin
CS := GetCallStack();
Names := GetProcNames(CS);
end;
end;
procedure Test;
begin
TestInner(0);
end;
initialization
Test();
finalization
Assert(Length(CS) = 6);
Assert(Names[0] = 'TestInner');
Assert(Names[1] = 'TestInner');
Assert(Names[2] = 'TestInner');
Assert(Names[3] = 'TestInner');
Assert(Names[4] = 'Test');
Assert(Names[5] = '$initialization');
end. |
unit xpParse;
(*
* The contents of this file are subject to the Mozilla Public
* License Version 1.1 (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.mozilla.org/MPL/
*
* 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.
*
* This code was inspired to expidite the creation of unit tests
* for use the Dunit test frame work.
*
* The Initial Developer of XPGen is Michael A. Johnson.
* Portions created The Initial Developer is Copyright (C) 2000.
* Portions created by The DUnit Group are Copyright (C) 2000.
* All rights reserved.
*
* Contributor(s):
* Michael A. Johnson <majohnson@golden.net>
* Juanco Aņez <juanco@users.sourceforge.net>
* Chris Morris <chrismo@users.sourceforge.net>
* Jeff Moore <JeffMoore@users.sourceforge.net>
* The DUnit group at SourceForge <http://dunit.sourceforge.net>
*
*)
{
Unit : xpParse
Description : defines the real "parser" that recognizes the necessary parts of
a delphi file. The parse step generates parse nodes that are
then useful in generating the test stubs for inclusion in dunit.
Programmer : Michael A. Johnson
Date : 03-Jul-2000
}
interface
uses
xpLex,
Classes,
ParseDef,
SysUtils;
type
EUnitIDExpected = class(Exception);
EEqualExpected = class(Exception);
EBadConstInit = class(Exception);
lex_token = record
Str: string;
token_type: token_enum;
end;
TParseNodeClass = class
fNameClass: string;
fPubMethodList: TStringList;
fPrtMethodList: TStringList;
fPvtMethodList: TSTringList;
public
constructor Create(newName: string); virtual;
destructor Destroy; override;
property PubMethodList: TStringList read fpubMethodList write fpubMethodList;
property PrtMethodList: TStringList read fPrtMethodList write fPrtMethodList;
property PvtMethodList: TSTringList read fPvtMethodList write fPvtMethodList;
property NameClass: string read fNameClass write fNameClass;
end;
TXPStubParser = class
protected
funitName: string;
lex: TLexer;
fSrcStream: TStream;
fParseNodeList: TList;
procedure SetSrcStream(NewStream: TStream);
procedure NewClassNode(NameOfNode: string);
procedure NewPubMethodIdent(NameOfMethod: string);
procedure NewPvtMethodIdent(NameOfMethod: string);
procedure NewPrtMethodIdent(NameOfMethod: string);
function Get_Token(lex: TLexer): lex_token;
function Parse_Unit_Heading(lex: TLexer): lex_token;
function Parse_const_Paragraph(lex: TLexer): lex_token;
function Parse_type_Paragraph(lex: TLexer): lex_token;
function Parse_var_paragraph(lex: TLexer): lex_token;
function Parse_uses_clause(lex: TLexer): lex_token;
function Parse_typedef(ident: string; lex: TLexer): lex_token;
function Parse_tobject_derived(token: lex_token; lex: TLexer): lex_token;
function Parse_derived(ident: string; lex: TLexer): lex_token;
function SyncToken(target: token_enum; lex: TLexer): lex_token;
function ParseEventDef(token : lex_token;lex: TLexer): lex_token;
procedure EmptyParseNodeList;
public
constructor Create; virtual;
destructor Destroy; override;
procedure Parse;
property SrcStream: TStream read fSrcStream write SetSrcStream;
property unitName: string read funitName write funitName;
property ParseNodeList: TList read fParseNodeList write fParseNodeList;
end;
implementation
uses
ListSupport;
function TXPStubParser.Get_Token(lex: TLexer): lex_token;
begin
result.Str := lex.tokenString;
result.token_type := TokenToTokenType(result.str);
lex.NextToken;
end;
function TXPStubParser.Parse_const_Paragraph(lex: TLexer): lex_token;
begin
result := Get_Token(lex);
repeat
case result.token_type of
kw_ident:
begin
result := Get_Token(lex);
case result.token_type of
{ typical const }
kw_equal:
begin
result := SyncToken(kw_semi, lex);
result := Get_Token(lex);
end;
{ typed constant }
kw_colon:
begin
result := SyncToken(kw_equal, lex);
result := Get_Token(lex);
case result.token_type of
kw_openParen:
begin
result := SyncToken(kw_closeParen, lex);
repeat
result := Get_Token(lex);
until (lex.Token = toEof) or (result.token_type = kw_semi);
result := Get_Token(lex);
end;
kw_openbracket:
begin
result := SyncToken(kw_closebracket, lex);
repeat
result := Get_Token(lex);
until (lex.Token = toEof) or (result.token_type = kw_semi);
result := Get_Token(lex);
end;
kw_ident:
begin
result := SyncToken(kw_semi,lex);
result := Get_Token(lex);
end;
else
raise EBadConstInit.create('Expected '' or ( after constant assignment');
end
end;
end;
end;
else
exit; { anything else should be handled by something else }
end;
until (lex.token = toEof);
end;
function TXPStubParser.parse_type_Paragraph(lex: TLexer): lex_token;
begin
result := Get_Token(lex);
repeat
case result.token_type of
kw_ident: result := parse_typedef(result.Str, lex);
kw_semi: result := Get_Token(lex);
kw_end:
begin
result := Get_Token(lex);
end;
else
exit; { anything else should be handled by something else }
end;
until (lex.token = toEof);
end;
function TXPStubParser.Parse_Unit_Heading(lex: TLexer): lex_token;
begin
result := Get_Token(lex);
case result.token_type of
kw_ident:
begin
funitName := result.str;
result := SyncToken(kw_semi, lex);
end
else
raise EUnitIDExpected.create('Unit Name Identifier Expected');
end;
end;
function TXPStubParser.parse_var_paragraph(lex: TLexer): lex_token;
begin
result := Get_Token(lex);
repeat
case result.token_type of
kw_ident:
begin
result := SyncToken(kw_semi, lex);
result := Get_Token(lex);
end;
else
exit;
end;
until (lex.Token = toEof);
end;
function TXPStubParser.parse_uses_clause(lex: TLexer): lex_token;
begin
{ skip tokens until we get to the end of the uses clause }
result := SyncToken(kw_semi, lex);
end;
function TXPStubParser.parse_typedef(ident: string; lex: TLexer): lex_token;
begin
result := Get_Token(lex);
case result.token_type of
kw_equal:
begin
result := Get_Token(lex);
case result.token_type of
kw_class:
begin
result := Get_Token(lex);
case result.token_type of
kw_protected,
kw_public,
kw_private,
kw_ident:
begin {
fo0 = class
end;
}
NewClassNode(ident);
result := parse_tobject_derived(result, lex);
end;
kw_openParen:
begin
NewClassNode(ident);
result := parse_derived(result.Str, lex);
end;
kw_of :
begin
result := SyncToken(kw_semi,lex);
end;
kw_semi:
begin
{ nop to ignore forward def. }
{ i.e tform2 = class; }
exit;
end;
end;
end;
kw_ptr:
begin
{ skip ptr def - ie intPtr = ^integer; }
result := SyncToken(kw_semi, lex);
end;
kw_procedure :
begin
result := ParseEventDef(result,lex);
{ SyncToken(kw_rightParen, lex);}
end;
kw_interface :
begin
result := Get_Token(lex);
if result.token_type <> kw_semi then
begin
{ scan to the end of the interface def }
result := SyncToken(kw_end, lex);
{ skip the trailing semi }
result := SyncToken(kw_semi, lex);
end;
end;
kw_record:
begin
{ scan to the end of the record def }
result := SyncToken(kw_end, lex);
{ skip the trailing semi }
result := SyncToken(kw_semi, lex);
end;
kw_openParen:
begin
result := SyncToken(kw_closeParen,lex);
result := SyncToken(kw_semi, lex);
end;
end;
end
else
raise EEqualExpected.Create('= expected but found : ' + result.str+' srcLine : '+IntToStr(lex.sourceLine));
end;
end;
function TXPStubParser.parse_derived(ident: string; lex: TLexer): lex_token;
begin
result := Get_Token(lex);
if result.token_type = kw_ident then
begin
result := Get_Token(lex);
if result.token_type = kw_comma then
result := SyncToken(kw_closeParen,lex);
if result.token_type = kw_CloseParen then
begin
result := Get_Token(lex);
case result.token_type of
kw_semi: exit;
else
result := parse_tobject_derived(result, lex);
end;
end;
end;
end;
function TXPStubParser.parse_tobject_derived(token: lex_token; lex: TLexer): lex_token;
var
Visibility: MethodVisibility;
begin
{ assume class was compiled in $M+ state, even it it wasn't so that non
specified members are assumed public }
Visibility := kw_public;
result := token;
repeat
case result.token_type of
kw_ident:
begin
result := SyncToken(kw_semi, lex);
end;
kw_function:
begin
result := Get_Token(lex);
if result.token_type = kw_ident then
begin
case visibility of
kw_private: NewPvtMethodIdent(result.str);
kw_protected: NewPrtMethodIdent(result.str);
kw_published,
kw_public,
kw_automated:
NewPubMethodIdent(result.str);
end;
result := Get_Token(lex);
case result.token_type of
kw_colon:
begin
result := SyncToken(kw_semi, lex);
result := Get_Token(lex);
end;
kw_openParen:
begin
result := SyncToken(kw_closeParen, lex);
result := SyncToken(kw_semi, lex);
result := Get_Token(lex);
end;
else
raise exception.create('expected paramlist or return type');
end;
end;
end;
kw_procedure:
begin
result := Get_Token(lex);
if result.token_type = kw_ident then
begin
case visibility of
kw_private: NewPvtMethodIdent(result.str);
kw_protected: NewPrtMethodIdent(result.str);
kw_published,
kw_public,
kw_automated:
NewPubMethodIdent(result.str);
end;
result := Get_Token(lex);
case result.token_type of
kw_semi: result := Get_Token(lex);
kw_openParen:
begin
result := SyncToken(kw_closeParen, lex);
result := Get_Token(lex);
end;
end
end
else
raise exception.create('ident expected');
end;
kw_private,
kw_protected,
kw_published,
kw_public,
kw_automated:
begin
Visibility := result.token_type;
result := Get_Token(lex);
end;
else
result := Get_Token(lex);
end;
until (lex.token = toEof) or (result.token_type = kw_end);
end;
function TXPStubParser.SyncToken(target: token_enum; lex: TLexer): lex_token;
begin
repeat
result := Get_Token(lex);
until (lex.token = toEof) or (result.token_type = target);
end;
procedure TXPStubParser.SetSrcStream(newStream: TStream);
begin
fSrcStream := newStream;
end;
constructor TXPStubParser.Create;
begin
lex := nil;
fSrcStream := nil;
fParseNodeList := TList.Create;
inherited Create;
end;
procedure TXPStubParser.Parse;
var
token: lex_token;
begin
EmptyParseNodeList;
Lex := nil;
try
Lex := TLexer.create(fSrcStream);
token := Get_Token(lex);
while lex.Token <> toEof do
begin
case token.token_type of
Kw_unit:
token := Parse_Unit_Heading(lex);
kw_uses:
token := parse_uses_clause(lex);
Kw_const:
token := Parse_const_Paragraph(lex);
Kw_type:
token := parse_type_Paragraph(lex);
kw_interface:
token := Get_Token(lex);
kw_var:
token :=
parse_var_paragraph(lex);
kw_implementation:
break; { stop when we hit the implemation kw }
else
token := Get_Token(lex);
end;
end;
finally
Lex.Free;
end;
end;
destructor TXPStubParser.Destroy;
begin
{ clean up any left over parseNodes }
ListFreeObjectItems(fParseNodeList);
fParseNodeList.Free;
inherited Destroy;
end;
{ TParseNodeClass }
constructor TParseNodeClass.Create(newName: string);
begin
fNameClass := newName;
fpubMethodList := TStringList.Create;
fPrtMethodList := TStringList.Create;
fPvtMethodList := TSTringList.Create;
inherited Create;
end;
destructor TParseNodeClass.Destroy;
begin
fpubMethodList.Free;
fPrtMethodList.Free;
fPvtMethodList.Free;
inherited Destroy;
end;
procedure TXPStubParser.NewClassNode(nameOfNode: string);
begin
fParseNodeList.Add(TParseNodeClass.Create(NameOfNode));
end;
procedure TXPStubParser.NewPubMethodIdent(nameOfMethod: string);
var
currentNode: Tobject;
begin
currentNode := fParseNodeList.Last;
if currentNode <> nil then
begin
if currentNode is TParseNodeClass then
begin
with currentNode as TParseNodeClass do
begin
PubMethodList.Add(NameOfMethod);
end;
end;
end;
end;
procedure TXPStubParser.NewPrtMethodIdent(NameOfMethod: string);
var
currentNode: Tobject;
begin
currentNode := fParseNodeList.Last;
if currentNode <> nil then
begin
if currentNode is TParseNodeClass then
begin
with currentNode as TParseNodeClass do
begin
PrtMethodList.Add(NameOfMethod);
end;
end;
end;
end;
procedure TXPStubParser.NewPvtMethodIdent(NameOfMethod: string);
var
currentNode: Tobject;
begin
currentNode := fParseNodeList.Last;
if currentNode <> nil then
begin
if currentNode is TParseNodeClass then
begin
with currentNode as TParseNodeClass do
begin
PvtMethodList.Add(NameOfMethod);
end;
end;
end;
end;
procedure TXPStubParser.EmptyParseNodeList;
begin
{ get rid of any pre-existing parse nodes }
ListFreeObjectItems(fParseNodeList);
end;
function TXPStubParser.ParseEventDef(token: lex_token;
lex: TLexer): lex_token;
{
event defs follow the form:
<ident> <eq> <kw_proc> <l_paren> <ident_list> <r_paren> <of> <kw_object> <kw_semi>
}
begin
result := SyncToken(kw_Openparen, lex);
result := SyncToken(kw_Closeparen, lex);
result := SyncToken(kw_object, lex);
result := SyncToken(kw_semi,lex);
end;
end.
|
unit fLkUpLocation;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
fAutoSz, StdCtrls, ORCtrls, ORFn, VA508AccessibilityManager;
type
TfrmLkUpLocation = class(TfrmAutoSz)
lblInfo: TLabel;
cboLocation: TORComboBox;
lblLocation: TLabel;
cmdOK: TButton;
cmdCancel: TButton;
procedure cmdCancelClick(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure cmdOKClick(Sender: TObject);
procedure cboLocationNeedData(Sender: TObject; const StartFrom: String;
Direction, InsertAt: Integer);
private
OKPressed: Boolean;
end;
var
LocType: integer;
procedure LookupLocation(var IEN: Integer; var AName: string; const AType: integer; const HelpInfo: string);
implementation
{$R *.DFM}
uses rCore, uConst;
procedure LookupLocation(var IEN: Integer; var AName: string; const AType: integer; const HelpInfo: string);
var
frmLkUpLocation: TfrmLkUpLocation;
begin
LocType := AType;
frmLkUpLocation := TfrmLkUpLocation.Create(Application);
try
ResizeFormToFont(TForm(frmLkUpLocation));
frmLkUpLocation.lblInfo.Caption := HelpInfo;
frmLkUpLocation.ShowModal;
IEN := 0;
AName := '';
if frmLkUpLocation.OKPressed then
begin
IEN := frmLkUpLocation.cboLocation.ItemIEN;
AName := frmLkUpLocation.cboLocation.Text;
end;
finally
frmLkUpLocation.Release;
end;
end;
procedure TfrmLkUpLocation.FormCreate(Sender: TObject);
begin
inherited;
OKPressed := False;
cboLocation.InitLongList('');
end;
procedure TfrmLkUpLocation.cboLocationNeedData(Sender: TObject; const StartFrom: string;
Direction, InsertAt: Integer);
begin
inherited;
case LocType of
LOC_ALL: cboLocation.ForDataUse(SubSetOfLocations(StartFrom, Direction));
LOC_OUTP: cboLocation.ForDataUse(SubSetOfClinics(StartFrom, Direction));
LOC_INP: cboLocation.ForDataUse(SubSetOfInpatientLocations(StartFrom, Direction));
end;
end;
procedure TfrmLkUpLocation.cmdOKClick(Sender: TObject);
begin
inherited;
OKPressed := True;
Close;
end;
procedure TfrmLkUpLocation.cmdCancelClick(Sender: TObject);
begin
inherited;
Close;
end;
end.
|
unit Musiques;
interface
type
TMusiques = Record
Note1 : string;
Note2 : string;
Note3 : string;
Note4 : string;
Duree : single;
end;
const
// The Bare Necessities
// MELODIE (Main droite)
Musique1_MD: Array[0..27] of TMusiques =(
(Duree:1;)
,(Note1:'Do3'; Duree:1;)
,(Note1:'Re3'; Duree:1;)
,(Note1:'Fa3'; Duree:1;)
,(Duree:1;)
,(Note1:'La3'; Duree:2;)
,(Note1:'Sol3d';Duree:1;)
,(Note1:'La3'; Duree:1;)
,(Note1:'Sol3'; Duree:1;)
,(Note1:'Fa3'; Duree:1;)
,(Note1:'Fa3'; Duree:1;)
,(Note1:'Sol3'; Duree:1;)
,(Note1:'Fa3'; Duree:1;)
,(Note1:'Sol3'; Duree:1;)
,(Note1:'Fa3'; Duree:1;)
,(Note1:'Sol3'; Duree:1;)
,(Note1:'Fa3'; Duree:1;)
,(Note1:'Re3'; Duree:1;)
,(Note1:'Do3'; Duree:1;)
,(Note1:'Fa3'; Duree:1;)
,(Note1:'Do3'; Duree:1;)
,(Note1:'Fa3'; Duree:1;)
,(Note1:'La3'; Duree:1;)
,(Note1:'Re4'; Duree:1;)
,(Note1:'Do4'; Duree:1;)
,(Note1:'La3d'; Duree:1;)
,(Note1:'La3'; Duree:1;)
,(Note1:'Sol3'; Duree:4;)
);
// ACCOMPAGNEMENT "Mélodie" (Main gauche)
Musique1_MG: Array[0..30] of TMusiques =(
(Duree:4;)
,(Note1:'Fa1'; Duree:1;)
,(Duree:1;)
,(Note1:'Do1';Duree:1;)
,(Duree:1;)
,(Note1:'Fa1'; Duree:1;)
,(Duree:1;)
,(Note1:'La1';Duree:1;)
,(Duree:1;)
,(Note1:'La1d'; Duree:1;)
,(Duree:1;)
,(Note1:'Fa1';Duree:1;)
,(Duree:1;)
,(Note1:'La1d'; Duree:1;)
,(Duree:1;)
,(Note1:'Sol1';Duree:1;)
,(Duree:1;)
,(Note1:'Fa1'; Duree:1;)
,(Duree:1;)
,(Note1:'Re1d';Duree:1;)
,(Duree:1;)
,(Note1:'Re1'; Duree:1;)
,(Duree:1;)
,(Note1:'Fa1d';Duree:1;)
,(Duree:1;)
,(Note1:'Sol1'; Duree:1;)
,(Note1:'La1'; Duree:1;)
,(Note1:'La1d';Duree:1;)
,(Note1:'La1d'; Duree:1;)
,(Note1:'Do2'; Duree:1;)
,(Duree:3;)
);
{
// Accompagnement "Accords" (Main Gauche)
Musique1_MG: Array[0..8] of TMusiques =(
(Duree:4;)
,(Note1:'Fa2'; Note2:'La2'; Note3:'Do3'; Note4:'Mi3'; Duree:4;)
,(Note1:'Fa2'; Note2:'La2'; Note3:'Do3'; Note4:'Re3d'; Duree:4;)
,(Note1:'Fa2'; Note2:'La2'; Note3:'Do3d'; Note4:'Re3'; Duree:4;)
,(Note1:'Fa2'; Note2:'Sol2'; Note3:'La3d'; Note4:'Re3'; Duree:4;)
,(Note1:'Fa2'; Note2:'La2'; Note3:'Do3'; Note4:'Re3'; Duree:2;)
,(Note1:'Sol2'; Note2:'La2'; Note3:'Do3'; Note4:'Re3d'; Duree:2;)
,(Note1:'Fa2d'; Note2:'La2'; Note3:'Do3'; Note4:'Re3'; Duree:4;)
,(Note1:'Fa2'; Note2:'Sol2'; Note3:'Si2'; Note4:'Re3'; Duree:4;)
);
}
implementation
end.
|
unit IdLogDebug;
interface
uses
Classes,
IdLogBase,
IdException,
IdSocketHandle;
type
TIdLogDebugTarget = (ltFile, ltDebugOutput, ltEvent);
const
ID_TIDLOGDEBUG_TARGET = ltFile;
type
TLogItemEvent = procedure(ASender: TComponent; var AText: string) of object;
TIdLogDebug = class(TIdLogBase)
protected
FFilename: string;
FFileStream: TFileStream;
FOnLogItem: TLogItemEvent;
FTarget: TIdLogDebugTarget;
procedure Log(AText: string); override;
procedure SetActive(const AValue: Boolean); override;
procedure SetTarget(const AValue: TIdLogDebugTarget);
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
published
property Filename: string read FFilename write FFilename;
property OnLogItem: TLogItemEvent read FOnLogItem write FOnLogItem;
property Target: TIdLogDebugTarget read FTarget write SetTarget default
ID_TIDLOGDEBUG_TARGET;
end;
EIdCanNotChangeTarget = class(EIdException);
implementation
uses
IdGlobal,
IdResourceStrings,
SysUtils;
constructor TIdLogDebug.Create(AOwner: TComponent);
begin
inherited;
FTarget := ID_TIDLOGDEBUG_TARGET;
end;
destructor TIdLogDebug.Destroy;
begin
Active := False;
inherited;
end;
procedure TIdLogDebug.Log(AText: string);
var
s: string;
begin
if assigned(OnLogItem) then
begin
OnLogItem(Self, AText);
end;
case Target of
ltFile:
begin
FFileStream.WriteBuffer(PChar(AText)^, Length(AText));
s := EOL;
FFileStream.WriteBuffer(PChar(s)^, Length(s));
end;
ltDebugOutput:
begin
DebugOutput(AText + EOL);
end;
end;
end;
procedure TIdLogDebug.SetActive(const AValue: Boolean);
begin
if AValue then
begin
case Target of
ltFile:
if not (csLoading in ComponentState) then
begin
if FileExists(Filename) then
begin
FFileStream := TFileStream.Create(Filename, fmOpenReadWrite);
end
else
begin
FFileStream := TFileStream.Create(Filename, fmCreate);
end;
FFileStream.Position := FFileStream.Size;
end;
end;
end
else
begin
case Target of
ltFile:
begin
FreeAndNil(FFileStream);
end;
end;
end;
inherited;
end;
procedure TIdLogDebug.SetTarget(const AValue: TIdLogDebugTarget);
begin
if ([csLoading, csDesigning] * ComponentState = []) and Active then
begin
raise EIdCanNotChangeTarget.Create(RSCannotChangeDebugTargetAtWhileActive);
end;
FTarget := AValue;
end;
end.
|
unit UPedidoDadosGeraisController;
interface
uses
UDmVenda, UPedidoDadosGerais, System.SysUtils, Data.DB;
type
IPedidoDadosGeraisController = interface
function Getobj: TPedidoDadosGerais;
procedure Setobj(const Value: TPedidoDadosGerais);
function lstPedidoDadosGerais: OleVariant;
function incluir(const Value: TPedidoDadosGerais): TPedidoDadosGerais;
function alterar(const Value: TPedidoDadosGerais): TPedidoDadosGerais;
function excluir(const Value: TPedidoDadosGerais): TPedidoDadosGerais;
function BuscaPedido(const Value: TPedidoDadosGerais): TPedidoDadosGerais;
property obj: TPedidoDadosGerais read Getobj write Setobj;
end;
TPedidoDadosGeraisController = class(TInterfacedObject, IPedidoDadosGeraisController)
private
Fobj: TPedidoDadosGerais;
function Getobj: TPedidoDadosGerais;
procedure Setobj(const Value: TPedidoDadosGerais);
public
function lstPedidoDadosGerais: OleVariant;
function incluir(const Value: TPedidoDadosGerais): TPedidoDadosGerais;
function alterar(const Value: TPedidoDadosGerais): TPedidoDadosGerais;
function excluir(const Value: TPedidoDadosGerais): TPedidoDadosGerais;
function BuscaPedido(const Value: TPedidoDadosGerais): TPedidoDadosGerais;
property obj: TPedidoDadosGerais read Getobj write Setobj;
end;
implementation
{ TPedidoDadosGeraisController }
function TPedidoDadosGeraisController.alterar(const Value: TPedidoDadosGerais): TPedidoDadosGerais;
begin
dmVenda.BeginTran;
try
if (dmVenda.qryPedidoGerais.Locate('numero_pedido', Value.numeroPedido, [loCaseInsensitive])) then begin
dmVenda.qryPedidoGerais.Edit;
dmVenda.qryPedidoGerais.FieldByName('numero_pedido').Value := Value.numeroPedido;
dmVenda.qryPedidoGerais.FieldByName('data_emissao').Value := Value.dataEmissao;
dmVenda.qryPedidoGerais.FieldByName('codigo_cliente').Value := Value.cliente.codigo;
dmVenda.qryPedidoGerais.FieldByName('valor_total').Value := Value.valorTotal;
dmVenda.qryPedidoGerais.Post;
end;
dmVenda.CommitTran;
except on E: Exception do
dmVenda.RollbackTran;
end;
Result := BuscaPedido(Value);
end;
function TPedidoDadosGeraisController.BuscaPedido(
const Value: TPedidoDadosGerais): TPedidoDadosGerais;
var
obj: TPedidoDadosGerais;
begin
obj := TPedidoDadosGerais.Create;
dmVenda.qryLstPedGer.Close;
dmVenda.qryLstPedGer.ParamByName('data_emissao').Value := Value.dataEmissao;
dmVenda.qryLstPedGer.ParamByName('codigo_cliente').Value := Value.cliente.codigo;
dmVenda.qryLstPedGer.ParamByName('valor_total').Value := Value.valorTotal;
dmVenda.cdsLstPedGer.Close;
dmVenda.cdsLstPedGer.Open;
if dmVenda.cdsLstPedGer.RecordCount > 0 then begin
obj.numeroPedido := dmVenda.cdsLstPedGer.FieldByName('numero_pedido').Value;
end;
Result := obj;
end;
function TPedidoDadosGeraisController.excluir(const Value: TPedidoDadosGerais): TPedidoDadosGerais;
begin
dmVenda.BeginTran;
try
if (dmVenda.qryPedidoGerais.Locate('numero_pedido', Value.numeroPedido, [loCaseInsensitive])) then begin
dmVenda.qryPedidoGerais.Delete;
end;
dmVenda.CommitTran;
except on E: Exception do
dmVenda.RollbackTran;
end;
Result := BuscaPedido(Value);
end;
function TPedidoDadosGeraisController.Getobj: TPedidoDadosGerais;
begin
Result := Fobj;
end;
function TPedidoDadosGeraisController.incluir(const Value: TPedidoDadosGerais): TPedidoDadosGerais;
const
sql = 'INSERT INTO pedidos_dados_gerais(data_emissao, codigo_cliente, valor_total) '+
'VALUES (:data_emissao, :codigo_cliente, :valor_total)';
begin
dmVenda.BeginTran;
try
dmVenda.exPedGer.CommandText := sql;
dmVenda.exPedGer.ParamByName('data_emissao').Value := Value.dataEmissao;
dmVenda.exPedGer.ParamByName('codigo_cliente').Value := Value.cliente.codigo;
dmVenda.exPedGer.ParamByName('valor_total').Value := Value.valorTotal;
dmVenda.exPedGer.ExecSQL;
dmVenda.CommitTran;
except on E: Exception do
dmVenda.RollbackTran;
end;
Result := BuscaPedido(Value);
end;
function TPedidoDadosGeraisController.lstPedidoDadosGerais: OleVariant;
begin
dmVenda.qryPedidoGerais.Close;
dmVenda.qryPedidoGerais.Open;
Result := dmVenda.dspPedidoGerais.Data;
end;
procedure TPedidoDadosGeraisController.Setobj(const Value: TPedidoDadosGerais);
begin
Fobj := Value;
end;
end.
|
unit UProduto;
interface
uses UGenerico, UMarca, UCategoria, UUnidade;
type Produto = class(Generico)
protected
Tipo : string[1];
umaMarca : Marca;
umaCategoria : Categoria;
umaUnidade : Unidade;
quantidade : Real;
icms : Real;
ipi : Real;
precoCompra : Double;
precoVenda : Real;
icmsAnterior : Real;
ipiAnterior : Real;
precoCompraAnt : Real;
observacao : string[255];
public
Constructor CrieObjeto;
Destructor Destrua_Se;
Procedure setTipo (vTipo : String);
Procedure setUmaMarca (vUmaMarca : Marca);
Procedure setUmaCategoria (vUmaCategoria : Categoria);
Procedure setUmaUnidade (vUnidade : Unidade);
Procedure setQuantidade (vQuantidade : Real);
Procedure setICMS (vICMS : Real);
Procedure setIPI (vIPI : Real);
Procedure setPrecoCompra (vPrecoCompra : Double);
Procedure setPrecoVenda (vPrecoVenda : Real);
Procedure setICMSAnterior (vICMSAnterior : Real);
Procedure setIPIAnterior (vIPIAnterior : Real);
Procedure setPrecoCompraAnt (vPrecoCompraAnt : Real);
Procedure setObservacao (vObservacao : String);
function getTipo : string;
Function getUmaMarca : Marca;
Function getUmaCategoria : Categoria;
Function getUmaUnidade : Unidade;
Function getQuantidade : Real;
Function getICMS : Real;
Function getIPI : Real;
Function getPrecoCompra : Double;
Function getPrecoVenda : Real;
Function getICMSAnterior : Real;
Function getIPIAnterior : Real;
Function getPrecoCompraAnt : Real;
Function getObservacao : String;
//Fornecedor
// procedure CrieObejtoFornecedor;
// procedure addFornecedor(vFornecedor : Fornecedor);
// procedure LimparListaFornecedor;
end;
implementation
{ Produto }
constructor Produto.CrieObjeto;
begin
inherited;
Tipo := '';
umaMarca := Marca.CrieObjeto;
umaCategoria := Categoria.CrieObjeto;
umaUnidade := Unidade.CrieObjeto;
quantidade := 0;
icms := 0;
ipi := 0;
precoCompra := 0;
precoVenda := 0;
icmsAnterior := 0;
ipiAnterior := 0;
precoCompraAnt := 0;
observacao := '';
end;
destructor Produto.Destrua_Se;
begin
end;
function Produto.getICMS: Real;
begin
Result := ICMS;
end;
function Produto.getICMSAnterior: Real;
begin
Result := icmsAnterior;
end;
function Produto.getIPI: Real;
begin
Result := IPI;
end;
function Produto.getIPIAnterior: Real;
begin
Result := ipiAnterior;
end;
function Produto.getObservacao: String;
begin
Result := Observacao;
end;
function Produto.getPrecoCompra: Double;
begin
Result:= precoCompra;
end;
function Produto.getPrecoCompraAnt: Real;
begin
Result := precoCompraAnt;
end;
function Produto.getPrecoVenda: Real;
begin
Result := precoVenda;
end;
function Produto.getQuantidade: Real;
begin
Result := Quantidade;
end;
function Produto.getTipo: string;
begin
Result := Tipo;
end;
function Produto.getUmaCategoria: Categoria;
begin
Result := umaCategoria;
end;
function Produto.getUmaMarca: Marca;
begin
Result := umaMarca;
end;
function Produto.getUmaUnidade: Unidade;
begin
Result := umaUnidade;
end;
procedure Produto.setICMS(vICMS: Real);
begin
ICMS := vICMS
end;
procedure Produto.setICMSAnterior(vICMSAnterior: Real);
begin
icmsAnterior := vICMSAnterior;
end;
procedure Produto.setIPI(vIPI: Real);
begin
IPI := vIPI;
end;
procedure Produto.setIPIAnterior(vIPIAnterior: Real);
begin
ipiAnterior := vIPIAnterior;
end;
procedure Produto.setObservacao(vObservacao: String);
begin
Observacao := vObservacao;
end;
procedure Produto.setPrecoCompra(vPrecoCompra: Double);
begin
PrecoCompra := vPrecoCompra;
end;
procedure Produto.setPrecoCompraAnt(vPrecoCompraAnt: Real);
begin
precoCompraAnt := vPrecoCompraAnt;
end;
procedure Produto.setPrecoVenda(vPrecoVenda: Real);
begin
PrecoVenda := vPrecoVenda;
end;
procedure Produto.setQuantidade(vQuantidade: Real);
begin
Quantidade := vQuantidade;
end;
procedure Produto.setTipo(vTipo: String);
begin
Tipo := vTipo;
end;
procedure Produto.setUmaCategoria(vUmaCategoria: Categoria);
begin
umaCategoria := vUmaCategoria;
end;
procedure Produto.setUmaMarca(vUmaMarca: Marca);
begin
umaMarca := vUmaMarca;
end;
procedure Produto.setUmaUnidade(vUnidade: Unidade);
begin
umaUnidade := vUnidade;
end;
end.
|
/// <summary>
/// <para>
/// These components are for reading and writing the Wallet Keys to a
/// local file.
/// </para>
/// <para>
/// The File Structure is as follows:
/// </para>
/// <list type="table">
/// <listheader>
/// <term>Byte Length</term>
/// <description>Description</description>
/// </listheader>
/// <item>
/// <term>2</term>
/// <description><i>idLength</i>: Integer- Length of wallet
/// identifier.</description>
/// </item>
/// <item>
/// <term>idLength</term>
/// <description>Needs to match the const CT_PrivateKeyFile_Magic
/// if it is a valid wallet</description>
/// </item>
/// <item>
/// <term>4 Bytes</term>
/// <description>File Version</description>
/// </item>
/// <item>
/// <term>4 Bytes</term>
/// <description>Number of Keys</description>
/// </item>
/// <item>
/// <term>Keys</term>
/// <description>For each key:</description>
/// </item>
/// <item>
/// <term>2 Bytes</term>
/// <description><i>keyNameLength</i>: Length of Key Name</description>
/// </item>
/// <item>
/// <term>KeyNameLength</term>
/// <description>Key Name</description>
/// </item>
/// </list>
/// </summary>
unit PascalCoin.Wallet.Classes;
interface
uses System.Classes, System.Generics.Collections, System.SysUtils,
PascalCoin.Wallet.Interfaces, PascalCoin.Utils.Interfaces, Spring;
Type
TOnNeedPassword = procedure(const APassword: string) of object;
TWallet = class(TInterfacedObject, IWallet)
private
FKeyTools: IKeyTools;
FStreamOp: IStreamOp;
FPassword: String;
/// <summary>
/// This is used to lock wallets that aren't encrypted, just a way to
/// prevent silly mistakes - a double check
/// </summary>
FLocked: Boolean;
FState: TEncryptionState;
FWalletFileStream: TFileStream;
FIsReadingStream: Boolean;
// Probably better to use a TDictionary for this
FKeys: TList<IWalletKey>;
FFileVersion: Integer;
FOnLockChange: Event<TPascalCoinBooleanEvent>;
procedure LoadWallet;
procedure LoadWalletFromStream(Stream: TStream);
protected
function SetPassword(const Value: string): Boolean;
function GetWalletKey(const Index: Integer): IWalletKey;
function GetState: TEncryptionState;
function GetLocked: Boolean;
function GetOnLockChange: IEvent<TPascalCoinBooleanEvent>;
function Lock: Boolean;
function Unlock(const APassword: string): Boolean;
function ChangePassword(const Value: string): Boolean;
function GetWalletFileName: String;
function AddWalletKey(Value: IWalletKey): Integer;
function CreateNewKey(const AKeyType: TKeyType;
const AName: string): Integer;
function Count: Integer;
procedure SaveToStream;
function FindKey(const Value: string;
const AEncoding: TKeyEncoding = TKeyEncoding.Hex): IWalletKey;
procedure PublicKeysToStrings(Value: TStrings;
const AEncoding: TKeyEncoding);
property Password: string read FPassword;
public
constructor Create(ATools: IKeyTools; AStreamOp: IStreamOp);
destructor Destroy; override;
end;
TWalletKey = class(TInterfacedObject, IWalletKey)
private
FWallet: TWallet;
FKeyTools: IKeyTools;
FName: String;
FPublicKey: IPublicKey;
FCryptedKey: TRawBytes;
FEncryptionState: TEncryptionState;
procedure Clear;
protected
function GetName: String;
procedure SetName(const Value: String);
function GetPublicKey: IPublicKey;
function GetCryptedKey: TRawBytes;
procedure SetCryptedKey(const Value: TRawBytes);
function GetPrivateKey: IPrivateKey;
function GetState: TEncryptionState;
function GetKeyType: TKeyType;
function HasPrivateKey: Boolean;
public
constructor Create(AKeyTools: IKeyTools; AWallet: TWallet);
end;
TPublicKey = class(TInterfacedObject, IPublicKey)
private
FKeyTools: IKeyTools;
FNID: Word;
FX: TBytes;
FY: TBytes;
protected
function GetNID: Word;
procedure SetNID(const Value: Word);
function GetX: TBytes;
procedure SetX(const Value: TBytes);
function GetY: TBytes;
procedure SetY(const Value: TBytes);
function GetKeyType: TKeyType;
procedure SetKeyType(const Value: TKeyType);
function GetKeyTypeAsStr: string;
procedure SetKeyTypeAsStr(const Value: string);
function GetAsHexStr: string;
function GetAsBase58: string;
public
constructor Create(AKeyTools: IKeyTools);
end;
TPrivateKey = class(TInterfacedObject, IPrivateKey)
private
FKey: TRawBytes;
FKeyType: TKeyType;
protected
function GetKey: TRawBytes;
procedure SetKey(Value: TRawBytes);
function GetKeyType: TKeyType;
procedure SetKeyType(const Value: TKeyType);
function GetAsHexStr: String;
public
constructor Create; overload;
{$IFDEF UNITTEST}
constructor Create(AHexKey: string; const AKeyType: TKeyType); overload;
{$ENDIF UNITTEST}
end;
implementation
uses System.IOUtils, System.Rtti,
PascalCoin.Utils.Classes, PascalCoin.ResourceStrings, PascalCoin.Helpers,
ClpIAsymmetricCipherKeyPair, PascalCoin.FMX.Strings, clpEncoders;
Const
CT_PrivateKeyFile_Magic = 'TWalletKeys';
CT_PrivateKeyFile_Version = 100;
{ TWallet }
function TWallet.AddWalletKey(Value: IWalletKey): Integer;
begin
result := FKeys.Add(Value);
end;
function TWallet.Count: Integer;
begin
result := FKeys.Count;
end;
constructor TWallet.Create(ATools: IKeyTools; AStreamOp: IStreamOp);
begin
inherited Create;
FKeyTools := ATools;
FStreamOp := AStreamOp;
FKeys := TList<IWalletKey>.Create;
FState := esPlainText;
FLocked := True;
LoadWallet;
end;
function TWallet.CreateNewKey(const AKeyType: TKeyType;
const AName: string): Integer;
var
lWalletKey: IWalletKey;
lKeyPair: IAsymmetricCipherKeyPair;
lPrivateKey: TRawBytes;
lPrivateKeyAsHex: String;
begin
lWalletKey := TWalletKey.Create(FKeyTools, Self);
lWalletKey.Name := AName;
lWalletKey.PublicKey.KeyType := AKeyType;
// This is a bit Nasty, but will do until UGO looks into it
repeat
lKeyPair := FKeyTools.GenerateECKeyPair(AKeyType);
lWalletKey.PublicKey.X := FKeyTools.GetPublicKeyAffineX(lKeyPair);
lWalletKey.PublicKey.Y := FKeyTools.GetPublicKeyAffineY(lKeyPair);
until (AKeyType <> TKeyType.SECP256K1) or
lWalletKey.PublicKey.AsBase58.StartsWith('3Ghhb');
lPrivateKey := FKeyTools.GetPrivateKey(lKeyPair);
lPrivateKeyAsHex := FKeyTools.GetPascalCoinPrivateKeyAsHexString(AKeyType,
lPrivateKey);
lWalletKey.CryptedKey := FKeyTools.EncryptPascalCoinPrivateKey
(lPrivateKeyAsHex, FPassword);
result := AddWalletKey(lWalletKey);
SaveToStream;
end;
destructor TWallet.Destroy;
begin
FKeys.Free;
FWalletFileStream.Free;
inherited;
end;
function TWallet.FindKey(const Value: string; const AEncoding: TKeyEncoding)
: IWalletKey;
var
lKey: IWalletKey;
begin
// If Keys was a TDictioary this would be faster
for lKey in FKeys do
begin
case AEncoding of
TKeyEncoding.Hex:
if lKey.PublicKey.AsHexStr = Value then
Exit(lKey);
TKeyEncoding.Base58:
if lKey.PublicKey.AsBase58 = Value then
Exit(lKey);
end;
end;
end;
function TWallet.GetLocked: Boolean;
begin
result := ((FState = esPlainText) and FLocked) or
((FState <> esPlainText) and (FPassword = ''));
end;
function TWallet.GetOnLockChange: IEvent<TPascalCoinBooleanEvent>;
begin
result := FOnLockChange;
end;
function TWallet.GetState: TEncryptionState;
begin
result := FState;
end;
function TWallet.GetWalletFileName: String;
begin
{$IFDEF TESTNET}
result := TPath.Combine(TPath.GetHomePath, 'PascalCoin_URBAN');
{$ELSE}
result := TPath.Combine(TPath.GetHomePath, 'PascalCoin');
{$ENDIF}
result := TPath.Combine(result, 'WalletKeys.dat');
end;
function TWallet.GetWalletKey(const Index: Integer): IWalletKey;
begin
result := FKeys[Index];
end;
procedure TWallet.LoadWallet;
var
lFileName: string;
begin
FIsReadingStream := True;
try
if Assigned(FWalletFileStream) then
begin
FWalletFileStream.Free;
FWalletFileStream := nil;
end;
lFileName := GetWalletFileName;
if TFile.Exists(lFileName) then
FWalletFileStream := TFileStream.Create(lFileName, fmOpenReadWrite or
fmShareDenyWrite)
else
FWalletFileStream := TFileStream.Create(lFileName,
fmCreate or fmShareDenyWrite);
FWalletFileStream.Position := 0;
if (FWalletFileStream.Size - FWalletFileStream.Position > 0) then
begin
try
LoadWalletFromStream(FWalletFileStream);
if Count > 0 then
FState := FKeys[0].State;
except
FWalletFileStream.Free;
end;
end;
finally
FIsReadingStream := False;
end;
end;
procedure TWallet.LoadWalletFromStream(Stream: TStream);
var
s: String;
lRaw, LX, LY: TRawBytes;
nKeys: Integer;
I: Integer;
lWalletKey: IWalletKey;
lNid: Word;
lStr: String;
begin
FStreamOp.ReadRawBytes(Stream, lRaw);
lStr := TEncoding.ASCII.GetString(lRaw);
if Not(String.Compare(lStr, CT_PrivateKeyFile_Magic) = 0) then
raise Exception.Create(InvalidStream + ': ' + Classname);
// Read version:
Stream.Read(FFileVersion, 4);
if (FFileVersion <> CT_PrivateKeyFile_Version) then
begin
// Old version
Stream.Position := Stream.Position - 4;
raise Exception.Create(Classname + ':' + InvalidPrivateKeysFileVersion +
': ' + FFileVersion.ToString);
end;
Stream.Read(nKeys, 4);
for I := 0 to nKeys - 1 do
begin
lWalletKey := TWalletKey.Create(FKeyTools, Self);
FStreamOp.ReadRawBytes(Stream, lRaw);
lWalletKey.Name := TEncoding.ASCII.GetString(lRaw);
Stream.Read(lNid, SizeOf(lNid));
lWalletKey.PublicKey.NID := lNid;
FStreamOp.ReadRawBytes(Stream, LX);
lWalletKey.PublicKey.X := LX;
FStreamOp.ReadRawBytes(Stream, LY);
lWalletKey.PublicKey.Y := LY;
FStreamOp.ReadRawBytes(Stream, lRaw);
lWalletKey.CryptedKey := lRaw;
AddWalletKey(lWalletKey);
end;
end;
function TWallet.Lock: Boolean;
begin
result := True;
if not FLocked then
begin
FLocked := True;
FPassword := '';
FOnLockChange.Invoke(True);
end;
end;
procedure TWallet.PublicKeysToStrings(Value: TStrings;
const AEncoding: TKeyEncoding);
var
lKey: IWalletKey;
begin
for lKey in FKeys do
begin
case AEncoding of
TKeyEncoding.Base58:
Value.Add(lKey.PublicKey.AsBase58);
TKeyEncoding.Hex:
Value.Add(lKey.PublicKey.AsHexStr);
end;
end;
end;
procedure TWallet.SaveToStream;
var
I: Integer;
W: IWalletKey;
lNid: Word;
begin
if FIsReadingStream then
Exit;
if Not Assigned(FWalletFileStream) then
Exit;
FWalletFileStream.Size := 0;
FWalletFileStream.Position := 0;
FStreamOp.WriteRawBytes(FWalletFileStream,
TEncoding.ASCII.GetBytes(CT_PrivateKeyFile_Magic));
I := CT_PrivateKeyFile_Version;
FWalletFileStream.Write(I, 4);
I := FKeys.Count;
FWalletFileStream.Write(I, 4);
for I := 0 to FKeys.Count - 1 do
begin
W := FKeys[I];
FStreamOp.WriteRawBytes(FWalletFileStream,
TEncoding.ASCII.GetBytes(W.Name));
lNid := W.PublicKey.NID;
FWalletFileStream.Write(lNid, SizeOf(lNid));
FStreamOp.WriteRawBytes(FWalletFileStream, W.PublicKey.X);
FStreamOp.WriteRawBytes(FWalletFileStream, W.PublicKey.Y);
FStreamOp.WriteRawBytes(FWalletFileStream, W.CryptedKey);
end;
end;
function TWallet.SetPassword(const Value: string): Boolean;
var
lPlainKey: TRawBytes;
begin
if Value = FPassword then
Exit(True);
if FState = esPlainText then
raise Exception.Create(STheWalletIsNotEncrypted);
if (FPassword <> '') then
raise Exception.Create(SThisDoesnTMatchThePasswordAlread);
if Count = 0 then
begin
FPassword := Value;
Exit(True);
end;
// does it work?
result := FKeyTools.DecryptPascalCoinPrivateKey
(FKeys[0].CryptedKey.ToHexaString, Value, lPlainKey);
if result then
FPassword := Value;
end;
function TWallet.ChangePassword(const Value: string): Boolean;
var
lOldPassword, lHexKey: string;
lPlainKey, lPassword: TRawBytes;
lWalletKey: IWalletKey;
begin
if FPassword = Value then
begin
Exit(Unlock(Value));
end;
lOldPassword := FPassword;
lPassword.FromString(lOldPassword);
for lWalletKey in FKeys do
begin
if not FKeyTools.DecryptPascalCoinPrivateKey
(lWalletKey.CryptedKey.ToHexaString, lOldPassword, lPlainKey) then
begin
raise Exception.Create('Unable to decrypt key!');
end;
lHexKey := lPlainKey.ToHexaString;
lWalletKey.CryptedKey := FKeyTools.EncryptPascalCoinPrivateKey
(lHexKey, Value);
end;
FPassword := Value;
SaveToStream;
result := Unlock(Value);
end;
function TWallet.Unlock(const APassword: string): Boolean;
begin
// Check for already Unlocked
if not GetLocked then
Exit(True);
if (FState = esEncrypted) then
begin
if (APassword = '') then
Exit(False);
result := SetPassword(APassword);
end
else
result := True;
if result then
begin
FLocked := False;
FOnLockChange.Invoke(False);
end;
end;
{ TWalletKey }
procedure TWalletKey.Clear;
begin
FPublicKey := nil;
FEncryptionState := esPlainText;
SetLength(FCryptedKey, 0);
end;
constructor TWalletKey.Create(AKeyTools: IKeyTools; AWallet: TWallet);
begin
inherited Create;
FKeyTools := AKeyTools;
FWallet := AWallet;
Clear;
end;
function TWalletKey.GetPublicKey: IPublicKey;
begin
if FPublicKey = nil then
FPublicKey := TPublicKey.Create(FKeyTools);
result := FPublicKey;
end;
function TWalletKey.GetState: TEncryptionState;
begin
result := FEncryptionState;
end;
function TWalletKey.GetCryptedKey: TBytes;
begin
result := FCryptedKey;
end;
function TWalletKey.GetKeyType: TKeyType;
begin
result := FPublicKey.KeyType;
end;
function TWalletKey.GetName: String;
begin
result := FName;
end;
function TWalletKey.GetPrivateKey: IPrivateKey;
var
lKey: TRawBytes;
begin
result := TPrivateKey.Create;
result.KeyType := FPublicKey.KeyType;
if FKeyTools.DecryptPascalCoinPrivateKey(FCryptedKey.ToHexaString,
FWallet.Password, lKey) then
result.Key := lKey;
end;
function TWalletKey.HasPrivateKey: Boolean;
begin
result := Length(FCryptedKey) > 0;
end;
procedure TWalletKey.SetCryptedKey(const Value: TBytes);
var
lVal: TRawBytes;
lRetval: Boolean;
lTestVal: string;
begin
FCryptedKey := Value;
try
lRetval := FKeyTools.DecryptPascalCoinPrivateKey(FCryptedKey.ToHexaString,
'', lVal);
except
on e: Exception do
begin
lTestVal := Self.FName;
end;
end;
if lRetval then
FEncryptionState := esPlainText
else
FEncryptionState := esEncrypted;
end;
procedure TWalletKey.SetName(const Value: String);
begin
FName := Value;
end;
{ TPublicKey }
constructor TPublicKey.Create(AKeyTools: IKeyTools);
begin
inherited Create;
FKeyTools := AKeyTools;
end;
function TPublicKey.GetNID: Word;
begin
result := FNID;
end;
function TPublicKey.GetX: TBytes;
begin
result := FX;
end;
function TPublicKey.GetY: TBytes;
begin
result := FY;
end;
function TPublicKey.GetAsBase58: string;
begin
result := FKeyTools.GetPascalCoinPublicKeyAsBase58(GetAsHexStr);
end;
function TPublicKey.GetAsHexStr: string;
begin
result := FKeyTools.GetPascalCoinPublicKeyAsHexString(GetKeyType, FX, FY);
end;
function TPublicKey.GetKeyType: TKeyType;
begin
result := FKeyTools.RetrieveKeyType(FNID);
end;
function TPublicKey.GetKeyTypeAsStr: string;
begin
result := TRttiEnumerationType.GetName<TKeyType>(GetKeyType);
end;
procedure TPublicKey.SetKeyType(const Value: TKeyType);
begin
FNID := FKeyTools.GetKeyTypeNumericValue(Value);
end;
procedure TPublicKey.SetKeyTypeAsStr(const Value: string);
begin
SetKeyType(TRttiEnumerationType.GetValue<TKeyType>(Value));
end;
procedure TPublicKey.SetNID(const Value: Word);
begin
FNID := Value;
end;
procedure TPublicKey.SetX(const Value: TBytes);
begin
FX := Value;
end;
procedure TPublicKey.SetY(const Value: TBytes);
begin
FY := Value;
end;
{ TPrivateKey }
{$IFDEF UNITTEST}
constructor TPrivateKey.Create(AHexKey: string; const AKeyType: TKeyType);
begin
Create;
FKey := THex.Decode(AHexKey);
FKeyType := AKeyType;
end;
{$ENDIF}
constructor TPrivateKey.Create;
begin
inherited Create;
end;
function TPrivateKey.GetAsHexStr: String;
begin
result := FKey.ToHexaString;
end;
function TPrivateKey.GetKey: TRawBytes;
begin
result := FKey;
end;
function TPrivateKey.GetKeyType: TKeyType;
begin
result := FKeyType;
end;
procedure TPrivateKey.SetKey(Value: TRawBytes);
begin
FKey := Value;
end;
procedure TPrivateKey.SetKeyType(const Value: TKeyType);
begin
FKeyType := Value;
end;
end.
|
{$A+,B-,D+,E-,F-,G+,I+,L+,N+,O-,P-,Q+,R+,S+,T-,V+,X+,Y+}
{$M 1024,0,0}
{
by Behdad Esfahbod
Algorithmic Problems Book
April '2000
Problem 81 O(N2) Dynamic, Greedy Mehod
}
program
JobAssignment;
const
MaxN = 100;
type
TJob = record
S, F, B, Map : Longint;
end;
var
N : Integer;
Job : array [0 .. MaxN] of TJob;
D1 : array [0 .. MaxN] of Longint;
P1 : array [0 .. MaxN] of Integer;
D2 : array [-1 .. MaxN, -1 .. MaxN] of Longint;
P2 : array [0 .. MaxN, 0 .. MaxN] of Integer;
Ans : array [1 .. MaxN] of Integer;
X : Longint;
I, J, K, L, P : Integer;
procedure ReadInput;
begin
Assign(Input, 'input.txt');
Reset(Input);
Readln(N);
for I := 1 to N do
with Job[I] do
Readln(S, F, B);
Close(Input);
end;
procedure Sort(l, r: Integer);
var
i, j, x: integer;
begin
i := l; j := r; x := job[(l+r) DIV 2].f;
repeat
while job[i].f < x do i := i + 1;
while x < job[j].f do j := j - 1;
if i <= j then
begin
job[0] := job[i]; job[i] := job[j]; job[j] := job[0];
i := i + 1; j := j - 1;
end;
until i > j;
if l < j then Sort(l, j);
if i < r then Sort(i, r);
end;
procedure Dynamic1;
begin
for I := 1 to N do
with Job[I] do
begin
for J := I - 1 downto 0 do
if (Job[J].F <= S) and (D1[I] <= D1[J]) then
begin
D1[I] := D1[J];
P1[I] := J;
end;
Inc(D1[I], B);
end;
end;
procedure WriteOutput1;
begin
Assign(Output, 'jobs1.out');
Rewrite(Output);
X := -1;
for I := 1 to N do
if X < D1[I] then
begin
X := D1[I];
J := I;
end;
Write('Selected jobs:');
while J <> 0 do
begin
Write(' ', Job[J].Map);
J := P1[J];
end;
Writeln;
Writeln('Total benefit = ', X);
Close(Output);
end;
procedure Dynamic2;
begin
for I := 0 to N do
for J := 0 to N do
begin
P2[I, J] := -1;
if (I > J) then
begin
D2[I, J] := D2[I - 1, J];
for K := I - 1 downto 0 do
if Job[K].F <= Job[I].S then
Break;
if D2[I, J] < D2[K, J] + Job[I].B then
begin
D2[I, J] := D2[K, J] + Job[I].B;
P2[I, J] := K;
end;
end
else
if (J > I) then
begin
D2[I, J] := D2[I, J - 1];
for K := J - 1 downto 0 do
if Job[K].F <= Job[J].S then
Break;
if D2[I, J] < D2[I, K] + Job[J].B then
begin
D2[I, J] := D2[I, K] + Job[J].B;
P2[I, J] := K;
end;
end
else
begin
D2[I, J] := D2[I - 1, J - 1];
for K := I - 1 downto 0 do
if Job[K].F <= Job[I].S then
Break;
if D2[I, J] < D2[K, J - 1] + Job[I].B then
begin
D2[I, J] := D2[K, J - 1] + Job[I].B;
P2[I, J] := K;
end;
end;
end;
end;
procedure WriteOutput2;
begin
Assign(Output, 'jobs2.out');
Rewrite(Output);
I := N; J := N;
while I + J > 0 do
begin
if I > J then
if P2[I, J] = -1 then
Dec(I)
else
begin
Ans[I] := 1;
I := P2[I, J];
end
else
if J > I then
if P2[I, J] = -1 then
Dec(J)
else
begin
Ans[J] := 2;
J := P2[I, J];
end
else
if P2[I, J] = -1 then
begin
Dec(I);
Dec(J);
end
else
begin
Ans[I] := 1;
I := P2[I, J];
Dec(J);
end
end;
for I := 1 to 2 do
begin
Write('Jobs to be executed on machine #', I, ':');
for J := N downto 1 do
if Ans[J] = I then
Write(' ', Job[J].Map);
Writeln;
end;
Writeln('Total benefit = ', D2[N, N]);
Close(Output);
end;
procedure Greedy;
begin
FillChar(Ans, SizeOf(Ans), 0);
for J := 1 to N do D1[J] := MaxLongint;
K := 0;
for I := N downto 1 do
begin
for J := 1 to N do
if Job[I].F <= D1[J] then
Break;
if J > K then
K := J;
Ans[I] := J;
D1[J] := Job[I].S;
end;
end;
procedure WriteOutput3;
begin
Assign(Output, 'jobs3.out');
Rewrite(Output);
Writeln('Minimum number of machines = ', K);
for J := 1 to K do
begin
Write('Jobs to be executed on machine #', J, ':');
for I := 1 to N do
if Ans[I] = J then
Write(' ', Job[I].Map);
Writeln;
end;
Close(Output);
end;
procedure Solve;
begin
for I := 1 to N do
Job[I].Map := I;
Sort(1, N);
FillChar(Job[0], SizeOf(Job[0]), 0);
Dynamic1;
WriteOutput1;
Dynamic2;
WriteOutput2;
Greedy;
WriteOutput3;
end;
begin
ReadInput;
Solve;
end.
|
{*******************************************************}
{ }
{ CodeGear Delphi Runtime Library }
{ Copyright(c) 2013-2018 Embarcadero Technologies, Inc. }
{ All rights reserved }
{ }
{*******************************************************}
unit Web.ApacheConst;
interface
resourcestring
sHTTPDImplNotRegistered = 'Apache version implementation is not registered. An Apache project must use a unit such as Web.HTTPD24Impl.';
sMultipleVersions = 'Multiple Apache versions implementations are referenced by this project. A project may not reference multiple versions such as Web.HTTPD22Impl and Web.HTTPD24Impl.';
implementation
end.
|
unit RegistryUnit;
interface
uses SysUtils, Classes;
type
ERegistrySampleError = class(Exception);
procedure GetRegData(out InstallPath, ModData: string);
function GetRegInstallPath: string;
function GetRegModData: string;
const
ABaseKey = 'Software\Sample Co.\SampleApp';
implementation
uses Registry;
procedure GetRegData(out InstallPath, ModData: string);
begin
InstallPath := GetRegInstallPath;
ModData := GetRegModData;
end;
function GetRegInstallPath: string;
var
r: TRegistry;
begin
r := TRegistry.Create;
try
if not r.KeyExists(ABaseKey) then
raise ERegistrySampleError.Create('App key does not exist.');
if not r.OpenKey(ABaseKey, false) then
raise ERegistrySampleError.Create('Cannot open app key.');
Result := r.ReadString('InstallPath');
r.CloseKey;
finally
r.Free;
end;
end;
function GetRegModData: string;
var
r: TRegistry;
begin
r := TRegistry.Create;
try
if not r.KeyExists(ABaseKey + '\ModuleAData') then
raise ERegistrySampleError.Create('Module key does not exist.');
if not r.OpenKey(ABaseKey + '\ModuleAData', false) then
raise ERegistrySampleError.Create('Cannot open module key.');
Result := r.ReadString('Data');
r.CloseKey;
finally
r.Free;
end;
end;
end.
|
unit DimensionsUnit;
interface
uses
SysUtils,
Variants,
Math,
Classes,
Contnrs,
IdGlobal;
const
SpaceSize = 100;
StateDimensionSize = 2;
StateDimensionCount = 3;
StatePointCount = StateDimensionSize * StateDimensionCount;
type
TSpace = Class(TObject)
private
procedure Initialize;
public
Points : array[1..SpaceSize, 1..SpaceSize, 1..SpaceSize] of Byte;
constructor Create;
function GetPoint(x,y,z : Integer) : Byte;
procedure SetPoint(x,y,z, PointValue : Byte);
end;
TState = class(TObject)
private
function GetText: string;
published
property Text : string read GetText;
public
Points : array[1..StatePointCount] of Byte;
StateResult : Integer;
constructor Create(StateNumber: Integer);
end;
TStateList = class(TObjectList)
private
FRuleNumberLow : Integer;
FRuleNumberHigh : Integer;
procedure CreateStates;
function GetRuleNumberLow: Longword;
procedure SetRuleNumberLow(const Value: Longword);
function GetRuleNumberHigh: Longword;
procedure SetRuleNumberHigh(const Value: Longword);
function GetCommaText: string;
published
property RuleNumberLow : Longword read GetRuleNumberLow write SetRuleNumberLow;
property RuleNumberHigh : Longword read GetRuleNumberHigh write SetRuleNumberHigh;
property CommaText : string read GetCommaText;
public
procedure Clear;
procedure SetResult(StateIndex, ResultValue : Byte);
function GetResult(StateIndex : Integer): Byte;
constructor Create;
end;
TAutomata = class(TObject)
private
FRuleNumber : Integer;
function GetRuleNumberLow: Longword;
procedure SetRuleNumberLow(const Value: Longword);
function GetRuleNumberHigh: Longword;
procedure SetRuleNumberHigh(const Value: Longword);
published
property RuleNumberLow : Longword read GetRuleNumberLow write SetRuleNumberLow;
property RuleNumberHigh : Longword read GetRuleNumberHigh write SetRuleNumberHigh;
public
Space : TSpace;
Space2 : TSpace;
SpaceFree : TSpace;
Space2Free : TSpace;
PossibleStates : TStateList;
Iterations : Integer;
procedure LoadFromText(TextFile: string);
procedure SaveToText(TextFile: string);
procedure Iterate;
constructor Create;
destructor Destroy; override;
end;
implementation
{ TAutomata }
constructor TAutomata.Create;
begin
FRuleNumber := 0;
PossibleStates := TStateList.Create;
inherited;
Space := TSpace.Create;
SpaceFree := Space;
Space2 := TSpace.Create;
Space2Free := Space2;
end;
destructor TAutomata.Destroy;
begin
inherited;
try
FreeAndNil(SpaceFree);
FreeAndNil(Space2Free);
FreeAndNil(PossibleStates);
except
end;
end;
function TAutomata.GetRuleNumberLow: Longword;
begin
Result := PossibleStates.RuleNumberLow;
end;
function TAutomata.GetRuleNumberHigh: Longword;
begin
Result := PossibleStates.RuleNumberHigh;
end;
procedure TAutomata.SetRuleNumberHigh(const Value: LongWord);
begin
PossibleStates.RuleNumberHigh := Value;
end;
procedure TAutomata.SetRuleNumberLow(const Value: LongWord);
begin
PossibleStates.RuleNumberLow := Value;
end;
procedure TAutomata.Iterate;
var
XIndex,
YIndex,
ZIndex : Integer;
StateIndex : Integer;
begin
for ZIndex := 1 to SpaceSize do
for XIndex := 1 to SpaceSize do
for YIndex := 1 to SpaceSize do
Space2.SetPoint(XIndex, YIndex, ZIndex, Space.GetPoint(XIndex,YIndex,ZIndex));
for ZIndex := 1 to SpaceSize do
for XIndex := 1 to SpaceSize do
for YIndex := 1 to SpaceSize do
begin
StateIndex := 0;
StateIndex := StateIndex or Space2.GetPoint(XIndex - 1, YIndex, ZIndex);
StateIndex := StateIndex or (Space2.GetPoint(XIndex + 1, YIndex, ZIndex) * 2);
StateIndex := StateIndex or (Space2.GetPoint(XIndex, YIndex - 1, ZIndex) * 4);
StateIndex := StateIndex or (Space2.GetPoint(XIndex, YIndex + 1, ZIndex) * 8);
StateIndex := StateIndex or (Space2.GetPoint(XIndex, YIndex, ZIndex - 1) * 16);
StateIndex := StateIndex or (Space2.GetPoint(XIndex, YIndex, ZIndex + 1) * 32);
Space.SetPoint(XIndex, YIndex, ZIndex, PossibleStates.GetResult(StateIndex));
end;
Iterations := Iterations + 1;
end;
procedure TAutomata.LoadFromText(TextFile: string);
var
xSpaceIndex,
ySpaceIndex,
zSpaceIndex: Integer;
StateIndex : Integer;
Text: TStringList;
TextIndex : Integer;
begin
Text := TStringList.Create;
try
Text.LoadFromFile(TextFile);
for StateIndex := 0 to PossibleStates.Count-1 do
PossibleStates.SetResult(StateIndex,StrToInt(Text.Strings[StateIndex]));
TextIndex := PossibleStates.Count;
for zSpaceIndex := 1 to SpaceSize do
for ySpaceIndex := 1 to SpaceSize do
for xSpaceIndex := 1 to SpaceSize do
begin
Space.Points[xSpaceIndex, ySpaceIndex, zSpaceIndex] := StrToInt(Text.Strings[TextIndex]);
Inc(TextIndex);
end;
Iterations := StrToInt(Text.Strings[TextIndex]);
finally
Text.Free;
end;
end;
procedure TAutomata.SaveToText(TextFile: string);
var
xSpaceIndex,
ySpaceIndex,
zSpaceIndex: Integer;
StateIndex : Integer;
Text: TStringList;
TextIndex : Integer;
begin
Text := TStringList.Create;
try
for StateIndex := 0 to PossibleStates.Count-1 do
Text.Add(IntToStr(PossibleStates.GetResult(StateIndex)));
for zSpaceIndex := 1 to SpaceSize do
for ySpaceIndex := 1 to SpaceSize do
for xSpaceIndex := 1 to SpaceSize do
begin
Text.Add(IntToStr(Space.Points[xSpaceIndex, ySpaceIndex, zSpaceIndex]));
end;
Text.Add(IntToStr(Iterations));
Text.SaveToFile(TextFile);
finally
Text.Free;
end;
end;
{ TSpace }
function AdjustCordinate(Cordinate: Integer) : Integer;
function Constrain(ValueToConstrain, Constraint: Integer): Integer;
begin
Result := ValueToConstrain;
while Result > Constraint do
begin
Result := Result - Constraint;
end;
end;
begin
Result := Cordinate;
if Result < 1 then
begin
Result := -Constrain(-Result, SpaceSize);
Result := SpaceSize + Result;
end
else
Result := Constrain(Result, SpaceSize);
end;
constructor TSpace.Create;
begin
Initialize;
end;
function TSpace.GetPoint(x, y, z: Integer): Byte;
begin
x := AdjustCordinate(x);
y := AdjustCordinate(y);
z := AdjustCordinate(z);
Result := Points[x, y, z];
end;
procedure TSpace.Initialize;
var
xSpaceIndex,
ySpaceIndex,
zSpaceIndex : Integer;
begin
for zSpaceIndex := 1 to SpaceSize do
for ySpaceIndex := 1 to SpaceSize do
for xSpaceIndex := 1 to SpaceSize do
Points[xSpaceIndex, ySpaceIndex, zSpaceIndex] := 0;
end;
procedure TSpace.SetPoint(x, y, z, PointValue: Byte);
begin
x := AdjustCordinate(x);
y := AdjustCordinate(y);
z := AdjustCordinate(z);
Points[x, y, z] := PointValue;
end;
{ TRuleList }
constructor TStateList.Create;
begin
FRuleNumberLow := 0;
FRuleNumberHigh := 0;
inherited;
CreateStates;
OwnsObjects := True;
end;
procedure TStateList.CreateStates;
var
State: TState;
StateIndex : Integer;
begin
for StateIndex := 1 to Trunc(Power(2, StatePointCount)) do
begin
State := TState.Create(StateIndex);
Add(State);
end;
end;
function TStateList.GetCommaText: string;
var
StateIndex: Integer;
StringList : TStringList;
begin
Result := '';
StringList := TStringList.Create;
try
for StateIndex := 0 to Count - 1 do
StringList.Add(TState(Items[StateIndex]).Text);
Result := StringList.CommaText;
finally
FreeAndNil(StringList);
end;
end;
function TStateList.GetResult(StateIndex: Integer): Byte;
begin
Result := TState(Items[StateIndex]).StateResult;
end;
{ TState }
constructor TState.Create(StateNumber: Integer);
var
StateIndex: Integer;
begin
for StateIndex := 1 to StatePointCount do
if ((StateNumber - 1) and (Trunc(Power(2, StateIndex - 1)))) > 0 then
Points[StateIndex] := 1
else
Points[StateIndex] := 0;
end;
procedure TStateList.SetResult(StateIndex, ResultValue: Byte);
begin
TState(Items[StateIndex]).StateResult := ResultValue;
end;
procedure TStateList.SetRuleNumberLow(const Value: Longword);
var
StateIndex: Integer;
BitString : string;
begin
if Value > 0 then
begin
FRuleNumberLow := Value - 1;
BitString := IntToBin(Value);
for StateIndex := 1 to 32 do
begin
SetResult(StateIndex - 1, StrToInt(BitString[StateIndex]));
end;
end;
end;
procedure TStateList.SetRuleNumberHigh(const Value: Longword);
var
StateIndex: Integer;
BitString : string;
begin
if Value > 0 then
begin
FRuleNumberHigh := Value-1;
BitString := IntToBin(Value);
for StateIndex := 33 to 64 do
begin
SetResult(StateIndex - 1, StrToInt(BitString[StateIndex - 32]));
end;
end;
end;
function TState.GetText: string;
var
PointIndex : Integer;
begin
Result := '';
for PointIndex := 1 to StatePointCount do
begin
Result := Result + IntToStr(Points[PointIndex]);
end;
Result := Result + ' =' + IntToStr(StateResult);
end;
function TStateList.GetRuleNumberHigh: Longword;
var
StateIndex : Integer;
OrMultiplyer : Integer;
begin
Result := 1;
OrMultiplyer := 1;
for StateIndex := 32 to 63 do
begin
if GetResult(StateIndex) > 0 then
Result := Result or OrMultiplyer;
OrMultiplyer := OrMultiplyer * 2;
end;
end;
function TStateList.GetRuleNumberLow: Longword;
var
StateIndex : Integer;
OrMultiplyer : Integer;
begin
Result := 1;
OrMultiplyer := 1;
for StateIndex := 0 to 31 do
begin
if GetResult(StateIndex) > 0 then
Result := Result or OrMultiplyer;
OrMultiplyer := OrMultiplyer * 2;
end;
end;
procedure TStateList.Clear;
var
StateIndex : Integer;
begin
for StateIndex := 0 to 63 do
begin
SetResult(StateIndex,0);
end;
end;
end.
|
{*******************************************************}
{ }
{ Delphi Runtime Library }
{ }
{ Copyright(c) 1995-2011 Embarcadero Technologies, Inc. }
{ }
{*******************************************************}
unit Data.Win.ADOConst;
interface
resourcestring
SInvalidEnumValue = 'Invalid Enum Value';
SMissingConnection = 'Missing Connection or ConnectionString';
SNoDetailFilter = 'Filter property cannot be used for detail tables';
SBookmarksRequired = 'Dataset does not support bookmarks, which are required for multi-record data controls';
SMissingCommandText = 'Missing %s property';
SNoResultSet = 'CommandText does not return a result set';
SADOCreateError = 'Error creating object. Please verify that the Microsoft Data Access Components 2.1 (or later) have been properly installed';
SEventsNotSupported = 'Events are not supported with server side TableDirect cursors';
SUsupportedFieldType = 'Unsupported field type (%s) in field %s';
SNoMatchingADOType = 'No matching ADO data type for %s';
SConnectionRequired = 'A connection component is required for async ExecuteOptions';
SCantRequery = 'Cannot perform a requery after connection has changed';
SNoFilterOptions = 'FilterOptions are not supported';
SRecordsetNotOpen = 'Recordset is not open';
sNameAttr = 'Name';
sValueAttr = 'Value';
implementation
end.
|
unit FC.Trade.StatisticsDialog;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, ufmDialogClose_B, StdCtrls, ComCtrls, ExtendControls, ExtCtrls,FC.fmUIDataStorage,
ActnList, ToolWin,FC.Definitions;
type
TfmTradingStatisticDialog = class(TfmDialogClose_B)
lvProperties: TExtendListView;
Properties: TLabel;
ToolBar1: TToolBar;
tbExport: TToolButton;
alActions: TActionList;
acExport: TAction;
procedure acExportExecute(Sender: TObject);
private
FTrader: IStockTrader;
public
property Trader: IStockTrader read FTrader write FTrader;
procedure AddProperty(const aName: string; const aValue: string);
end;
implementation
uses Export.Definitions;
{$R *.dfm}
{ TfmTradingStatisticDialog }
procedure TfmTradingStatisticDialog.AddProperty(const aName, aValue: string);
begin
with lvProperties.Items.Add do
begin
Caption:=aName;
SubItems.Add(aValue);
end;
end;
procedure TfmTradingStatisticDialog.acExportExecute(Sender: TObject);
var
aExportInfo: TExportInfo;
aPropCollection: IStockTraderPropertyCollection;
aExportString : TExportString;
i: integer;
begin
aExportInfo:=TExportInfo.Create;
aPropCollection:=Trader.GetProperties;
try
//Default format
aExportInfo.DefaultFormat.FontName:='Tahoma';
aExportInfo.DefaultFormat.FontSize:=7;
aExportInfo.DefaultFormat.IgnoreFormat:=false;
//Title
aExportString:=TExportString.Create(Trader.GetCategory+'\'+Trader.GetName+#13#10);
aExportString.Format.IgnoreFormat:=false;
aExportString.Format.FontSize:=12;
aExportString.Format.FontStyle:=[efsBold,efsItalic];
aExportInfo.HeadStrings.Add(aExportString);
//Properties
for i:=0 to aPropCollection.Count-1 do
begin
aExportString:=TExportString.Create(aPropCollection.Items[i].GetCategory+'\'+
aPropCollection.Items[i].GetName+'='+
aPropCollection.Items[i].ValueAsText);
aExportString.Format.IgnoreFormat:=false;
aExportString.Format.FontSize:=10;
aExportInfo.HeadStrings.Add(aExportString);
end;
ExporterManager.ExportOperator.DoExport(lvProperties,aExportInfo);
finally
aExportInfo.Free;
end;
end;
end.
|
unit iaTestSupport.Log;
interface
uses
System.SyncObjs;
procedure LogIt(const pText:string);
var
pubConsoleLock:TCriticalSection;
implementation
uses
System.SysUtils;
procedure LogIt(const pText:string);
begin
pubConsoleLock.Enter();
try
WriteLn(FormatDateTime('yyyy-mm-dd hh.nn.ss', Now) + ': ' + pText);
finally
pubConsoleLock.Leave();
end;
end;
initialization
pubConsoleLock := TCriticalSection.Create();
finalization
pubConsoleLock.Free();
end.
|
unit caVector;
{$INCLUDE ca.inc}
interface
uses
// Standard Delphi units
Classes,
Sysutils,
Math,
// ca units
caCell,
caClasses,
caTypes,
caUtils,
caLog;
type
//---------------------------------------------------------------------------
// IcaVectorStringsAligner
//---------------------------------------------------------------------------
TcaVector = class;
IcaVectorStringsAligner = interface
['{4B90DBAC-1F92-41FB-9D57-6AED7DDC22F6}']
function GetAlignedStrings: IcaStringList;
function GetStringsAlignment: TcaArrayStringsAlignment;
function GetStringsWidth: Integer;
procedure Execute;
procedure SetStringsAlignment(const Value: TcaArrayStringsAlignment);
procedure SetStringsWidth(const Value: Integer);
property AlignedStrings: IcaStringList read GetAlignedStrings;
property StringsAlignment: TcaArrayStringsAlignment read GetStringsAlignment write SetStringsAlignment;
property StringsWidth: Integer read GetStringsWidth write SetStringsWidth;
end;
//---------------------------------------------------------------------------
// TcaVectorStringsAligner
//---------------------------------------------------------------------------
TcaVectorStringsAligner = class(TInterfacedObject, IcaVectorStringsAligner)
private
FAlignedStrings: IcaStringList;
FStringsAlignment: TcaArrayStringsAlignment;
FStringsWidth: Integer;
FVector: TcaVector;
function GetAlignedStrings: IcaStringList;
function GetStringsAlignment: TcaArrayStringsAlignment;
function GetStringsWidth: Integer;
procedure SetStringsAlignment(const Value: TcaArrayStringsAlignment);
procedure SetStringsWidth(const Value: Integer);
public
constructor Create(AVector: TcaVector);
procedure Execute;
property AlignedStrings: IcaStringList read GetAlignedStrings;
property StringsAlignment: TcaArrayStringsAlignment read GetStringsAlignment write SetStringsAlignment;
property StringsWidth: Integer read GetStringsWidth write SetStringsWidth;
end;
//---------------------------------------------------------------------------
// IcaVector
//---------------------------------------------------------------------------
IcaVector = interface
['{04600722-10EF-44E9-B397-F8A21194103C}']
// Property methods
function GetAlignedStrings: IcaStringList;
function GetAligner: IcaVectorStringsAligner;
function GetCells: TList;
function GetCount: Integer;
function GetStringsAlignment: TcaArrayStringsAlignment;
function GetStringsWidth: Integer;
procedure SetCount(const Value: Integer);
procedure SetStringsAlignment(const Value: TcaArrayStringsAlignment);
procedure SetStringsWidth(const Value: Integer);
// Event property methods
function GetOnChange: TNotifyEvent;
procedure SetOnChange(const Value: TNotifyEvent);
// Protected properties
property Cells: TList read GetCells;
// Public methods
procedure Assign(ASource: IcaVector); overload;
procedure Assign(ASource: TcaVector); overload;
procedure Clear;
procedure Delete(AIndex: Integer);
procedure GrowBy(Delta: Integer);
procedure ShrinkBy(Delta: Integer);
// Properties
property AlignedStrings: IcaStringList read GetAlignedStrings;
property Aligner: IcaVectorStringsAligner read GetAligner;
property Count: Integer read GetCount write SetCount;
property StringsAlignment: TcaArrayStringsAlignment read GetStringsAlignment write SetStringsAlignment;
property StringsWidth: Integer read GetStringsWidth write SetStringsWidth;
// Event properties
property OnChange: TNotifyEvent read GetOnChange write SetOnChange;
end;
IcaVectorItemString = interface
['{B5028F46-B8BB-4859-9359-B0D2E48449FB}']
function GetItemString(Index: Integer): String;
end;
//---------------------------------------------------------------------------
// TcaVector
//---------------------------------------------------------------------------
TcaVector = class(TInterfacedObject, IcaVector, IcaVectorStringsAligner)
private
FAligner: IcaVectorStringsAligner;
FCells: TList;
// Event property fields
FOnChange: TNotifyEvent;
// Property methods
function GetAlignedStrings: IcaStringList;
function GetAligner: IcaVectorStringsAligner;
function GetCells: TList;
function GetHigh: Integer;
function GetLow: Integer;
function GetCount: Integer;
function GetStringsAlignment: TcaArrayStringsAlignment;
function GetStringsWidth: Integer;
procedure SetCount(const Value: Integer);
procedure SetStringsAlignment(const Value: TcaArrayStringsAlignment);
procedure SetStringsWidth(const Value: Integer);
// Event property methods
function GetOnChange: TNotifyEvent;
procedure SetOnChange(const Value: TNotifyEvent);
// Event handlers
procedure CellChangedEvent(Sender: TObject);
protected
// Static protected methods
function CreateCellObject: TcaCell;
// Virtual protected methods
function CreateCell: TcaCell; virtual; abstract;
procedure DoChanged; virtual;
// Protected properties
property Cells: TList read GetCells;
public
constructor Create;
destructor Destroy; override;
// Public methods
procedure Assign(ASource: IcaVector); overload;
procedure Assign(ASource: TcaVector); overload;
procedure Clear;
procedure Delete(AIndex: Integer);
procedure GrowBy(Delta: Integer);
procedure ShrinkBy(Delta: Integer);
// Properties
property Aligner: IcaVectorStringsAligner read GetAligner implements IcaVectorStringsAligner;
property AlignedStrings: IcaStringList read GetAlignedStrings;
property High: Integer read GetHigh;
property Low: Integer read GetLow;
property Count: Integer read GetCount write SetCount;
property StringsAlignment: TcaArrayStringsAlignment read GetStringsAlignment write SetStringsAlignment;
property StringsWidth: Integer read GetStringsWidth write SetStringsWidth;
// Event properties
property OnChange: TNotifyEvent read GetOnChange write SetOnChange;
end;
//---------------------------------------------------------------------------
// IcaIntegerVector
//---------------------------------------------------------------------------
IcaIntegerVector = interface(IcaVector)
['{20A2544D-C35D-40EF-9133-A095E324A046}']
// Property methods
function GetItem(Index: Integer): Integer;
procedure SetItem(Index: Integer; const Value: Integer);
// Public methods
function Add(const AItem: Integer): Integer;
function IndexOf(const AItem: Integer): Integer;
procedure AddArray(AArray: array of Integer);
// Properties
property Items[Index: Integer]: Integer read GetItem write SetItem; default;
end;
//---------------------------------------------------------------------------
// IcaIntegerStack
//---------------------------------------------------------------------------
IcaIntegerStack = interface
['{827FE124-87BA-48DD-86D8-7C55D8DFB0F4}']
// Property methods
function GetIsEmpty: Boolean;
function GetSize: Integer;
// Public methods
function Peek: Integer;
function Pop: Integer;
function Push(AItem: Integer): Integer;
// Properties
property IsEmpty: Boolean read GetIsEmpty;
property Size: Integer read GetSize;
end;
//---------------------------------------------------------------------------
// TcaIntegerVector
//---------------------------------------------------------------------------
TcaIntegerVector = class(TcaVector, IcaIntegerVector,
IcaVectorItemString,
IcaIntegerStack)
private
// IcaIntegerVector property methods
function GetItem(Index: Integer): Integer;
function GetItemString(Index: Integer): String;
procedure SetItem(Index: Integer; const Value: Integer);
// IcaIntegerStack property methods
function GetIsEmpty: Boolean;
function GetSize: Integer;
protected
function CreateCell: TcaCell; override;
public
// IcaIntegerVector public methods
function Add(const AItem: Integer): Integer;
function IndexOf(const AItem: Integer): Integer;
procedure AddArray(AArray: array of Integer);
// IcaIntegerVector properties
property Items[Index: Integer]: Integer read GetItem write SetItem; default;
// IcaIntegerStack public methods
function Peek: Integer;
function Pop: Integer;
function Push(AItem: Integer): Integer;
// IcaIntegerStack properties
property IsEmpty: Boolean read GetIsEmpty;
property Size: Integer read GetSize;
end;
//---------------------------------------------------------------------------
// IcaStringVector
//---------------------------------------------------------------------------
IcaStringVector = interface(IcaVector)
['{2674C3AB-683A-4A37-9682-7F99FC117675}']
// Property methods
function GetItem(Index: Integer): String;
procedure SetItem(Index: Integer; const Value: String);
// Public methods
function Add(const AItem: String): Integer;
function IndexOf(const AItem: String): Integer;
procedure AddArray(AArray: array of String);
// Properties
property Items[Index: Integer]: String read GetItem write SetItem; default;
end;
//---------------------------------------------------------------------------
// TcaStringVector
//---------------------------------------------------------------------------
TcaStringVector = class(TcaVector, IcaStringVector, IcaVectorItemString)
private
function GetItem(Index: Integer): String;
function GetItemString(Index: Integer): String;
procedure SetItem(Index: Integer; const Value: String);
protected
function CreateCell: TcaCell; override;
public
// Public methods
function Add(const AItem: String): Integer;
function IndexOf(const AItem: String): Integer;
procedure AddArray(AArray: array of String);
// Properties
property Items[Index: Integer]: String read GetItem write SetItem; default;
end;
//---------------------------------------------------------------------------
// IcaSingleVector
//---------------------------------------------------------------------------
IcaSingleVector = interface(IcaVector)
['{E71CF14D-13BD-487F-8CDA-42899477995A}']
// Property methods
function GetItem(Index: Integer): Single;
procedure SetItem(Index: Integer; const Value: Single);
// Public methods
function Add(const AItem: Single): Integer;
function IndexOf(const AItem: Single): Integer;
procedure AddArray(AArray: array of Single);
// Properties
property Items[Index: Integer]: Single read GetItem write SetItem; default;
end;
//---------------------------------------------------------------------------
// TcaSingleVector
//---------------------------------------------------------------------------
TcaSingleVector = class(TcaVector, IcaSingleVector, IcaVectorItemString)
private
function GetItem(Index: Integer): Single;
function GetItemString(Index: Integer): String;
procedure SetItem(Index: Integer; const Value: Single);
protected
function CreateCell: TcaCell; override;
public
// Public methods
function Add(const AItem: Single): Integer;
function IndexOf(const AItem: Single): Integer;
procedure AddArray(AArray: array of Single);
// Properties
property Items[Index: Integer]: Single read GetItem write SetItem; default;
end;
//---------------------------------------------------------------------------
// IcaDoubleVector
//---------------------------------------------------------------------------
IcaDoubleVector = interface(IcaVector)
['{E71CF14D-13BD-487F-8CDA-42899477995A}']
// Property methods
function GetItem(Index: Integer): Double;
procedure SetItem(Index: Integer; const Value: Double);
// Public methods
function Add(const AItem: Double): Integer;
function IndexOf(const AItem: Double): Integer;
procedure AddArray(AArray: array of Double);
// Properties
property Items[Index: Integer]: Double read GetItem write SetItem; default;
end;
//---------------------------------------------------------------------------
// TcaDoubleVector
//---------------------------------------------------------------------------
TcaDoubleVector = class(TcaVector, IcaDoubleVector, IcaVectorItemString)
private
function GetItem(Index: Integer): Double;
function GetItemString(Index: Integer): String;
procedure SetItem(Index: Integer; const Value: Double);
protected
function CreateCell: TcaCell; override;
public
// Public methods
function Add(const AItem: Double): Integer;
function IndexOf(const AItem: Double): Integer;
procedure AddArray(AArray: array of Double);
// Properties
property Items[Index: Integer]: Double read GetItem write SetItem; default;
end;
//---------------------------------------------------------------------------
// IcaExtendedVector
//---------------------------------------------------------------------------
IcaExtendedVector = interface(IcaVector)
['{697807BB-A152-46C4-A958-F83316C22EA8}']
// Property methods
function GetItem(Index: Integer): Extended;
procedure SetItem(Index: Integer; const Value: Extended);
// Public methods
function Add(const AItem: Extended): Integer;
function IndexOf(const AItem: Extended): Integer;
procedure AddArray(AArray: array of Extended);
// Properties
property Items[Index: Integer]: Extended read GetItem write SetItem; default;
end;
//---------------------------------------------------------------------------
// TcaExtendedVector
//---------------------------------------------------------------------------
TcaExtendedVector = class(TcaVector, IcaExtendedVector, IcaVectorItemString)
private
function GetItem(Index: Integer): Extended;
function GetItemString(Index: Integer): String;
procedure SetItem(Index: Integer; const Value: Extended);
protected
function CreateCell: TcaCell; override;
public
// Public methods
function Add(const AItem: Extended): Integer;
function IndexOf(const AItem: Extended): Integer;
procedure AddArray(AArray: array of Extended);
// Properties
property Items[Index: Integer]: Extended read GetItem write SetItem; default;
end;
implementation
//---------------------------------------------------------------------------
// IcaVectorStringsAligner
//---------------------------------------------------------------------------
constructor TcaVectorStringsAligner.Create(AVector: TcaVector);
begin
inherited Create;
FVector := AVector;
FAlignedStrings := TcaStringList.Create;
end;
function TcaVectorStringsAligner.GetAlignedStrings: IcaStringList;
begin
Result := FAlignedStrings;
end;
procedure TcaVectorStringsAligner.Execute;
var
Index: Integer;
MaxWidth: Integer;
UnAlignedStrings: IcaStringList;
UnAlignedStr: String;
UnAlignedString: IcaString;
AlignedStr: String;
PadStr: String;
VItemStr: IcaVectorItemString;
begin
UnAlignedStrings := TcaStringList.Create;
// Build UnAlignedStrings
VItemStr := FVector as IcaVectorItemString;
for Index := FVector.Low to FVector.High do
begin
UnAlignedStr := VItemStr.GetItemString(Index);
UnAlignedStrings.Add(UnAlignedStr);
end;
// Find widest possible string
if FStringsWidth <> 0 then
MaxWidth := FStringsWidth
else
MaxWidth := UnAlignedStrings.WidthOfWidest;
// Build new list
FAlignedStrings.Clear;
// cautils
PadStr := Utils.BuildString(#32, MaxWidth);
for Index := UnAlignedStrings.Low to UnAlignedStrings.High do
begin
UnAlignedString := TcaString.Create(UnAlignedStrings[Index]);
case FStringsAlignment of
saLeft: AlignedStr := UnAlignedString.PadRight(MaxWidth);
saRight: AlignedStr := UnAlignedString.PadLeft(MaxWidth);
saPreZero: AlignedStr := UnAlignedString.PreZero(MaxWidth);
end;
FAlignedStrings.Add(AlignedStr);
end;
end;
procedure TcaVectorStringsAligner.SetStringsWidth(const Value: Integer);
begin
FStringsWidth := Value;
end;
procedure TcaVectorStringsAligner.SetStringsAlignment(const Value: TcaArrayStringsAlignment);
begin
FStringsAlignment := Value;
end;
function TcaVectorStringsAligner.GetStringsWidth: Integer;
begin
Result := FStringsWidth;
end;
function TcaVectorStringsAligner.GetStringsAlignment: TcaArrayStringsAlignment;
begin
Result := FStringsAlignment;
end;
//---------------------------------------------------------------------------
// TcaVector
//---------------------------------------------------------------------------
constructor TcaVector.Create;
begin
inherited;
FAligner := TcaVectorStringsAligner.Create(Self);
FCells := TList.Create;
end;
destructor TcaVector.Destroy;
begin
FCells.Free;
inherited;
end;
// Public methods
procedure TcaVector.Assign(ASource: IcaVector);
var
Index: Integer;
Cell: TcaCell;
SourceCell: TcaCell;
begin
Clear;
for Index := 0 to ASource.Count - 1 do
begin
SourceCell := TcaCell(ASource.Cells[Index]);
Cell := CreateCellObject;
FCells.Add(Cell);
Cell.AsString := SourceCell.AsString;
end;
end;
procedure TcaVector.Assign(ASource: TcaVector);
var
Index: Integer;
Cell: TcaCell;
SourceCell: TcaCell;
begin
Clear;
for Index := 0 to ASource.Count - 1 do
begin
SourceCell := TcaCell(ASource.Cells[Index]);
Cell := CreateCellObject;
FCells.Add(Cell);
Cell.AsString := SourceCell.AsString;
end;
end;
procedure TcaVector.Clear;
begin
FCells.Clear;
DoChanged;
end;
procedure TcaVector.Delete(AIndex: Integer);
begin
FCells.Delete(AIndex);
end;
procedure TcaVector.GrowBy(Delta: Integer);
var
Index: Integer;
begin
for Index := 1 to Delta do
FCells.Add(CreateCellObject);
end;
procedure TcaVector.ShrinkBy(Delta: Integer);
var
NewCount: Integer;
begin
NewCount := Max(0, GetCount - Delta);
while GetCount > NewCount do
FCells.Delete(GetCount);
end;
// Static protected methods
function TcaVector.CreateCellObject: TcaCell;
begin
Result := CreateCell;
Result.OnChange := CellChangedEvent;
DoChanged;
end;
// Virtual protected methods
procedure TcaVector.DoChanged;
begin
if Assigned(FOnChange) then FOnChange(Self);
end;
// Private methods
function TcaVector.GetAlignedStrings: IcaStringList;
begin
FAligner.Execute;
Result := FAligner.AlignedStrings;
end;
function TcaVector.GetAligner: IcaVectorStringsAligner;
begin
Result := FAligner;
end;
function TcaVector.GetCells: TList;
begin
Result := FCells;
end;
function TcaVector.GetHigh: Integer;
begin
Result := FCells.Count - 1;
end;
function TcaVector.GetLow: Integer;
begin
Result := 0;
end;
function TcaVector.GetCount: Integer;
begin
Result := FCells.Count;
end;
function TcaVector.GetStringsAlignment: TcaArrayStringsAlignment;
begin
Result := FAligner.StringsAlignment;
end;
function TcaVector.GetStringsWidth: Integer;
begin
Result := FAligner.StringsWidth;
end;
procedure TcaVector.SetCount(const Value: Integer);
var
Delta: Integer;
begin
Delta := Value - GetCount;
if Delta > 0 then
GrowBy(Delta)
else
ShrinkBy(Delta);
end;
procedure TcaVector.SetStringsWidth(const Value: Integer);
begin
FAligner.StringsWidth := Value;
end;
procedure TcaVector.SetStringsAlignment(const Value: TcaArrayStringsAlignment);
begin
FAligner.StringsAlignment := Value;
end;
// Event handlers
procedure TcaVector.CellChangedEvent(Sender: TObject);
begin
DoChanged;
end;
// Event property methods
function TcaVector.GetOnChange: TNotifyEvent;
begin
Result := FOnChange;
end;
procedure TcaVector.SetOnChange(const Value: TNotifyEvent);
begin
FOnChange := Value;
end;
//---------------------------------------------------------------------------
// TcaIntegerVector
//---------------------------------------------------------------------------
// IcaIntegerVector public methods
function TcaIntegerVector.Add(const AItem: Integer): Integer;
var
Cell: TcaCell;
begin
Cell := CreateCellObject;
TcaIntegerCell(Cell).Value := AItem;
Result := Cells.Add(Cell);
end;
procedure TcaIntegerVector.AddArray(AArray: array of Integer);
var
Index: Integer;
begin
for Index := System.Low(AArray) to System.High(AArray) do
Add(AArray[Index]);
end;
function TcaIntegerVector.IndexOf(const AItem: Integer): Integer;
var
Index: Integer;
begin
Result := -1;
for Index := 0 to Count - 1 do
begin
if GetItem(Index) = AItem then
begin
Result := Index;
Break;
end;
end;
end;
// IcaIntegerStack public methods
function TcaIntegerVector.Peek: Integer;
begin
if Count = 0 then
Result := 0
else
Result := Items[High];
end;
function TcaIntegerVector.Pop: Integer;
begin
if Count = 0 then
Result := 0
else
begin
Result := Peek;
Delete(High);
end;
end;
function TcaIntegerVector.Push(AItem: Integer): Integer;
begin
Result := Add(AItem);
end;
// Protected methods
function TcaIntegerVector.CreateCell: TcaCell;
begin
Result := TcaIntegerCell.Create;
end;
// IcaIntegerVector property methods
function TcaIntegerVector.GetItem(Index: Integer): Integer;
begin
Result := TcaIntegerCell(Cells[Index]).Value;
end;
function TcaIntegerVector.GetItemString(Index: Integer): String;
begin
Result := IntToStr(GetItem(Index));
end;
procedure TcaIntegerVector.SetItem(Index: Integer; const Value: Integer);
begin
TcaIntegerCell(Cells[Index]).Value := Value;
end;
// IcaIntegerStack property methods
function TcaIntegerVector.GetIsEmpty: Boolean;
begin
Result := Count = 0;
end;
function TcaIntegerVector.GetSize: Integer;
begin
Result := Count;
end;
//---------------------------------------------------------------------------
// TcaStringVector
//---------------------------------------------------------------------------
// Public methods
function TcaStringVector.Add(const AItem: String): Integer;
var
Cell: TcaCell;
begin
Cell := CreateCellObject;
TcaStringCell(Cell).Value := AItem;
Result := Cells.Add(Cell);
end;
procedure TcaStringVector.AddArray(AArray: array of String);
var
Index: Integer;
begin
for Index := System.Low(AArray) to System.High(AArray) do
Add(AArray[Index]);
end;
function TcaStringVector.IndexOf(const AItem: String): Integer;
var
Index: Integer;
begin
Result := -1;
for Index := 0 to Count - 1 do
begin
if GetItem(Index) = AItem then
begin
Result := Index;
Break;
end;
end;
end;
// Protected methods
function TcaStringVector.CreateCell: TcaCell;
begin
Result := TcaStringCell.Create;
end;
// Property methods
function TcaStringVector.GetItem(Index: Integer): String;
begin
Result := TcaStringCell(Cells[Index]).Value;
end;
function TcaStringVector.GetItemString(Index: Integer): String;
begin
Result := GetItem(Index);
end;
procedure TcaStringVector.SetItem(Index: Integer; const Value: String);
begin
TcaStringCell(Cells[Index]).Value := Value;
end;
//---------------------------------------------------------------------------
// TcaSingleVector
//---------------------------------------------------------------------------
// Public methods
function TcaSingleVector.Add(const AItem: Single): Integer;
var
Cell: TcaCell;
begin
Cell := CreateCellObject;
TcaSingleCell(Cell).Value := AItem;
Result := Cells.Add(Cell);
end;
procedure TcaSingleVector.AddArray(AArray: array of Single);
var
Index: Integer;
begin
for Index := System.Low(AArray) to System.High(AArray) do
Add(AArray[Index]);
end;
function TcaSingleVector.IndexOf(const AItem: Single): Integer;
var
Index: Integer;
begin
Result := -1;
for Index := 0 to Count - 1 do
begin
if GetItem(Index) = AItem then
begin
Result := Index;
Break;
end;
end;
end;
// Protected methods
function TcaSingleVector.CreateCell: TcaCell;
begin
Result := TcaSingleCell.Create;
end;
// Property methods
function TcaSingleVector.GetItem(Index: Integer): Single;
begin
Result := TcaSingleCell(Cells[Index]).Value;
end;
function TcaSingleVector.GetItemString(Index: Integer): String;
begin
Result := FloatToStr(GetItem(Index));
end;
procedure TcaSingleVector.SetItem(Index: Integer; const Value: Single);
begin
TcaSingleCell(Cells[Index]).Value := Value;
end;
//---------------------------------------------------------------------------
// TcaDoubleVector
//---------------------------------------------------------------------------
// Public methods
function TcaDoubleVector.Add(const AItem: Double): Integer;
var
Cell: TcaCell;
begin
Cell := CreateCellObject;
TcaDoubleCell(Cell).Value := AItem;
Result := Cells.Add(Cell);
end;
procedure TcaDoubleVector.AddArray(AArray: array of Double);
var
Index: Integer;
begin
for Index := System.Low(AArray) to System.High(AArray) do
Add(AArray[Index]);
end;
function TcaDoubleVector.IndexOf(const AItem: Double): Integer;
var
Index: Integer;
begin
Result := -1;
for Index := 0 to Count - 1 do
begin
if GetItem(Index) = AItem then
begin
Result := Index;
Break;
end;
end;
end;
// Protected methods
function TcaDoubleVector.CreateCell: TcaCell;
begin
Result := TcaDoubleCell.Create;
end;
function TcaDoubleVector.GetItem(Index: Integer): Double;
begin
Result := TcaDoubleCell(Cells[Index]).Value;
end;
function TcaDoubleVector.GetItemString(Index: Integer): String;
begin
Result := FloatToStr(GetItem(Index));
end;
procedure TcaDoubleVector.SetItem(Index: Integer; const Value: Double);
begin
TcaDoubleCell(Cells[Index]).Value := Value;
end;
//---------------------------------------------------------------------------
// TcaExtendedVector
//---------------------------------------------------------------------------
// Public methods
function TcaExtendedVector.Add(const AItem: Extended): Integer;
var
Cell: TcaCell;
begin
Cell := CreateCellObject;
TcaExtendedCell(Cell).Value := AItem;
Result := Cells.Add(Cell);
end;
procedure TcaExtendedVector.AddArray(AArray: array of Extended);
var
Index: Integer;
begin
for Index := System.Low(AArray) to System.High(AArray) do
Add(AArray[Index]);
end;
function TcaExtendedVector.IndexOf(const AItem: Extended): Integer;
var
Index: Integer;
begin
Result := -1;
for Index := 0 to Count - 1 do
begin
if GetItem(Index) = AItem then
begin
Result := Index;
Break;
end;
end;
end;
// Protected methods
function TcaExtendedVector.CreateCell: TcaCell;
begin
Result := TcaExtendedCell.Create;
end;
function TcaExtendedVector.GetItem(Index: Integer): Extended;
begin
Result := TcaExtendedCell(Cells[Index]).Value;
end;
function TcaExtendedVector.GetItemString(Index: Integer): String;
begin
Result := FloatToStr(GetItem(Index));
end;
procedure TcaExtendedVector.SetItem(Index: Integer; const Value: Extended);
begin
TcaExtendedCell(Cells[Index]).Value := Value;
end;
end.
|
PROCEDURE SendFile(fileT : FileType; VAR crcMode : BOOLEAN);
CONST
SetFileAttribs = 30;
GetSetUser = 32;
fileMode : ARRAY [0..5] OF CHAR = '100644';
VAR
blk : DataBlock;
i,j : INTEGER;
strng : STRING[80];
bytesRemaining : REAL;
blkNum : BYTE;
response : ResponseType;
iFile : FILE;
oldUser : BYTE;
fcb : FcbType;
BEGIN
WITH fileT DO BEGIN
oldUser := Bdos(GetSetUser,$FF);
Bdos(GetSetUser,User);
Assign(iFile,MakeDName(fileT));
Reset(iFile);
{ block 0: filename length modtime filemode }
FOR i := 0 TO 127 DO
blk[i] := 0;
i := 0;
strng := MakePath(fileT);
FOR j := 1 TO Length(strng) DO BEGIN
blk[i] := Ord(strng[j]);
i := Succ(i);
END;
blk[i] := $00;
i := Succ(i);
Str(Bytes:8:0, strng);
FOR j := 1 TO Length(strng) DO BEGIN
IF strng[j] <> ' ' THEN BEGIN
blk[i] := Ord(strng[j]);
i := Succ(i);
END;
END;
blk[i] := Ord(' ');
i := Succ(i);
{ modification timestamp }
FOR j := 1 TO Length(ModTime) DO BEGIN
blk[i] := Ord(ModTime[j]);
i := Succ(i);
END;
blk[i] := Ord(' ');
i := Succ(i);
FOR j := 0 TO 5 DO BEGIN
blk[i] := Ord(fileMode[j]);
i := Succ(i);
END;
response := WaitNAK(60);
IF (response = GotNAK) OR (response = GotWantCRC) THEN BEGIN
crcMode := response = GotWantCRC;
response := SendBlock(0,blk,128,crcMode);
IF response = GotACK THEN BEGIN
FOR i := 0 TO 1023 DO
blk[i] := 0;
response := WaitNAK(60);
IF (response = GotNAK) OR (response = GotWantCRC) THEN BEGIN
crcMode := response = GotWantCRC;
bytesRemaining := Bytes;
blkNum := 1;
WHILE bytesRemaining > 0 DO BEGIN
IF bytesRemaining >= 1024 THEN BEGIN
BlockRead(iFile,blk,8);
response := SendBlock(blkNum,blk,1024,crcMode);
bytesRemaining := bytesRemaining - 1024;
END ELSE BEGIN
BlockRead(iFile,blk,1);
response := SendBlock(blkNum,blk,128,crcMode);
bytesRemaining := bytesRemaining - 128;
END;
IF response <> GotACK THEN BEGIN
IF response = GotABORT THEN
WriteLn('Send aborted.')
ELSE
WriteLn('Send failed (block #',blkNum,' not ACKed).');
Close(iFile);
Bdos(GetSetUser,oldUser);
Cancel;
Halt;
END;
blkNum := Succ(blkNum);
END;
Close(iFile);
response := SendEOT;
IF response = GotACK THEN BEGIN
{ Set archive bit to mark file as being backed up }
FillChar(fcb,36,0);
fcb.User := Ord(Drive) - Ord('A') + 1;
Move(Name,fcb.Name,8);
Move(Typ,fcb.Typ,3);
fcb.Typ[2] := Chr(Ord(fcb.Typ[2]) OR $80);
Bdos(SetFileAttribs,Addr(fcb));
END ELSE BEGIN
IF response = GotABORT THEN
WriteLn('Send aborted.')
ELSE
WriteLn('Send failed (EOT not ACKed).');
Close(iFile);
Bdos(GetSetUser,oldUser);
Cancel;
Halt;
END;
Bdos(GetSetUser,oldUser);
END;
END;
END;
END;
END;
|
unit XERO.Utils;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
System.Classes;
function IsEmptyString(AValue: string): boolean;
function StripCRLLF(AValue: string): string;
function URLEncode(const AStr: String): String;
function URLDecode(const AStr: string): string;
function GetURLSeperator(AURL: string): string;
function EncodeHTML(AValue: String): string;
function DecodeHTML(AValue: String): string;
implementation
uses
StrUtils, System.IOUtils,
Winapi.ShellAPI,
IdURI;
function StripCRLLF(AValue: string): string;
begin
Result := AValue;
Result := StringReplace(Result, #10, '', [rfReplaceAll]);
Result := StringReplace(Result, #13, '', [rfReplaceAll]);
end;
function GetURLSeperator(AURL: string): string;
begin
Result := '?';
if Pos('?', AURL) > 0 then
Result := '&';
end;
function IsEmptyString(AValue: string): boolean;
begin
Result := Trim(AValue) = '';
end;
function URLEncode(const AStr: String): String;
var
i: integer;
begin
Result := '';
for i := 1 to Length(AStr) do
if not(AStr[i] in ['A' .. 'Z', 'a' .. 'z', '0', '1' .. '9', '-', '_', '~',
'.']) then
Result := Result + '%' + inttohex(ord(AStr[i]), 2)
else
Result := Result + AStr[i];
end;
function URLDecode(const AStr: string): string;
var
i: integer;
b: Byte;
begin
Result := '';
i := 1;
while (i <= Length(AStr)) do
begin
if (AStr[i] = '%') then
begin
try
b := Byte(StrtoInt('$' + Copy(AStr, i + 1, 2)));
Result := Result + ANSIChar(b);
Inc(i, 2);
except
EXIT;
end;
end
else
Result := Result + AStr[i];
Inc(i);
end;
end;
function EncodeHTML(AValue: String): string;
begin
Result := ReplaceStr(AValue, '&', '&');
Result := ReplaceStr(Result, '<', '<');
Result := ReplaceStr(Result, '>', '>');
Result := ReplaceStr(Result, chr(39), ''');
Result := ReplaceStr(Result, '"', '"');
// Result := ReplaceStr(Result, #13, ' '); // CR
// Result := ReplaceStr(Result, #10, ' '); // LF
Result := ReplaceStr(Result, #13, '
'); // CR
Result := ReplaceStr(Result, #10, '
'); // LF
end;
function DecodeHTML(AValue: String): string;
begin
Result := ReplaceStr(AValue, '<', '<');
Result := ReplaceStr(Result, '>', '>');
Result := ReplaceStr(Result, ''', chr(39));
Result := ReplaceStr(Result, '"', '"');
Result := ReplaceStr(Result, '&', '&');
Result := ReplaceStr(Result, ' ', #10);
Result := ReplaceStr(Result, ' ', #13);
Result := ReplaceStr(Result, '
', #10);
Result := ReplaceStr(Result, '
', #13);
end;
end.
|
unit IdURI;
interface
type
TIdURI = class
protected
FDocument: string;
FProtocol: string;
FURI: string;
FPort: string;
Fpath: string;
FHost: string;
FBookmark: string;
procedure SetHost(const Value: string);
procedure SetDocument(const Value: string);
procedure SetBookmark(const Value: string);
procedure Setpath(const Value: string);
procedure SetPort(const Value: string);
procedure SetProtocol(const Value: string);
procedure SetURI(const Value: string);
procedure Refresh;
public
class procedure NormalizePath(var APath: string);
class procedure ParseURI(URI: string; var Protocol, Host, path, Document,
Port, Bookmark: string);
constructor Create(const AURI: string = ''); virtual;
property Protocol: string read FProtocol write SetProtocol;
property Path: string read Fpath write Setpath;
property Host: string read FHost write SetHost;
property Document: string read FDocument write SetDocument;
property Port: string read FPort write SetPort;
property URI: string read FURI write SetURI;
property Bookmark: string read FBookmark write SetBookmark;
end;
implementation
uses
IdGlobal, IdResourceStrings,
SysUtils;
constructor TIdURI.Create(const AURI: string = '');
begin
if length(AURI) > 0 then
begin
URI := AURI;
end;
end;
class procedure TIdURI.NormalizePath(var APath: string);
var
i: Integer;
begin
i := 1;
while i <= Length(APath) do
begin
if APath[i] in LeadBytes then
begin
inc(i, 2)
end
else
if APath[i] = '\' then
begin
APath[i] := '/';
inc(i, 1);
end
else
begin
inc(i, 1);
end;
end;
end;
class procedure TIdURI.ParseURI(URI: string; var Protocol, Host, path, Document,
Port, Bookmark: string);
var
sBuffer: string;
iTokenPos: Integer;
begin
Host := '';
Protocol := '';
Path := '';
Document := '';
NormalizePath(URI);
if IndyPos('://', URI) > 0 then
begin
iTokenPos := IndyPos('://', URI);
Protocol := Copy(URI, 1, iTokenPos - 1);
Delete(URI, 1, iTokenPos + 2);
sBuffer := fetch(URI, '/', true);
Host := fetch(sBuffer, ':', true);
Port := sBuffer;
iTokenPos := RPos('/', URI, -1);
Path := Copy(URI, 1, iTokenPos);
Delete(URI, 1, iTokenPos);
Document := URI;
end
else
begin
iTokenPos := RPos('/', URI, -1);
Path := Copy(URI, 1, iTokenPos);
Delete(URI, 1, iTokenPos);
Document := URI;
end;
if Copy(Path, 1, 1) <> '/' then
begin
Path := '/' + Path;
end;
sBuffer := Fetch(Document, '#');
Bookmark := Document;
Document := sBuffer;
end;
procedure TIdURI.Refresh;
begin
FURI := FProtocol + '://' + FHost;
if Length(FPort) > 0 then
FURI := FURI + ':' + FPort;
FURI := FURI + FPath + FDocument;
if Length(FBookmark) > 0 then
FURI := FURI + '#' + FBookmark;
end;
procedure TIdURI.SetBookmark(const Value: string);
begin
FBookmark := Value;
Refresh;
end;
procedure TIdURI.SetDocument(const Value: string);
begin
FDocument := Value;
Refresh;
end;
procedure TIdURI.SetHost(const Value: string);
begin
FHost := Value;
Refresh;
end;
procedure TIdURI.Setpath(const Value: string);
begin
Fpath := Value;
Refresh;
end;
procedure TIdURI.SetPort(const Value: string);
begin
FPort := Value;
Refresh;
end;
procedure TIdURI.SetProtocol(const Value: string);
begin
FProtocol := Value;
Refresh;
end;
procedure TIdURI.SetURI(const Value: string);
begin
FURI := Value;
NormalizePath(FURI);
ParseURI(FURI, FProtocol, FHost, FPath, FDocument, FPort, FBookmark);
end;
end.
|
{*******************************************************}
{ }
{ Delphi Visual Component Library }
{ Copyright(c) 2014-2018 Embarcadero Technologies, Inc. }
{ All rights reserved }
{ }
{*******************************************************}
unit HttpClientReg;
interface
procedure Register;
implementation
uses
DesignIntf, DesignEditors, System.Classes, System.Net.HttpClientComponent;
type
TNetHttpClientSelectionEditor = class(TSelectionEditor)
public
procedure RequiresUnits(Proc: TGetStrProc); override;
end;
procedure Register;
begin
RegisterComponents('Net', [TNetHttpClient, TNetHttpRequest]);
RegisterSelectionEditor(TNetHttpClient, TNetHttpClientSelectionEditor);
RegisterSelectionEditor(TNetHttpRequest, TNetHttpClientSelectionEditor);
end;
{ TNetHttpClientSelectionEditor }
procedure TNetHttpClientSelectionEditor.RequiresUnits(Proc: TGetStrProc);
begin
// Add needed used units to the uses clauses of the form where the component is located.
Proc('System.Net.URLClient');
Proc('System.Net.HttpClient');
Proc('System.Net.HttpClientComponent');
end;
end.
|
unit StringGridsUnit;
interface
uses
Winapi.Windows, System.SysUtils, System.Classes, System.Contnrs,
System.Win.ComObj, Vcl.Grids, StringGridExUnit;
type
TObjectStrings = class(TObjectList)
private
FName: string;
FTag: integer;
FDescription: string;
FConnectionString: string;
function GetItem(Index: Integer): TStringGrid;
procedure SetItem(Index: Integer; const Value: TStringGrid);
procedure SetName(const Value: string);
procedure SetConnectionString(const Value: string);
public
function Add: TStringGridEx;overload;
property Items[Index: Integer]: TStringGrid read GetItem write SetItem; default;
property Name: string read FName write SetName;
property Tag: integer read FTag write FTag;
property Description: string read FDescription write FDescription;
property ConnectionString: string read FConnectionString write SetConnectionString;
end;
TStringGrids = class(TObjectStrings);
implementation
{ TObjectStrings }
function TObjectStrings.Add: TStringGridEx;
begin
Result := TStringGridEx.Create(nil);
inherited Add(Result);
end;
function TObjectStrings.GetItem(Index: Integer): TStringGrid;
begin
Result := TStringGrid(inherited Items[Index]);
end;
procedure TObjectStrings.SetConnectionString(const Value: string);
begin
FConnectionString := Value;
end;
procedure TObjectStrings.SetItem(Index: Integer; const Value: TStringGrid);
begin
inherited Items[Index] := Value;
end;
procedure TObjectStrings.SetName(const Value: string);
begin
FName := Value;
end;
end.
|
program hello_world;
var
i: integer;
begin
for i := 0 to 10 do
writeln(Hello, world!);
end.
|
{$A8} {$R-}
{*************************************************************}
{ }
{ Embarcadero Delphi Visual Component Library }
{ InterBase Express core components }
{ }
{ Copyright (c) 1998-2017 Embarcadero Technologies, Inc.}
{ All rights reserved }
{ }
{ Additional code created by Jeff Overcash and used }
{ with permission. }
{*************************************************************}
unit IBX.IBVisualConst;
interface
resourcestring
SIBFilterBeginning = 'Partial match at beginning';
SIBFilterAnywhere = 'Partial match anywhere';
SIBFilterExact = 'Exact Match';
SIBFilterAtEnd = 'Partial match at end';
SIBFilterRange = 'Match Range';
SIBFilterNot = 'Not ';
SIBFilterCaption = 'IBX Filter Dialog';
SIBFilterNonIBXError = 'IBFilterDialog only works with IBDataSet or IBQuery components';
implementation
end.
|
unit FormCoordSystems;
interface
uses
System.SysUtils, System.Types, System.UITypes, System.Classes, System.Variants,
FMX.Types, FMX.Controls, FMX.Forms, FMX.Dialogs, FMX.Objects, FMX.Edit,
FMX.ListBox, FMX.Objects3D, FMX.Types3D, FMX.Ani;
type
TFormCoordSys = class(TForm)
grbInputData: TGroupBox;
lblLatitude: TLabel;
lblLongitude: TLabel;
lblH: TLabel;
edtLatitudeDeg: TEdit;
edtLongitudeDeg: TEdit;
edtH: TEdit;
lblX: TLabel;
lblY: TLabel;
lblZ: TLabel;
expMercator: TExpander;
expAzimut: TExpander;
lblXMercator: TLabel;
lblYMercator: TLabel;
lblXAzimut: TLabel;
lblYAzimut: TLabel;
edtXMercator: TEdit;
edtYMercator: TEdit;
edtLatitudeMin: TEdit;
edtLatitudeSec: TEdit;
edtLongitudeMin: TEdit;
edtLongitudeSec: TEdit;
lblLegend: TLabel;
edtXAzimut: TEdit;
edtYAzimut: TEdit;
edtXGeocenter: TEdit;
edtYGeocenter: TEdit;
edtZGeocenter: TEdit;
pnlData: TPanel;
lblInfo: TLabel;
pnlGraphics: TPanel;
expGeocenter: TExpander;
pnlUP: TPanel;
pnlDown: TPanel;
splHorizontal: TSplitter;
lblLatBase: TLabel;
pnlMercatorUL: TPanel;
splVertUp: TSplitter;
pnlAzimutUR: TPanel;
pnlGaussDL: TPanel;
splVertDown: TSplitter;
pnlCoordModel3D: TPanel;
imgMercator: TImage;
pnlMercatorParams: TPanel;
lblMercatoParams: TLabel;
chbAllMercator: TCheckBox;
cbLatMinMercator: TComboBox;
cbLatMaxMercator: TComboBox;
cbLongMinMercator: TComboBox;
cbLongMaxMercator: TComboBox;
lblMin: TLabel;
lblMax: TLabel;
lblMercLat: TLabel;
lblMercLong: TLabel;
cbStepMercator: TComboBox;
lblStepMercator: TLabel;
expGauss: TExpander;
trbCrossLatitude: TTrackBar;
edtCrossLatitude: TEdit;
edtXGauss: TEdit;
edtYGauss: TEdit;
lblXGauss: TLabel;
lblYGauss: TLabel;
lblNomenclatura: TLabel;
lblScale: TLabel;
cbScale: TComboBox;
edtNomenclatura: TEdit;
pnlGaussParams: TPanel;
imgGauss: TImage;
pnlAzimut: TPanel;
imgAzimut: TImage;
lblGaussParams: TLabel;
lblAzimutParams: TLabel;
cbLatMaxAzimut: TComboBox;
cbLatMinAzimut: TComboBox;
cbLongMinAzimut: TComboBox;
cbLongMaxAzimut: TComboBox;
lblMaxAzim: TLabel;
lblMinAzim: TLabel;
lblAzimLat: TLabel;
cbStepLatAzimut: TComboBox;
lblStepAzimut: TLabel;
chbAllAzimut: TCheckBox;
lblAzimLong: TLabel;
cbStepLongAzimut: TComboBox;
lblStepGauss: TLabel;
vp3dGeo: TViewport3D;
cmrGeo: TCamera;
lghtGeo: TLight;
mdl3dGeo: TModel3D;
sphrGeo: TSphere;
grd3dGeo: TGrid3D;
btnHelpGeocenter: TButton;
btnHelpMercator: TButton;
btnHelpGauss: TButton;
btnHelpAzimut: TButton;
btnHelpGeo: TButton;
procedure FormCreate(Sender: TObject);
procedure pnlGraphicsResize(Sender: TObject);
procedure edtLongitudeDegChange(Sender: TObject);
procedure edtHChange(Sender: TObject);
procedure edtLatitudeDegKeyUp(Sender: TObject; var Key: Word;
var KeyChar: Char; Shift: TShiftState);
procedure chbAllMercatorChange(Sender: TObject);
procedure cbStepMercatorChange(Sender: TObject);
procedure trbCrossLatitudeChange(Sender: TObject);
procedure chbAllAzimutChange(Sender: TObject);
procedure cbStepLatAzimutChange(Sender: TObject);
procedure imgAzimutResize(Sender: TObject);
procedure cbScaleChange(Sender: TObject);
procedure edtLatitudeDegChange(Sender: TObject);
procedure btnHelpGeoClick(Sender: TObject);
procedure btnHelpGeocenterClick(Sender: TObject);
procedure btnHelpMercatorClick(Sender: TObject);
procedure btnHelpGaussClick(Sender: TObject);
procedure btnHelpAzimutClick(Sender: TObject);
private
procedure ShowData();
procedure Calc(lat, long, _height: Double);
procedure ShowOutData();
procedure DrawData();
procedure ClearFields();
procedure ClearFieldsMercator();
procedure ClearFieldsGeocentric();
procedure ClearFieldsGauss();
procedure ClearFieldsAzimut();
procedure DrawMercator(X, Y: Double; latMin, latMax, longMin, longMax: Double;
step: Integer; canvas: TCanvas);
procedure DrawAzimut(X, Y: Double; latMin,
latMax, longMin, longMax, stepLat, stepLong: Integer; canvas: TCanvas);
procedure DrawGauss(X, Y, latMin, latMax, longMin, longMax, step: Double;
canvas: TCanvas);
procedure PreDrawMercator();
procedure PreDrawAzimut();
procedure PreDrawGauss();
var
Latitude, Longitude, gHeight, MercatorX, MercatorY,
GeocentricX, GeocentricY, GeocentricZ, LatitudeSK_42, LongitudeSK_42,
gHeightSK_42, AzimutX, AzimutY, GaussX, GaussY, stepGauss: Double;
Nzone: Integer; LitZone, Nomenclatura: string;
HTMLFile: string;
public
{ Public declarations }
end;
var
FormCoordSys: TFormCoordSys;
implementation
{$R *.fmx}
uses
Windows, Math, ShellAPI, CoordSysFunc;
procedure SetValue(i: Integer; edit: TEdit); overload; forward;
procedure SetValue(d: Double; edit: TEdit); overload; forward;
procedure SetValue(s: String; edit: TEdit); overload; forward;
procedure SetValue(i: Integer; edit: TEdit);
var onChangeOld: TNotifyEvent;
begin
onChangeOld := edit.OnChange;
edit.OnChange := nil;
edit.Text := IntToStr(i);
edit.OnChange := onChangeOld;
end;
procedure SetValue(d: Double; edit: TEdit);
var onChangeOld: TNotifyEvent;
begin
onChangeOld := edit.OnChange;
edit.OnChange := nil;
edit.Text := FloatToStrF(d, ffGeneral, 11, 3);
edit.OnChange := onChangeOld;
end;
procedure SetValue(s: String; edit: TEdit);
var onChangeOld: TNotifyEvent;
begin
onChangeOld := edit.OnChange;
edit.OnChange := nil;
edit.Text := s;
edit.OnChange := onChangeOld;
end;
procedure TFormCoordSys.btnHelpAzimutClick(Sender: TObject);
begin
HTMLFile := 'help\azimut.html';
ShellExecute(0, 'open', PWideChar(HTMLFile), nil, nil, SW_SHOWNORMAL);
end;
procedure TFormCoordSys.btnHelpGaussClick(Sender: TObject);
begin
HTMLFile := 'help\gauss.html';
ShellExecute(0, 'open', PChar(HTMLFile), nil, nil, SW_SHOWNORMAL);
end;
procedure TFormCoordSys.btnHelpGeocenterClick(Sender: TObject);
begin
HTMLFile := 'help\geocenter.html';
ShellExecute(0, 'open', PChar(HTMLFile), nil, nil, SW_SHOWNORMAL);
end;
procedure TFormCoordSys.btnHelpGeoClick(Sender: TObject);
begin
HTMLFile := 'help\geographic.html';
ShellExecute(0, 'open', PChar(HTMLFile), nil, nil, SW_SHOWNORMAL);
end;
procedure TFormCoordSys.btnHelpMercatorClick(Sender: TObject);
begin
HTMLFile := 'help\mercator.html';
ShellExecute(0, 'open', PChar(HTMLFile), nil, nil, SW_SHOWNORMAL);
end;
procedure TFormCoordSys.Calc(lat, long, _height: Double);
begin
GeographicToGeocentric(lat, long, _height, GeocentricX,
GeocentricY, GeocentricZ);
GeographicToMercator(lat, long, MercatorX, MercatorY);
GeographicToAzimut(lat, long, _height, DegToRad(StrToFloat(edtCrossLatitude.Text)),
AzimutX, AzimutY);
GeographicToGauss(lat, long, _height, false, GaussX, GaussY, Nzone, LitZone);
end;
procedure TFormCoordSys.ShowOutData();
begin
SetValue(GeocentricX, edtXGeocenter);
SetValue(GeocentricY, edtYGeocenter);
SetValue(GeocentricZ, edtZGeocenter);
SetValue(MercatorX, edtXMercator);
SetValue(MercatorY, edtYMercator);
SetValue(AzimutX, edtXAzimut);
SetValue(AzimutY, edtYAzimut);
SetValue(GaussX, edtXGauss);
SetValue(GaussY + Nzone*1000000, edtYGauss);
end;
procedure TFormCoordSys.DrawData();
begin
PreDrawMercator();
PreDrawAzimut();
PreDrawGauss();
end;
procedure TFormCoordSys.trbCrossLatitudeChange(Sender: TObject);
begin
edtCrossLatitude.Text := IntToStr(Round(trbCrossLatitude.Value));
GeographicToAzimut(Latitude, Longitude, gHeight, DegToRad(StrToFloat(edtCrossLatitude.Text)),
AzimutX, AzimutY);
ShowOutData();
PreDrawAzimut();
end;
procedure TFormCoordSys.PreDrawMercator();
begin
if chbAllMercator.IsChecked = true then
begin
// -90 and 90 cannot be used!
DrawMercator(MercatorX, MercatorY, -89, 89, -180, 180,
StrToInt(cbStepMercator.Selected.Text), imgMercator.Bitmap.Canvas);
end
else
begin
DrawMercator(MercatorX, MercatorY, StrToInt(cbLatMinMercator.Selected.Text),
StrToInt(cbLatMaxMercator.Selected.Text), StrToInt(cbLongMinMercator.Selected.Text),
StrToInt(cbLongMaxMercator.Selected.Text), StrToInt(cbStepMercator.Selected.Text),
imgMercator.Bitmap.Canvas);
end;
end;
procedure TFormCoordSys.PreDrawAzimut();
begin
if chbAllAzimut.IsChecked = True then
begin
DrawAzimut(AzimutX, AzimutY, 0, 90, -180, 180, StrToInt(cbStepLatAzimut.Selected.Text),
StrToInt(cbStepLongAzimut.Selected.Text), imgAzimut.Bitmap.Canvas);
end
else
begin
DrawAzimut(AzimutX, AzimutY, StrToInt(cbLatMinAzimut.Selected.Text),
StrToInt(cbLatMaxAzimut.Selected.Text), StrToInt(cbLongMinAzimut.Selected.Text),
StrToInt(cbLongMaxAzimut.Selected.Text), StrToInt(cbStepLatAzimut.Selected.Text),
StrToInt(cbStepLongAzimut.Selected.Text), imgAzimut.Bitmap.Canvas);
end;
end;
procedure TFormCoordSys.PreDrawGauss();
var latMin, latMax, longMin, longMax, step: Double;
begin
GetListGauss(Latitude, Longitude, GetScaleFactor(cbScale.Selected.Text),
latMin, latMax, longMin, longMax, step);
if step >= 1 then
begin
stepGauss := step;
lblStepGauss.Text := IntToStr(Round(stepGauss)) + ' deg';
end
else
if step >= (1/60) then
begin
stepGauss := step * 60;
lblStepGauss.Text := IntToStr(Round(stepGauss)) + #39;
end
else
begin
stepGauss := step * 3600;
lblStepGauss.Text := IntToStr(Round(stepGauss)) + #39 + #39;
end;
DrawGauss(GaussX, GaussY, latMin, latMax, longMin, longMax, step,
imgGauss.Bitmap.Canvas);
end;
procedure TFormCoordSys.cbScaleChange(Sender: TObject);
begin
PreDrawGauss();
end;
procedure TFormCoordSys.cbStepLatAzimutChange(Sender: TObject);
begin
PreDrawAzimut();
end;
procedure TFormCoordSys.cbStepMercatorChange(Sender: TObject);
begin
if (StrToInt(cbLatMinMercator.Selected.Text) < StrToInt(cbLatMaxMercator.Selected.Text))
or (StrToInt(cbLongMinMercator.Selected.Text) < StrToInt(cbLongMaxMercator.Selected.Text)) then
begin
PreDrawMercator();
end
else
begin
imgMercator.Bitmap.Clear(TAlphaColors.White);
imgMercator.Repaint;
end;
end;
procedure TFormCoordSys.chbAllMercatorChange(Sender: TObject);
begin
if chbAllMercator.IsChecked = true then
begin
cbLatMinMercator.Enabled := False;
cbLatMaxMercator.Enabled := False;
cbLongMinMercator.Enabled := False;
cbLongMaxMercator.Enabled := False;
PreDrawMercator();
end
else
begin
cbLatMinMercator.Enabled := True;
cbLatMaxMercator.Enabled := True;
cbLongMinMercator.Enabled := True;
cbLongMaxMercator.Enabled := True;
PreDrawMercator();
end;
end;
procedure TFormCoordSys.chbAllAzimutChange(Sender: TObject);
begin
if chbAllAzimut.IsChecked = true then
begin
cbLatMinAzimut.Enabled := False;
cbLatMaxAzimut.Enabled := False;
cbLongMinAzimut.Enabled := False;
cbLongMaxAzimut.Enabled := False;
PreDrawAzimut();
end
else
begin
cbLatMinAzimut.Enabled := True;
cbLatMaxAzimut.Enabled := True;
cbLongMinAzimut.Enabled := True;
cbLongMaxAzimut.Enabled := True;
PreDrawAzimut();
end;
end;
procedure TFormCoordSys.edtHChange(Sender: TObject);
var _height: Double;
begin
ClearFields();
try
_height := StrToFloat(edtH.Text);
gHeight := _height;
Calc(Latitude, Longitude, gHeight);
ShowOutData();
except
on EConvertError do
end;
end;
procedure TFormCoordSys.edtLatitudeDegChange(Sender: TObject);
var deg, min, sec: Double;
begin
ClearFields();
try
deg := StrToFloat(edtLatitudeDeg.Text);
if (deg < 90) and (deg > -90) then
begin
min := StrToFloat(edtLatitudeMin.Text);
if (min > 60)or(min < 0) then
begin
min := 0;
end;
sec := StrToFloat(edtLatitudeSec.Text);
if (sec > 60)or(sec < 0) then
begin
sec := 0;
end;
Latitude := DmsToRad(deg, min, sec);
ShowData();
end
else
begin
if deg >= 90 then
begin
deg := 90;
end
else
begin
deg := -90;
end;
min := 0;
sec := 0;
Latitude := DmsToRad(deg, min, sec);
ShowData();
end;
Calc(Latitude, Longitude, gHeight);
ShowOutData();
DrawData();
except
on EConvertError do
end;
end;
procedure TFormCoordSys.edtLatitudeDegKeyUp(Sender: TObject; var Key: Word;
var KeyChar: Char; Shift: TShiftState);
var OnChange: TNotifyEvent;
begin
OnChange := TEdit(Sender).OnChange;
if @OnChange <> nil then
OnChange(Sender);
end;
procedure TFormCoordSys.edtLongitudeDegChange(Sender: TObject);
var deg, min, sec: Double;
begin
ClearFields();
try
deg := StrToFloat(edtLongitudeDeg.Text);
if (deg < 180) and (deg > -180) then
begin
min := StrToFloat(edtLongitudeMin.Text);
if (min > 60)or(min < 0) then
begin
min := 50;
end;
sec := StrToFloat(edtLongitudeSec.Text);
if (sec > 60)or(sec < 0) then
begin
sec := 50;
end;
Longitude := DmsToRad(deg, min, sec);
ShowData();
end
else
begin
if deg >= 180 then
begin
deg := 179;
end
else
begin
deg := -179;
end;
min :=50;
sec := 50;
Longitude := DmsToRad(deg, min, sec);
ShowData();
end;
Calc(Latitude, Longitude, gHeight);
ShowOutData();
DrawData();
except
on EConvertError do
end;
end;
procedure TFormCoordSys.FormCreate(Sender: TObject);
var
I, counter: Integer; onResize: TNotifyEvent;
begin
onResize := imgAzimut.OnResize;
imgAzimut.OnResize := nil;
HTMLFile := 'help/geographic.html';
// Set values to Comboboxes of Mercator and stereographic visualization params
for counter := -4 to 4 do
begin
I:= counter * 20;
cbLatMinMercator.Items.Add(IntToStr(I));
cbLatMaxMercator.Items.Add(IntToStr(I));
if I >= 0 then
begin
cbLatMinAzimut.Items.Add(IntToStr(I));
cbLatMaxAzimut.Items.Add(IntToStr(I));
end;
end;
for counter := -9 to 9 do
begin
I := counter * 20;
cbLongMinMercator.Items.Add(IntToStr(I));
cbLongMaxMercator.Items.Add(IntToStr(I));
cbLongMinAzimut.Items.Add(IntToStr(I));
cbLongMaxAzimut.Items.Add(IntToStr(I));
end;
// Set step param of Mercator's and stereographic's projections visualization
cbStepMercator.Items.Add(IntToStr(5));
cbStepMercator.Items.Add(IntToStr(10));
cbStepMercator.Items.Add(IntToStr(20));
cbStepLatAzimut.Items.Add(IntToStr(5));
cbStepLatAzimut.Items.Add(IntToStr(10));
cbStepLatAzimut.Items.Add(IntToStr(20));
cbStepLongAzimut.Items.Add(IntToStr(5));
cbStepLongAzimut.Items.Add(IntToStr(10));
cbStepLongAzimut.Items.Add(IntToStr(20));
// Set List of scales
cbScale.Items.Add('1:1000000');
cbScale.Items.Add('1:500000');
cbScale.Items.Add('1:100000');
cbScale.Items.Add('1:50000');
cbScale.Items.Add('1:25000');
cbScale.Items.Add('1:10000');
// Set geographic coords of Kiev as default values
Latitude := DmsToRad(50,27,01);
Longitude := DmsToRad(30,31,22);
gHeight := 202;
ShowData();
Calc(Latitude, Longitude, gHeight);
ShowOutData();
// Make an equivalent size of all graphic panels
pnlGraphicsResize(nil);
imgMercator.Bitmap.SetSize(Round(imgMercator.Width), Round(imgMercator.Height));
imgAzimut.Bitmap.SetSize(Round(imgAzimut.Width), Round(imgAzimut.Height));
imgGauss.Bitmap.SetSize(Round(imgGauss.Width), Round(imgGauss.Height));
imgMercator.Bitmap.Canvas.Fill.Color := TAlphaColors.Black;
imgMercator.Bitmap.Canvas.Font.Size := 10;
imgAzimut.Bitmap.Canvas.Fill.Color := TAlphaColors.Black;
imgAzimut.Bitmap.Canvas.Font.Size := 10;
imgGauss.Bitmap.Canvas.Fill.Color := TAlphaColors.Black;
imgGauss.Bitmap.Canvas.Font.Size := 10;
imgMercator.Bitmap.Canvas.Stroke.Color := TAlphaColors.Blue;
imgAzimut.Bitmap.Canvas.Stroke.Color := TAlphaColors.Blue;
imgGauss.Bitmap.Canvas.Stroke.Color := TAlphaColors.Blue;
DrawData();
imgAzimut.OnResize := onResize;
end;
procedure TFormCoordSys.imgAzimutResize(Sender: TObject);
begin
imgMercator.Bitmap.SetSize(Round(imgMercator.Width), Round(imgMercator.Height));
imgAzimut.Bitmap.SetSize(Round(imgAzimut.Width), Round(imgAzimut.Height));
imgGauss.Bitmap.SetSize(Round(imgGauss.Width), Round(imgGauss.Height));
DrawData();
end;
procedure TFormCoordSys.pnlGraphicsResize(Sender: TObject);
begin
pnlUP.Height := (pnlGraphics.Height - splHorizontal.Height) / 2;
pnlMercatorUL.Width := (pnlGraphics.Width - splVertUp.Width) / 2;
pnlGaussDL.Width := (pnlGraphics.Width - splVertDown.Width) / 2;
end;
procedure TFormCoordSys.ShowData();
begin
// Set values to Latitude edits
SetValue(RadToDegInDms(Latitude), edtLatitudeDeg);
SetValue(RadToMinInDms(Latitude), edtLatitudeMin);
SetValue(RadToSecInDms(Latitude), edtLatitudeSec);
// Set values to Longitude edits
SetValue(RadToDegInDms(Longitude), edtLongitudeDeg);
SetValue(RadToMinInDms(Longitude), edtLongitudeMin);
SetValue(RadToSecInDms(Longitude), edtLongitudeSec);
// Set values to Height edit
SetValue(gHeight, edtH);
end;
procedure TFormCoordSys.ClearFields();
begin
ClearFieldsMercator();
ClearFieldsGeocentric();
ClearFieldsGauss();
ClearFieldsAzimut();
end;
procedure TFormCoordSys.ClearFieldsGauss();
begin
SetValue('', edtXGauss);
SetValue('', edtYGauss);
end;
procedure TFormCoordSys.ClearFieldsAzimut();
begin
SetValue('', edtXAzimut);
SetValue('', edtYAzimut);
end;
procedure TFormCoordSys.ClearFieldsMercator();
begin
SetValue('', edtXMercator);
SetValue('', edtYMercator);
end;
procedure TFormCoordSys.ClearFieldsGeocentric();
begin
SetValue('', edtXGeocenter);
SetValue('', edtYGeocenter);
SetValue('', edtZGeocenter);
end;
procedure TFormCoordSys.DrawMercator(X, Y: Double; latMin, latMax, longMin,
longMax: Double; step: Integer; canvas: TCanvas);
var XMaxPaint, YMaxPaint, Lat, Long: Integer;
pointStart, pointStop: TPointF; Xmin, Ymin, Xmax, Ymax, horiz, vert,
paramMercatorHoriz, paramMercatorVert, _x, _y: Double; _temp: string;
rect: TRectF; rectText: TRectF; pointText : TPointF;
begin
// Clear Bitmap to get empty Canvas to draw
imgMercator.Bitmap.Clear(TAlphaColors.White);
if (latMin < latMax) and (longMin < longMax) then
begin
// Set borders for paint
YMaxPaint := Round(imgMercator.Height-40);
XMaxPaint := Round(imgMercator.Width-40);
// Find Min and Max Coords for visualization
GeographicToMercator(DegToRad(latMin), DegToRad(longMin), Xmin, Ymin);
GeographicToMercator(DegToRad(latMax), DegToRad(longMax), Xmax, Ymax);
horiz := Xmax - Xmin;
vert := Ymax - Ymin;
// Params of convertation to screen coords
paramMercatorVert := YMaxPaint/vert;
paramMercatorHoriz := XMaxPaint/horiz;
Lat := Round(latMin);
Long := Round(longMin);
with canvas do
begin
if Lat < -80 then
begin
Lat := -80;
end;
canvas.BeginScene();
canvas.Stroke.Color := TAlphaColors.Blue;
// Draw meridians
while Long <= longMax do
begin
GeographicToMercator(DegToRad(latMin), DegToRad(Long), _x, _y);
pointStart := TPointF.Create(Round((_x - Xmin)*paramMercatorHoriz) + 20,
Round((vert - (_y - Ymin))*paramMercatorVert) + 20);
GeographicTOMercator(DegToRad(latMax), DegToRad(Long), _x, _y);
pointStop := TPointF.Create(Round((_x - Xmin)*paramMercatorHoriz + 20),
Round((vert - (_y - Ymin))*paramMercatorVert) + 20);
canvas.DrawLine(pointStart, pointStop, 100);
// Draw numeration of Longitudes ... -20, 0, 20, 40, 60 ...
if (Long mod 20) = 0 then
begin
canvas.Fill.Color := TAlphaColors.Black;
pointText := TPointF.Create(pointStart.X - 10, pointStart.Y + 2);
rectText := TRectF.Create(pointText, 20, 18);
canvas.FillText(rectText, IntToStr(Abs(Long)), False, 100,
[TFillTextFlag.ftRightToLeft], TTextAlign.taCenter, TTextAlign.taCenter);
pointText := TPointF.Create(pointStop.X - 10, pointStop.Y - 16);
rectText := TRectF.Create(pointText, 20, 14);
canvas.FillText(rectText, IntToStr(Abs(Long)), False, 100,
[TFillTextFlag.ftRightToLeft], TTextAlign.taCenter, TTextAlign.taCenter);
end;
Long := Long + step;
end;
// Draw parallels
while Lat <= latMax do
begin
GeographicToMercator(DegToRad(Lat), DegToRad(longMin), _x, _y);
pointStart := TPointF.Create(Round((_x - Xmin)*paramMercatorHoriz) + 20,
Round((vert - (_y - Ymin))*paramMercatorVert) + 20);
GeographicTOMercator(DegToRad(Lat), DegToRad(longMax), _x, _y);
pointStop := TPointF.Create(Round((_x - Xmin)*paramMercatorHoriz + 20),
Round((vert - (_y - Ymin))*paramMercatorVert) + 20);
canvas.DrawLine(pointStart, pointStop, 100);
// Draw numeration of Latitudes ... 0, 20, 40 ...
if (Lat mod 20) = 0 then
begin
pointText := TPointF.Create(pointStart.X - 18, pointStart.Y -6);
rectText := TRectF.Create(pointText, 16, 12);
canvas.FillText(rectText, IntToStr(Abs(Lat)), False, 100,
[TFillTextFlag.ftRightToLeft], TTextAlign.taCenter, TTextAlign.taCenter);
pointText := TPointF.Create(pointStop.X + 2, pointStop.Y - 6);
rectText := TRectF.Create(pointText, 16, 12);
canvas.FillText(rectText, IntToStr(Abs(Lat)), False, 100,
[TFillTextFlag.ftRightToLeft], TTextAlign.taCenter, TTextAlign.taCenter);
end;
Lat := Lat + step;
end;
// Draw point that has input geographic coords
pointStart := TPointF.Create(Round((X - Xmin)*paramMercatorHoriz) + 20,
Round((vert - (Y - Ymin))*paramMercatorVert) + 20);
rect := TRectF.Create(pointStart.X - 3, pointStart.Y - 3,
pointStart.X + 3, pointStart.Y + 3);
Canvas.Fill.Color := TAlphaColors.Red;
canvas.FillEllipse(rect, 100);
Canvas.Fill.Color := TAlphaColors.Black;
canvas.EndScene();
end;
end;
imgMercator.Repaint();
end;
procedure TFormCoordSys.DrawAzimut(X, Y: Double; latMin,
latMax, longMin, longMax, stepLat, stepLong: Integer; canvas: TCanvas);
var XMaxPaint, YMaxPaint, rAzimut, Xmin, Xmax, Ymin, Ymax, _x, _y, paramTransform,
paramVert, horiz, vert: Double; dx, dy, _longText: Integer;
centerX, centerY, R, Rmax, Lat, Long: Integer; rect, rectText: TRectF;
pointStart, pointStop, pointCenter, pointRadius, pointText: TPointF;
begin
imgAzimut.Bitmap.Clear(TAlphaColors.Lightskyblue);
canvas.Fill.Color := TAlphaColors.Black;
if (latMin < latMax) then
begin
YMaxPaint := Round(imgAzimut.Height-40);
XMaxPaint := Round(imgAzimut.Width-40);
centerX := Round(imgAzimut.Width / 2);
centerY := Round(imgAzimut.Height / 2);
GeographicToAzimut(DegToRad(latMin), DegToRad(0), gHeight,
DegToRad(StrToInt(edtCrossLatitude.Text)), _x, _y);
horiz := _x * 2;
vert := _x * 2;
paramTransform := YMaxPaint / vert;
Rmax := Round(_x * paramTransform);
pointCenter := TPointF.Create(centerX, centerY);
Lat := Round(latMin);
Long := Round(longMin);
// Draw section
with canvas do
begin
canvas.BeginScene();
canvas.Fill.Color := TAlphaColors.White;
canvas.Stroke.Color := TAlphaColors.Blue;
while Long >= longMax do
begin
longMax := longMax + 360;
end;
// Draw Meridians
while Long <= longMax do
begin
pointStart := TPointF.Create(centerX + Rmax * Cos(DegToRad(Long)),
centerY - Rmax * Sin(DegToRad(Long)));
GeographicToAzimut(DegToRad(latMax), DegToRad(0), gHeight,
DegToRad(StrToInt(edtCrossLatitude.Text)), _x, _y);
rAzimut := _x;
R := Round(rAzimut * paramTransform);
pointStop := TPointF.Create(centerX + R * Cos(DegToRad(Long)),
centerY - R * Sin(DegToRad(Long)));
canvas.DrawLine(pointStart, pointStop, 100);
Canvas.Fill.Color := TAlphaColors.Black;
// Draw longitude values of meridians that are devided by 20
if (Long mod 20) = 0 then
begin
_longText := Long;
while _longText > 180 do
begin
_longText := _longText - 360;
end;
pointText := TPointF.Create(centerX+(Rmax+10)*(pointStart.X-centerX)/Rmax - 11,
centerY+(Rmax+10)*(pointStart.Y-centerY)/Rmax - 10);
rectText := TRectF.Create(pointText, 20, 18);
canvas.FillText(rectText, IntToStr(Abs(_longText)), False, 100,
[TFillTextFlag.ftRightToLeft], TTextAlign.taCenter, TTextAlign.taCenter);
end;
Long := Long + stepLong;
end;
// Draw paralels as arcs of ellipse with a=b=R
while Lat <= latMax do
begin
GeographicToAzimut(DegToRad(Lat), DegToRad(0), gHeight,
DegToRad(StrToInt(edtCrossLatitude.Text)), _x, _y);
rAzimut := _x;
R := Round(rAzimut * paramTransform);
pointRadius := TPointF.Create(R, R);
canvas.DrawArc(pointCenter, pointRadius, GetStartAngle(longMax),
GetArcAngle(longMin, longMax), 100);
// Draw latitude values of paralels that are devided by 20
if (Lat mod 20) = 0 then
begin
dx := 0;
dy := 0;
if longMax = 0 then
begin
dx := -12;
end;
pointText := TPointF.Create(centerX + Round(R*Cos(DegToRad(GetStartAngle(longMax)))+1+dx),
centerY + Round(R*Sin(DegToRad(GetStartAngle(longMax))))+dy);
rectText := TRectF.Create(pointText, 10, 10);
canvas.FillText(rectText, IntToStr(Abs(Lat)), False, 100,
[TFillTextFlag.ftRightToLeft], TTextAlign.taCenter, TTextAlign.taCenter);
dx := 0;
dy := 0;
if longMin = 0 then
begin
dx := -12;
end;
pointText := TPointF.Create(centerX + Round(R*Cos(DegToRad(GetStartAngle(longMin)))+1+dx),
centerY + Round(R*Sin(DegToRad(GetStartAngle(longMin))))+dy);
rectText := TRectF.Create(pointText, 10, 10);
canvas.FillText(rectText, IntToStr(Abs(Lat)), False, 100,
[TFillTextFlag.ftRightToLeft], TTextAlign.taCenter, TTextAlign.taCenter);
end;
Lat := Lat + stepLat;
end;
// Draw point with input geographic coords
Canvas.Fill.Color := TAlphaColors.Black;
pointStart := TPointF.Create(centerX + Round(X*paramTransform),
centerY - Round(Y*paramTransform));
rect := TRectF.Create(pointStart.X - 3, pointStart.Y - 3,
pointStart.X + 3, pointStart.Y + 3);
Canvas.Fill.Color := TAlphaColors.Red;
canvas.FillEllipse(rect, 100);
Canvas.Fill.Color := TAlphaColors.Black;
canvas.EndScene();
end;
end;
imgAzimut.Repaint();
end;
procedure TFormCoordSys.DrawGauss(X, Y, latMin, latMax, longMin, longMax, step
: Double; canvas: TCanvas);
var XMaxPaint, YMaxPaint: Integer;
pointStart, pointStop: TPointF; Xmin, Ymin, Xmax, Ymax, horiz, vert,
paramGaussHoriz, paramGaussVert, _x, _y, Lat, Long: Double; _temp: string;
rect: TRectF; rectText: TRectF; pointText : TPointF; I, J: Integer;
begin
imgGauss.Bitmap.Clear(TAlphaColors.White);
// Set borders for paint
YMaxPaint := Round(imgGauss.Height-40);
XMaxPaint := Round(imgGauss.Width-80);
// Find Min and Max Coords for visualization
GeographicToGauss(DegToRad(latMin), DegToRad(longMin), Nzone, Xmin, Ymin);
GeographicToGauss(DegToRad(latMin), DegToRad(longMax), Nzone, _x, Ymax);
//Ymax := 500000 - (Ymax - 500000);
GeographicToGauss(DegToRad(latMax), DegToRad(longMax), Nzone, Xmax, _y);
if Ymax < _y then
begin
Ymax := _y;
end;
vert := Abs(Xmax - Xmin);
horiz := Abs(Ymax - Ymin);
// Params of convertation to screen coords
paramGaussHoriz := XMaxPaint/horiz;
paramGaussVert := YMaxPaint/vert;
Lat := latMin;
Long := longMin;
//Draw section
canvas.BeginScene();
canvas.Stroke.Color := TAlphaColors.Blue;
// Draw meridians
for I := 0 to Round((longMax-longMin)/step) do
begin
Long := longMin + I * step;
GeographicToGauss(DegToRad(latMin), DegToRad(Long), Nzone, _x, _y);
pointStart := TPointF.Create(Round((_y - Ymin)*paramGaussHoriz) + 40,
Round((vert - (_x - Xmin))*paramGaussVert) + 20);
GeographicToGauss(DegToRad(latMax), DegToRad(Long), Nzone, _x, _y);
pointStop := TPointF.Create(Round((_y - ymin)*paramGaussHoriz + 40),
Round((vert - (_x - Xmin))*paramGaussVert) + 20);
if (Long = longMin) or (Long = longMax) then
begin
canvas.Stroke.Color := TAlphaColors.Blueviolet;
end;
canvas.DrawLine(pointStart, pointStop, 100);
canvas.Stroke.Color := TAlphaColors.Blue;
// Longitude's numbers are drawing
canvas.Fill.Color := TAlphaColors.Black;
pointText := TPointF.Create(pointStart.X - 10, pointStart.Y + 2);
rectText := TRectF.Create(pointText, 25, 18);
canvas.FillText(rectText, FloatToStrF(Abs(Long), ffGeneral, 4,2), False, 100,
[TFillTextFlag.ftRightToLeft], TTextAlign.taCenter, TTextAlign.taCenter);
pointText := TPointF.Create(pointStop.X - 10, pointStop.Y - 16);
rectText := TRectF.Create(pointText, 25, 14);
canvas.FillText(rectText, FloatToStrF(Abs(Long), ffGeneral, 4,2), False, 100,
[TFillTextFlag.ftRightToLeft], TTextAlign.taCenter, TTextAlign.taCenter);
end;
// Draw parallels
for I := 0 to Round((latMax-latMin)/step) do
begin
Lat := latMin + I * step;
// Draw lines of paralel between two meridians
Long := longMin;
for J := 0 to Round((longMax-longMin)/step)-1 do
begin
Long := longMin + J * step;
GeographicToGauss(DegToRad(Lat), DegToRad(Long), Nzone, _x, _y);
pointStart := TPointF.Create(Round((_y - Ymin)*paramGaussHoriz) + 40,
Round((vert - (_x - Xmin))*paramGaussVert) + 20);
GeographicToGauss(DegToRad(Lat), DegToRad(Long + step), Nzone, _x, _y);
pointStop := TPointF.Create(Round((_y - Ymin)*paramGaussHoriz + 40),
Round((vert - (_x - Xmin))*paramGaussVert) + 20);
if (Lat = latMin) or (Lat = latMax) then
begin
canvas.Stroke.Color := TAlphaColors.Blueviolet;
end;
canvas.DrawLine(pointStart, pointStop, 100);
canvas.Stroke.Color := TAlphaColors.Blue;
end;
// find points to text position
GeographicToGauss(DegToRad(Lat), DegToRad(longMin), Nzone, _x, _y);
pointStart := TPointF.Create(Round((_y - Ymin)*paramGaussHoriz) + 40,
Round((vert - (_x - Xmin))*paramGaussVert) + 20);
GeographicToGauss(DegToRad(Lat), DegToRad(longMax), Nzone, _x, _y);
pointStop := TPointF.Create(Round((_y - Ymin)*paramGaussHoriz + 40),
Round((vert - (_x - Xmin))*paramGaussVert) + 20);
// Draw numeration of Latitudes ...
pointText := TPointF.Create(pointStart.X - 25, pointStart.Y -6);
rectText := TRectF.Create(pointText, 25, 12);
canvas.FillText(rectText, FloatToStrF(Abs(Lat), ffGeneral, 4,2), False, 100,
[TFillTextFlag.ftRightToLeft], TTextAlign.taCenter, TTextAlign.taCenter);
pointText := TPointF.Create(pointStop.X + 2, pointStop.Y - 6);
rectText := TRectF.Create(pointText, 25, 12);
canvas.FillText(rectText, FloatToStrF(Abs(Lat), ffGeneral, 4,2), False, 100,
[TFillTextFlag.ftRightToLeft], TTextAlign.taCenter, TTextAlign.taCenter);
end;
// Draw point that has input geographic coords
if Longitude >= 0 then
begin
pointStart := TPointF.Create(Round((Y - Ymin)*paramGaussHoriz) + 40,
Round((vert - (X - Xmin))*paramGaussVert) + 20);
rect := TRectF.Create(pointStart.X - 3, pointStart.Y - 3,
pointStart.X + 3, pointStart.Y + 3);
Canvas.Fill.Color := TAlphaColors.Red;
canvas.FillEllipse(rect, 100);
end
else
begin
pointStart := TPointF.Create(Round(((Y) - Ymin)*paramGaussHoriz) + 40,
Round((vert - (X - Xmin))*paramGaussVert) + 20);
rect := TRectF.Create(pointStart.X - 3, pointStart.Y - 3,
pointStart.X + 3, pointStart.Y + 3);
Canvas.Fill.Color := TAlphaColors.Red;
canvas.FillEllipse(rect, 100);
end;
Canvas.Fill.Color := TAlphaColors.Black;
canvas.EndScene();
// Find and show "Nomenclatura"
Nomenclatura := GetNomenclatura(GetScaleFactor(cbScale.Selected.Text), Nzone,
LitZone, Latitude, Longitude);
SetValue(Nomenclatura, edtNomenclatura);
end;
end.
|
unit System.uJson;
interface
{$IFDEF UNICODE}
{$DEFINE XE}
{$ENDIF}
uses System.Classes, System.Types, System.SysUtils, System.JSON, DateUtils,
RegularExpressions, {RTTI, TypInfo, DBXJson,} DBXJsonReflect;
type
TJsonType = (jtUnknown, jtObject, jtArray, jtString, jtTrue, jtFalse,
jtNumber, jtDate, jtDateTime, jtBytes);
TObjectHelper = class Helper for TObject
private
public
class function FromJson(AJson: String): System.TObject; static;
function Clone: System.TObject;
function AsJson: string;
end;
TJSONObjectHelper = class helper for TJSONObject
private
public
{$IFDEF VER270}
function ToJSON: string;
{$ENDIF}
class function GetTypeAsString(AType: TJsonType): string; static;
class function GetJsonType(AJsonValue: TJsonValue): TJsonType; static;
class function Stringify(so: TJSONObject): string;
class function Parse(const dados: string): TJSONObject;
function V(chave: String): variant;
function S(chave: string): string;
function I(chave: string): integer;
function O(chave: string): TJSONObject; overload;
function O(index: integer): TJSONObject; overload;
function F(chave: string): Extended;
function B(chave: string): boolean;
function A(chave: string): TJSONArray;
function AsArray: TJSONArray;
function Contains(chave: string): boolean;
function asObject: System.TObject;
class function FromObject<T>(AObject: T): TJSONObject; overload;
// class function FromObject(AObject: Pointer): TJSONObject;overload;
class function FromRecord<T>(rec: T): TJSONObject;
function addPair(chave: string; value: integer): TJSONObject; overload;
function addPair(chave: string; value: Double): TJSONObject; overload;
function addPair(chave: string; value: TDatetime): TJSONObject; overload;
end;
TJSONArrayHelper = class helper for TJSONArray
public
function Length: integer;
end;
TJSONValueHelper = class helper for TJsonValue
public
{$IFDEF VER270}
function ToJSON: string;
{$ENDIF}
function AsArray: TJSONArray;
function AsPair: TJsonPair;
function Datatype: TJsonType;
function asObject: TJSONObject;
end;
TJSONPairHelper = class helper for TJsonPair
public
function asObject: TJSONObject;
end;
IJson = TJSONObject;
IJSONArray = TJSONArray;
TJson = TJSONObject;
function ReadJsonString(const dados: string; chave: string): string;
function ReadJsonInteger(const dados: string; chave: string): integer;
function ReadJsonFloat(const dados: string; chave: string): Extended;
// function ReadJsonObject(const dados: string): IJson;
function JSONstringify(so: IJson): string;
function JSONParse(const dados: string): IJson;
function ISODateTimeToString(ADateTime: TDatetime): string;
function ISODateToString(ADate: TDatetime): string;
function ISOTimeToString(ATime: TTime): string;
function ISOStrToDateTime(DateTimeAsString: string): TDatetime;
function ISOStrToDate(DateAsString: string): TDate;
function ISOStrToTime(TimeAsString: string): TTime;
implementation
uses db, System.Rtti, System.TypInfo;
var
LJson: TJson;
class function TJSONObjectHelper.GetTypeAsString(AType: TJsonType): string;
begin
case AType of
jtUnknown:
result := 'Unknown';
jtString:
result := 'String';
jtTrue, jtFalse:
result := 'Boolean';
jtNumber:
result := 'Extended';
jtDate:
result := 'TDate';
jtDateTime:
result := 'TDateTime';
jtBytes:
result := 'Byte';
end;
end;
class function TJSONObjectHelper.GetJsonType(AJsonValue: TJsonValue): TJsonType;
var
LJsonString: TJSONString;
begin
if AJsonValue is TJSONObject then
result := jtObject
else if AJsonValue is TJSONArray then
result := jtArray
else if (AJsonValue is TJSONNumber) then
result := jtNumber
else if AJsonValue is TJSONTrue then
result := jtTrue
else if AJsonValue is TJSONFalse then
result := jtFalse
else if AJsonValue is TJSONString then
begin
LJsonString := (AJsonValue as TJSONString);
if TRegEx.IsMatch(LJsonString.value,
'^([0-9]{4})-?(1[0-2]|0[1-9])-?(3[01]|0[1-9]|[12][0-9])(T| )(2[0-3]|[01][0-9]):?([0-5][0-9]):?([0-5][0-9])$')
then
result := jtDateTime
else if TRegEx.IsMatch(LJsonString.value,
'^([0-9]{4})(-?)(1[0-2]|0[1-9])\2(3[01]|0[1-9]|[12][0-9])$') then
result := jtDate
else
result := jtString
end
else
result := jtUnknown;
end;
function JSONParse(const dados: string): IJson;
begin
result := TJSONObject.ParseJSONValue(dados) as IJson;
end;
function JSONstringify(so: IJson): string;
begin
result := so.ToJSON;
end;
function ReadJsonFloat(const dados: string; chave: string): Extended;
var
I: IJson;
begin
I := JSONParse(dados);
try
I.TryGetValue<Extended>(chave, result);
finally
I.Free;
end;
end;
function ReadJsonString(const dados: string; chave: string): string;
var
j: TJson;
I: IJson;
V: variant;
begin
j := JSONParse(dados);
// usar variavel local para não gerar conflito com Multi_threaded application
try
j.TryGetValue<variant>(chave, V);
result := V;
{ case VarTypeToDataType of
varString: Result := I.S[chave];
varInt64: Result := IntToStr(I.I[chave]);
varDouble,varCurrency: Result := FloatToStr(I.F[chave]);
varBoolean: Result := BoolToStr( I.B[chave] );
varDate: Result := DateToStr(I.D[chave]);
else
result := I.V[chave];
end; }
finally
j.Free;
end;
end;
(* function ReadJsonObject(const dados: string; chave: string): IJson;
var
j: TJson;
begin
result := JSONParse(dados);
{ // usar variavel local para não gerar conflito com Multi_threaded application
try
result := j.parse(dados);
finally
j.Free;
end;}
end;
*)
function ReadJsonInteger(const dados: string; chave: string): integer;
var
j: TJson;
I: IJson;
begin
j := JSONParse(dados);
// usar variavel local para não gerar conflito com Multi_threaded application
try
j.TryGetValue<integer>(chave, result);
finally
j.Free;
end;
end;
{$IFNDEF MULTI_THREADED}
function JSON: TJson;
begin
if not assigned(LJson) then
LJson := TJson.Create;
result := LJson;
end;
procedure JSONFree;
begin
if assigned(LJson) then
FreeAndNil(LJson);
end;
{$ENDIF}
{ TJSONObjectHelper }
function TJSONObjectHelper.A(chave: string): TJSONArray;
begin
TryGetValue<TJSONArray>(chave, result);
end;
function TJSONObjectHelper.addPair(chave: string; value: integer): TJSONObject;
begin
result := addPair(chave, TJSONNumber.Create(value));
end;
function TJSONObjectHelper.addPair(chave: string; value: Double): TJSONObject;
begin
result := addPair(chave, TJSONNumber.Create(value));
end;
function TJSONObjectHelper.addPair(chave: string; value: TDatetime)
: TJSONObject;
var
S: string;
begin
if trunc(value) <> value then
S := ISODateTimeToString(value)
else
S := ISODateToString(value);
result := addPair(chave, S);
end;
function TJSONObjectHelper.AsArray: TJSONArray;
begin
result := TJSONObject.ParseJSONValue(self.ToJSON) as TJSONArray;
end;
function TJSONObjectHelper.B(chave: string): boolean;
begin
TryGetValue<boolean>(chave, result);
end;
function TJSONObjectHelper.Contains(chave: string): boolean;
var
LJSONValue: TJsonValue;
begin
LJSONValue := FindValue(chave);
result := LJSONValue <> nil;
end;
function TJSONObjectHelper.F(chave: string): Extended;
begin
result := 0;
if FindValue(chave) <> nil then
TryGetValue<Extended>(chave, result);
end;
function TJSONObjectHelper.I(chave: string): integer;
begin
result := 0;
if FindValue(chave) <> nil then
TryGetValue<integer>(chave, result);
end;
function TJSONObjectHelper.O(index: integer): TJSONObject;
var
pair: TJsonPair;
begin
result := TJSONObject(get(index));
end;
function TJSONObjectHelper.O(chave: string): TJSONObject;
var
V: TJsonValue;
begin
V := GetValue(chave);
result := V as TJSONObject;
// TryGetValue<TJSONObject>(chave, result);
end;
class function TJSONObjectHelper.Parse(const dados: string): TJSONObject;
begin
result := TJSONObject.ParseJSONValue(dados) as TJSONObject;
end;
class function TJSONObjectHelper.FromRecord<T>(rec: T): TJSONObject;
var
m: TJSONMarshal;
js: TJsonValue;
begin
{ m := TJSONMarshal.Create;
try
js := m.Marshal(AObject);
result := js as TJSONObject;
finally
m.Free;
end;
}
result := TJSONObject.FromObject<T>(rec);
end;
class function TJSONObjectHelper.FromObject<T>(AObject: T): TJSONObject;
var
typ: TRttiType;
ctx: TRttiContext;
field: TRttiField;
tk: TTypeKind;
P: Pointer;
key: String;
FRecord: TRttiRecordType;
FMethod: TRttiMethod;
begin
result := TJSONObject.Create;
ctx := TRttiContext.Create;
typ := ctx.GetType(TypeInfo(T));
P := @AObject;
for field in typ.GetFields do
begin
key := field.Name.ToLower;
if not(field.Visibility in [mvPublic, mvPublished]) then
continue;
tk := field.FieldType.TypeKind;
case tk of
tkRecord:
begin
{ FRecord := ctx.GetType(field.GetValue(P).TypeInfo).AsRecord ;
FMethod := FRecord.GetMethod('asJson');
if assigned(FMethod) then
begin
result.AddPair(key,fMethod.asJson );
end; }
end;
tkInteger:
result.addPair(key, TJSONNumber.Create(field.GetValue(P).AsInteger));
tkFloat:
begin
if sametext(field.FieldType.Name, 'TDateTime') then
result.addPair(TJsonPair.Create(key,
ISODateTimeToString(field.GetValue(P).asExtended)))
else if sametext(field.FieldType.Name, 'TDate') then
result.addPair(TJsonPair.Create(key,
ISODateToString(field.GetValue(P).asExtended)))
else if sametext(field.FieldType.Name, 'TTime') then
result.addPair(TJsonPair.Create(key,
ISOTimeToString(field.GetValue(P).asExtended)))
else if sametext(field.FieldType.Name, 'TTimeStamp') then
result.addPair(TJsonPair.Create(key,
ISODateTimeToString(field.GetValue(P).asExtended)))
else
result.addPair(key, TJSONNumber.Create(field.GetValue(P)
.asExtended));
end
else
result.addPair(TJsonPair.Create(key, field.GetValue(P).ToString));
end;
end;
end;
function TJSONObjectHelper.S(chave: string): string;
begin
TryGetValue<string>(chave, result);
end;
class function TJSONObjectHelper.Stringify(so: TJSONObject): string;
begin
result := so.ToJSON;
end;
function TJSONObjectHelper.V(chave: String): variant;
var
V: string;
begin
TryGetValue<string>(chave, V);
result := V;
end;
function TJSONObjectHelper.asObject: System.TObject;
var
m: TJSONunMarshal;
begin
m := TJSONunMarshal.Create;
try
result := m.Unmarshal(self);
finally
m.Free;
end;
end;
{$IFDEF VER270}
function TJSONObjectHelper.ToJSON: string;
begin
result := ToString;
end;
{$ENDIF}
{ TJSONArrayHelper }
function TJSONArrayHelper.Length: integer;
begin
result := Count;
end;
{ TJSONValueHelper }
{$IFDEF VER270}
function TJSONValueHelper.ToJSON: string;
begin
result := ToString;
end;
{$ENDIF}
{ TJSONValueHelper }
function TJSONValueHelper.AsArray: TJSONArray;
begin
result := self as TJSONArray;
end;
function TJSONValueHelper.asObject: TJSONObject;
begin
result := self as TJSONObject;
end;
function TJSONValueHelper.AsPair: TJsonPair;
begin
result := TJsonPair(self);
end;
function TJSONValueHelper.Datatype: TJsonType;
begin
result := TJSONObject.GetJsonType(self);
end;
{ TJSONPairHelper }
function TJSONPairHelper.asObject: TJSONObject;
begin
result := (self.JsonValue) as TJSONObject;
end;
{ TObjectHelper }
function TObjectHelper.AsJson: string;
var
j: TJsonValue;
m: TJSONMarshal;
begin
m := TJSONMarshal.Create;
try
j := m.Marshal(self);
result := j.ToJSON;
finally
m.Free;
end;
end;
function TObjectHelper.Clone: System.TObject;
begin
result := TObject.FromJson(asJson);
end;
class function TObjectHelper.FromJson(AJson: String): System.TObject;
var
m: TJSONunMarshal;
V: TJSONObject;
begin
m := TJSONunMarshal.Create;
try
V := TJSONObject.Parse(AJson);
result := m.Unmarshal(V);
finally
m.Free;
end;
end;
function ISOTimeToString(ATime: TTime): string;
var
fs: TFormatSettings;
begin
fs.TimeSeparator := ':';
result := FormatDateTime('hh:nn:ss', ATime, fs);
end;
function ISODateToString(ADate: TDatetime): string;
begin
result := FormatDateTime('YYYY-MM-DD', ADate);
end;
function ISODateTimeToString(ADateTime: TDatetime): string;
begin
{ Result := FormatDateTime('yyyy-mm-dd', ADateTime) + 'T' +
FormatDateTime('hh:nn:ss.zzz', ADateTime)+'-0000';}
Result := DateToISO8601(ADateTime, False);
end;
function ISOStrToDateTime(DateTimeAsString: string): TDatetime;
begin
result := EncodeDateTime(StrToInt(Copy(DateTimeAsString, 1, 4)),
StrToInt(Copy(DateTimeAsString, 6, 2)),
StrToInt(Copy(DateTimeAsString, 9, 2)),
StrToInt(Copy(DateTimeAsString, 12, 2)),
StrToInt(Copy(DateTimeAsString, 15, 2)),
StrToInt(Copy(DateTimeAsString, 18, 2)), 0);
end;
function ISOStrToTime(TimeAsString: string): TTime;
begin
result := EncodeTime(StrToInt(Copy(TimeAsString, 1, 2)),
StrToInt(Copy(TimeAsString, 4, 2)), StrToInt(Copy(TimeAsString, 7, 2)), 0);
end;
function ISOStrToDate(DateAsString: string): TDate;
begin
result := EncodeDate(StrToInt(Copy(DateAsString, 1, 4)),
StrToInt(Copy(DateAsString, 6, 2)), StrToInt(Copy(DateAsString, 9, 2)));
// , StrToInt
// (Copy(DateAsString, 12, 2)), StrToInt(Copy(DateAsString, 15, 2)),
// StrToInt(Copy(DateAsString, 18, 2)), 0);
end;
// function ISODateToStr(const ADate: TDate): String;
// begin
// Result := FormatDateTime('YYYY-MM-DD', ADate);
// end;
//
// function ISOTimeToStr(const ATime: TTime): String;
// begin
// Result := FormatDateTime('HH:nn:ss', ATime);
// end;
initialization
finalization
{$IFNDEF MULTI_THREADED}
JSONFree;
{$ENDIF}
end.
|
Program carree_magiqueFF.pas;
uses crt;
const
MAX = 5 ;
type
Tab2d=array [1..MAX,1..MAX] of integer;
PROCEDURE affichage(tab4:Tab2d ) ;
var
i,j:INTEGER ;
begin
for j := 1 to MAX do
begin
for i := 1 to MAX do
begin
if (tab4[i,j]<=9) then
write (' ',tab4[i,j])
else
write (' ',tab4[i,j])
end;
writeln;
end;
end;
PROCEDURE TestBordureD (var x1 : INTEGER ; var y1 : INTEGER);
begin
if (x1 > MAX) then
begin
x1 := 1 ;
end;
if (y1<1) then
begin
y1 := MAX ;
end;
end ;
PROCEDURE TestBordureG (var x3:INTEGER ;var y3:INTEGER);
BEGIN
IF (x3-1<1) THEN
BEGIN
x3:=MAX;
END
ELSE
BEGIN
x3:=(x3-1);
END;
IF (y3-1<1) THEN
BEGIN
y3:=MAX;
END
ELSE
y3:=y3-1
END;
FUNCTION Test(tab2:Tab2d ;x2:INTEGER ; y2:INTEGER): BOOLEAN;
BEGIN
IF tab2[x2,y2]=0 THEN
Test:=TRUE
ELSE
Test:=FALSE
END;
PROCEDURE Initialisation(var Matrice0:T2dim; var abs:INTEGER; var ord:INTEGER);
VAR
i,j:INTEGER;
BEGIN
FOR j:=1 TO MAX DO
BEGIN
FOR i:=1 TO MAX DO
BEGIN
Matrice0[i,j]:=0;
END;
writeln;
END;
Matrice0[(MAX DIV 2)+1,(MAX DIV 2)]:=1;
abs:=((MAX DIV 2)+1);
ord:=(MAX DIV 2);
END;
PROCEDURE Remplissage( var tab:Tab2d ; var x:INTEGER ; var y:INTEGER);
VAR
i,j:INTEGER;
BEGIN
FOR i:=2 TO (MAX*MAX) DO
BEGIN
x:=x+1;
y:=y-1;
TestBordureDroite(x,y);
IF (Test(tab,x,y)=FALSE) THEN
BEGIN
REPEAT
TestBordureGauche(x,y)
UNTIL (Test(tab,x,y)=TRUE);
END;
tab[x,y]:=i;
Affichage(tab);
readln;
END;
END;
VAR
Matrice:Tab2d;
abscisse,ordonnee:INTEGER;
BEGIN
clrscr;
Initialisation(Matrice,abscisse,ordonnee);
Remplissage(Matrice,abscisse,ordonnee);
readln;
END.
|
{
Copyright (C) Alexey Torgashin, uvviewsoft.com
License: MPL 2.0 or LGPL
}
unit ATSynEdit_Cmp_HTML;
{$mode objfpc}{$H+}
{$ModeSwitch advancedrecords}
interface
uses
Classes,
ATStrings,
ATStringProc_Separator,
ATSynEdit,
ATSynEdit_Cmp_HTML_Provider;
procedure DoEditorCompletionHtml(Ed: TATSynEdit);
type
{ TATCompletionOptionsHtml }
TATCompletionOptionsHtml = record
private
ListOfTags: TStringList;
public
Provider: TATHtmlProvider;
FilenameHtmlList: string; //from CudaText: data/autocompletespec/html_list.ini
FilenameHtmlGlobals: string; //from CudaText: data/autocompletespec/html_globals.ini
FilenameHtmlEntities: string; //from CudaText: data/autocompletespec/html_entities.ini
FilenameHtmlMediaTypes: string; //from CudaText: data/autocompletespec/html_mediatypes.ini
FileMaskHREF: string;
FileMaskLinkHREF: string;
FileMaskPictures: string;
FileMaskScript: string;
FileMaskFrame: string;
FileMaskAudio: string;
FileMaskVideo: string;
FileMaskSomeSrc: string;
PrefixTag: string;
PrefixAttrib: string;
PrefixValue: string;
PrefixDir: string;
PrefixFile: string;
PrefixEntity: string;
MaxLinesPerTag: integer;
NonWordChars: UnicodeString;
procedure InitProvider;
function IsValidTag(const S: string; PartialAllowed: boolean): boolean;
function IsBooleanAttrib(const S: string): boolean;
end;
var
CompletionOpsHtml: TATCompletionOptionsHtml;
function IsTagNeedsClosingTag(const S: string): boolean;
implementation
uses
SysUtils, Graphics, StrUtils,
ATStringProc,
ATSynEdit_Carets,
ATSynEdit_RegExpr,
ATSynEdit_Cmp_Form,
ATSynEdit_Cmp_CSS,
ATSynEdit_Cmp_Filenames,
Dialogs,
Math;
type
TCompletionHtmlContext = (
ctxNone,
ctxTags,
ctxAttrs,
ctxValues,
ctxValuesQuoted,
ctxCssStyle,
ctxEntity,
ctxValueHref,
ctxValueLinkHref,
ctxValueFrameSrc,
ctxValueScriptSrc,
ctxValueImageSrc,
ctxValueAudioSrc,
ctxValueVideoSrc,
ctxValueSourceSrc
);
function IsQuote(ch: WideChar): boolean; inline;
begin
case ch of
'"', '''':
Result:= true;
else
Result:= false;
end;
end;
function IsQuoteOrSlash(ch: WideChar): boolean; inline;
begin
case ch of
'"', '''', '/', '\':
Result:= true;
else
Result:= false;
end;
end;
procedure EditorGetDistanceToQuotes(Ed: TATSynEdit; out ALeft, ARight: integer; out AAddSlash: boolean);
var
Caret: TATCaretItem;
S: UnicodeString;
Len, X, i: integer;
begin
ALeft:= 0;
ARight:= 0;
AAddSlash:= true;
if Ed.Carets.Count=0 then exit;
Caret:= Ed.Carets[0];
if not Ed.Strings.IsIndexValid(Caret.PosY) then exit;
S:= Ed.Strings.Lines[Caret.PosY];
Len:= Length(S);
X:= Caret.PosX+1;
i:= X;
while (i<=Len) and not IsQuote(S[i]) do Inc(i);
ARight:= i-X;
i:= X;
while (i>1) and (i<=Len) and not IsQuoteOrSlash(S[i-1]) do Dec(i);
ALeft:= Max(0, X-i);
end;
function IsTagNeedsClosingTag(const S: string): boolean;
begin
case S of
'area',
'base',
'br',
'col',
'command', //obsolete
'embed',
'frame', //not in html5
'hr',
'img',
'input',
'keygen', //obsolete
'link',
'menuitem', //obsolete
'meta',
'param',
'source',
'track',
'wbr':
Result:= false;
else
Result:= true;
end;
end;
type
TAcpIntegerArray = array of integer;
type
{ TAcp }
TAcp = class
private
ListResult: TStringList;
NeedBracketX: TAcpIntegerArray;
procedure DoOnGetCompleteProp(Sender: TObject;
AContent: TStringList;
out ACharsLeft, ACharsRight: integer);
procedure ApplyNeedBracketX;
procedure InitMainLists;
public
Ed: TATSynEdit;
ListEntities: TStringList;
LastContext: TCompletionHtmlContext;
LastChoices: array[TCompletionHtmlContext] of TStringList;
procedure DoOnChoose(Sender: TObject; const ASnippetId: string; ASnippetIndex: integer);
constructor Create; virtual;
destructor Destroy; override;
end;
var
Acp: TAcp = nil;
function CompareHtmlItems(List: TStringList; Index1, Index2: Integer): Integer;
//
function GetStr(const SFrom: string): string;
var
Sep: TATStringSeparator;
begin
Sep.Init(SFrom, CompletionOps.ColumnsSep);
//get 2nd column
Sep.GetItemStr(Result);
Sep.GetItemStr(Result);
//delete from #1
SDeleteFrom(Result, CompletionOps.SuffixSep);
end;
//
var
LastChoices: TStringList;
S1, S2: string;
N1, N2: integer;
begin
S1:= GetStr(List[Index1]);
S2:= GetStr(List[Index2]);
LastChoices:= Acp.LastChoices[Acp.LastContext];
N1:= LastChoices.IndexOf(S1);
N2:= LastChoices.IndexOf(S2);
if (N1>=0) and (N2>=0) then
exit(N1-N2);
if (N1>=0) then
exit(-1);
if (N2>=0) then
exit(1);
Result:= strcomp(PChar(S1), PChar(S2));
end;
function SFindRegex(const AText, ARegex: UnicodeString; AGroup: integer): string;
var
R: TRegExpr;
begin
Result:= '';
R:= TRegExpr.Create;
try
R.ModifierS:= false;
R.ModifierM:= true;
R.ModifierI:= true;
R.Expression:= ARegex;
R.InputString:= AText;
if R.ExecPos(1) then
Result:= Copy(AText, R.MatchPos[AGroup], R.MatchLen[AGroup]);
finally
R.Free;
end;
end;
procedure SFindRegexPos(const AText, ARegex: UnicodeString; AGroup: integer; AFromPos: integer; out APos, ALen: integer);
var
R: TRegExpr;
begin
APos:= -1;
ALen:= 0;
R:= TRegExpr.Create;
try
R.ModifierS:= false;
R.ModifierM:= true;
R.ModifierI:= true;
R.Expression:= ARegex;
R.InputString:= AText;
if R.ExecPos(AFromPos) then
begin
APos:= R.MatchPos[AGroup];
ALen:= R.MatchLen[AGroup];
end;
finally
R.Free;
end;
end;
function _StringEndsWithUnclosedQuote(const S: string; out AValueStr: string): boolean;
var
i: integer;
begin
Result:= false;
AValueStr:= '';
for i:= Length(S) downto 1 do
case S[i] of
'=':
exit;
'"', '''':
begin
AValueStr:= Copy(S, i+1, MaxInt);
exit(true);
end;
end;
end;
function EditorGetHtmlContext(Ed: TATSynedit;
APosX, APosY: integer;
out ATagName, AAttrName, AValueStr: string;
out ATagClosing: boolean;
out ACharAfter: char): TCompletionHtmlContext;
const
//regex to catch tag name at line start
cRegexTagPart = '^\w+\b';
cGroupTagPart = 0;
cRegexTagOnly = '^\w*$';
cGroupTagOnly = 0;
cRegexTagClose = '^/(\w*)$';
cGroupTagClose = 1;
//character class for all chars inside quotes
cRegexChars = '[\s\w,\.:;\-\+\*\?=\(\)\[\]\{\}/\\\|~`\^\$&%\#@!\n]';
//regex to catch attrib name, followed by "=" and not-closed quote, only at line end
//this regex has $ at end so it's found just before the caret
cRegexAttr = '\b([\w\-]+)\s*\=\s*([''"]' + cRegexChars + '*)?$';
cGroupAttr = 1;
//regex to catch CSS after 'style='
cRegexStyles: array[0..1] of UnicodeString = (
'\bstyle\s*=\s*"([^"]*)"',
'\bstyle\s*=\s*''([^'']*)'''
);
cGroupStyle = 1;
var
St: TATStrings;
S: UnicodeString;
NPrev, N, NPos, NLen, i: integer;
bTagValid: boolean;
ch: WideChar;
begin
ATagName:= '';
AAttrName:= '';
AValueStr:= '';
ATagClosing:= false;
ACharAfter:= ' ';
Result:= ctxNone;
bTagValid:= false;
St:= Ed.Strings;
if not St.IsIndexValid(APosY) then exit;
if APosX>St.LinesLen[APosY] then exit;
//detect caret inside style="..." or style='...'
S:= St.Lines[APosY];
if Trim(S)='' then exit;
for i:= Low(cRegexStyles) to High(cRegexStyles) do
begin
N:= 1;
repeat
SFindRegexPos(S, cRegexStyles[i], cGroupStyle, N, NPos, NLen);
if NPos<0 then Break;
if (NPos<=APosX+1) and (APosX+1<=NPos+NLen) then
exit(ctxCssStyle);
N:= NPos+NLen;
until false;
end;
//get str before caret
S:= St.LineSub(APosY, 1, APosX);
if Trim(S)='' then exit;
if S[APosX]='<' then
exit(ctxTags);
if (APosX-1>0) and (S[APosX-1]='<') and (S[APosX]='/') then
exit(ctxTags);
//detect HTML entity like &name;
if (APosX>0) and (APosX<=St.LinesLen[APosY]) then
begin
N:= Length(S);
while (N>0) and IsCharWordInIdentifier(S[N]) do
Dec(N);
if (N>0) and (S[N]='&') then
exit(ctxEntity);
end;
//detect char after caret and next wordchars
N:= APosX;
repeat
ch:= St.LineCharAt(APosY, N);
if not IsCharWordA(ch) then
begin
ACharAfter:= ch;
Break;
end;
Inc(N);
until false;
//add few previous lines to support multiline tags
if APosY>0 then
begin
NPrev:= Max(0, APosY-CompletionOpsHtml.MaxLinesPerTag);
for N:= APosY-1 downto NPrev do
S:= St.Lines[N]+' '+S;
end;
//cut string before last "<" or ">" char
N:= Length(S);
while (N>0) and (S[N]<>'<') and (S[N]<>'>') do Dec(N);
if N=0 then Exit;
Delete(S, 1, N);
ATagName:= LowerCase(SFindRegex(S, cRegexTagClose, cGroupTagClose));
bTagValid:= CompletionOpsHtml.IsValidTag(ATagName, true);
if bTagValid then
begin
ATagClosing:= true;
exit(ctxTags);
end;
ATagName:= LowerCase(SFindRegex(S, cRegexTagOnly, cGroupTagOnly));
bTagValid:= CompletionOpsHtml.IsValidTag(ATagName, true);
if bTagValid then
exit(ctxTags);
ATagName:= LowerCase(SFindRegex(S, cRegexTagPart, cGroupTagPart));
bTagValid:= CompletionOpsHtml.IsValidTag(ATagName, true);
if bTagValid then
begin
AAttrName:= LowerCase(SFindRegex(S, cRegexAttr, cGroupAttr));
if AAttrName<>'' then
begin
if _StringEndsWithUnclosedQuote(S, AValueStr) then
begin
Result:= ctxValuesQuoted;
if (ATagName='a') and (AAttrName='href') then
Result:= ctxValueHref
else
if ((ATagName='frame') or (ATagName='iframe')) and (AAttrName='src') then
Result:= ctxValueFrameSrc
else
if (ATagName='link') and (AAttrName='href') then
Result:= ctxValueLinkHref
else
if (ATagName='script') and (AAttrName='src') then
Result:= ctxValueScriptSrc
else
if ((ATagName='img') or (ATagName='input')) and (AAttrName='src') then
Result:= ctxValueImageSrc
else
if (ATagName='audio') and (AAttrName='src') then
Result:= ctxValueAudioSrc
else
if (ATagName='video') and (AAttrName='src') then
Result:= ctxValueVideoSrc
else
if (ATagName='source') and (AAttrName='src') then
Result:= ctxValueSourceSrc
else
if (ATagName='source') and (AAttrName='srcset') then
Result:= ctxValueImageSrc;
end
else
Result:= ctxValues;
end
else
Result:= ctxAttrs;
end;
end;
{ TATCompletionOptionsHtml }
procedure TATCompletionOptionsHtml.InitProvider;
begin
if Provider=nil then
Provider:= TATHtmlBasicProvider.Create(
FilenameHtmlList,
FilenameHtmlGlobals,
FilenameHtmlMediaTypes
);
end;
function TATCompletionOptionsHtml.IsValidTag(const S: string; PartialAllowed: boolean): boolean;
var
i: integer;
begin
Result:= false;
if S='' then exit;
if Provider=nil then
begin
InitProvider;
if Provider=nil then
raise Exception.Create('HTML tags provider not inited');
end;
if ListOfTags=nil then
begin
ListOfTags:= TStringList.Create;
ListOfTags.Sorted:= true;
ListOfTags.CaseSensitive:= false;
Provider.GetTags(ListOfTags);
end;
if ListOfTags.Find(S, i) then
exit(true);
if PartialAllowed then
for i:= 0 to ListOfTags.Count-1 do
if strlicomp(PChar(S), PChar(ListOfTags[i]), Length(S))=0 then
exit(true);
end;
function TATCompletionOptionsHtml.IsBooleanAttrib(const S: string): boolean;
begin
case S of
'allowfullscreen',
'allowpaymentrequest',
'async',
'autofocus',
'autoplay',
'checked',
'controls',
'default',
'defer',
'disabled',
'formnovalidate',
'hidden',
'ismap',
'itemscope',
'loop',
'multiple',
'muted',
'nomodule',
'novalidate',
'open',
'playsinline',
'readonly',
'required',
'reversed',
'selected',
'truespeed':
Result:= true;
else
Result:= false;
end;
end;
{ TAcp }
procedure TAcp.DoOnGetCompleteProp(Sender: TObject;
AContent: TStringList; out ACharsLeft, ACharsRight: integer);
//
procedure GetFileNames(AResult: TStringList; const AText, AFileMask: string);
var
bAddSlash: boolean;
begin
EditorGetDistanceToQuotes(Ed, ACharsLeft, ACharsRight, bAddSlash);
CalculateCompletionFilenames(AResult,
ExtractFileDir(Ed.FileName),
AText,
AFileMask,
CompletionOpsHtml.PrefixDir,
CompletionOpsHtml.PrefixFile,
bAddSlash,
true //URL encode
);
end;
//
var
St: TATStrings;
Caret: TATCaretItem;
Context: TCompletionHtmlContext;
EdLine: UnicodeString;
s_word: atString;
s_tag, s_attr, s_item, s_value,
s_tag_bracket, s_tag_close: string;
s_quote, s_space, s_equalchar, s_equalfinal: string;
ok, bTagClosing: boolean;
NextChar: char;
L: TStringList;
i: integer;
begin
InitMainLists;
AContent.Clear;
ACharsLeft:= 0;
ACharsRight:= 0;
ListResult.Clear;
St:= Ed.Strings;
if Ed.Carets.Count=0 then exit;
Caret:= Ed.Carets[0];
if not St.IsIndexValid(Caret.PosY) then exit;
if Caret.PosX>St.LinesLen[Caret.PosY] then exit;
Context:= EditorGetHtmlContext(Ed,
Caret.PosX,
Caret.PosY,
s_tag,
s_attr,
s_value,
bTagClosing,
NextChar);
EditorGetCurrentWord(Ed,
Caret.PosX,
Caret.PosY,
CompletionOpsHtml.NonWordChars+'/', // '/' is word-char, so add it specially
s_word,
ACharsLeft,
ACharsRight);
case Context of
ctxTags:
begin
L:= TStringList.Create;
try
CompletionOpsHtml.Provider.GetTags(L);
for i:= 0 to L.Count-1 do
begin
s_item:= L[i];
//special handle of some tags: a, img, link...
if (s_item='a') and not bTagClosing then
s_item:= 'a'#1' href="'#1'"></a>'
else
if (s_item='img') and not bTagClosing then
s_item:= 'img'#1' src="'#1'">'
else
if (s_item='link') and not bTagClosing then
s_item:= 'link'#1' rel="stylesheet" type="text/css" href="'#1'">'
else
begin
//usual handle of all tags
s_tag_bracket:= '';
s_tag_close:= '';
if NextChar<>'>' then
begin
s_tag_bracket:= '>';
if not bTagClosing and IsTagNeedsClosingTag(s_item) then
s_tag_close:= #1'</'+s_item+'>';
end;
s_item:= s_item+#1+s_tag_bracket+s_tag_close;
end;
//filter items
if s_word<>'' then
begin
ok:= StartsText(s_word, s_item);
if not ok then Continue;
end;
ListResult.Add(CompletionOpsHtml.PrefixTag+'|'+s_item);
end;
finally
FreeAndNil(L);
end;
end;
ctxAttrs:
begin
if NextChar='=' then
s_equalchar:= ''
else
s_equalchar:= '=""';
L:= TStringList.Create;
try
CompletionOpsHtml.Provider.GetTagProps(s_tag, L);
//keep only items which begin with s_word
for s_item in L do
begin
s_equalfinal:= s_equalchar;
// https://meiert.com/en/blog/boolean-attributes-of-html/
if CompletionOpsHtml.IsBooleanAttrib(s_item) then
s_equalfinal:= '';
if s_word<>'' then
begin
ok:= StartsText(s_word, s_item);
if not ok then Continue;
end;
ListResult.Add(s_tag+' '+CompletionOpsHtml.PrefixAttrib+'|'+s_item+#1+s_equalfinal);
end;
finally
FreeAndNil(L);
end;
end;
ctxValues,
ctxValuesQuoted:
begin
if Context=ctxValuesQuoted then
begin
s_quote:= '';
s_space:= '';
end
else
begin
s_quote:= '"';
s_space:= ' ';
end;
L:= TStringList.Create;
try
CompletionOpsHtml.Provider.GetTagPropValues(s_tag, s_attr, L);
for s_value in L do
begin
if s_word<>'' then
begin
ok:= StartsText(s_word, s_value);
if not ok then Continue;
end;
ListResult.Add(s_attr+' '+CompletionOpsHtml.PrefixValue+'|'+s_quote+s_value+s_quote+#1+s_space);
end;
finally
FreeAndNil(L);
end;
end;
ctxEntity:
begin
EdLine:= St.Lines[Caret.PosY];
i:= Caret.PosX+ACharsRight+1;
if i<=Length(EdLine) then
begin
NextChar:= EdLine[i];
if NextChar=';' then
Inc(ACharsRight); //to replace old entity with ';'
end;
if not Assigned(ListEntities) then
begin
ListEntities:= TStringList.Create;
if FileExists(CompletionOpsHtml.FilenameHtmlEntities) then
ListEntities.LoadFromFile(CompletionOpsHtml.FilenameHtmlEntities);
end;
for s_value in ListEntities do
if StartsText(s_word, s_value) then //case insensitive
ListResult.Add(CompletionOpsHtml.PrefixEntity+'|'+s_value+';');
end;
ctxValueHref:
begin
GetFileNames(ListResult, s_value, CompletionOpsHtml.FileMaskHREF);
end;
ctxValueLinkHref:
begin
GetFileNames(ListResult, s_value, CompletionOpsHtml.FileMaskLinkHREF);
end;
ctxValueScriptSrc:
begin
GetFileNames(ListResult, s_value, CompletionOpsHtml.FileMaskScript);
end;
ctxValueFrameSrc:
begin
GetFileNames(ListResult, s_value, CompletionOpsHtml.FileMaskFrame);
end;
ctxValueImageSrc:
begin
GetFileNames(ListResult, s_value, CompletionOpsHtml.FileMaskPictures);
end;
ctxValueAudioSrc:
begin
GetFileNames(ListResult, s_value, CompletionOpsHtml.FileMaskAudio);
end;
ctxValueVideoSrc:
begin
GetFileNames(ListResult, s_value, CompletionOpsHtml.FileMaskVideo);
end;
ctxValueSourceSrc:
begin
GetFileNames(ListResult, s_value, CompletionOpsHtml.FileMaskSomeSrc);
end;
end;
ListResult.CustomSort(@CompareHtmlItems);
AContent.Assign(ListResult);
end;
constructor TAcp.Create;
begin
inherited;
end;
procedure TAcp.InitMainLists;
var
ctx: TCompletionHtmlContext;
begin
if ListResult=nil then
begin
ListResult:= TStringList.Create;
ListResult.TextLineBreakStyle:= tlbsLF;
for ctx:= Low(ctx) to High(ctx) do
LastChoices[ctx]:= TStringList.Create;
end;
end;
destructor TAcp.Destroy;
var
ctx: TCompletionHtmlContext;
begin
for ctx:= Low(ctx) to High(ctx) do
FreeAndNil(LastChoices[ctx]);
FreeAndNil(ListResult);
FreeAndNil(ListEntities);
inherited;
end;
procedure TAcp.DoOnChoose(Sender: TObject; const ASnippetId: string;
ASnippetIndex: integer);
var
Sep: TATStringSeparator;
Str: string;
L: TStringList;
N: integer;
begin
InitMainLists;
Sep.Init(ASnippetId, CompletionOps.SuffixSep);
Sep.GetItemStr(Str);
L:= LastChoices[LastContext];
N:= L.IndexOf(Str);
if N>=0 then
L.Delete(N);
L.Insert(0, Str);
Acp.ApplyNeedBracketX;
end;
procedure TAcp.ApplyNeedBracketX;
var
St: TATStrings;
Caret: TATCaretItem;
SLine: UnicodeString;
iCaret: integer;
begin
if Length(NeedBracketX)<Ed.Carets.Count then exit;
St:= Ed.Strings;
for iCaret:= Ed.Carets.Count-1 downto 0 do
begin
Caret:= Ed.Carets[iCaret];
if NeedBracketX[iCaret]<0 then Continue;
if St.IsIndexValid(Caret.PosY) then
begin
SLine:= St.Lines[Caret.PosY];
Insert('<', SLine, NeedBracketX[iCaret]+1);
St.Lines[Caret.PosY]:= SLine;
Caret.PosX:= Caret.PosX+1;
Ed.UpdateCaretsAndMarkersOnEditing(iCaret+1,
Point(Caret.PosX, Caret.PosY),
Point(Caret.PosX, Caret.PosY),
Point(1, 0),
Point(0, 0));
end;
end;
if Ed.Carets.Count>0 then
Ed.DoEventChange(Ed.Carets[0].PosY);
Ed.Update(true);
NeedBracketX:= nil;
end;
procedure EditorCompletionNeedsLeadBracket(Ed: TATSynEdit; var Res: TAcpIntegerArray);
var
Caret: TATCaretItem;
iCaret: integer;
S: UnicodeString;
X: integer;
begin
SetLength(Res, Ed.Carets.Count);
for iCaret:= 0 to Ed.Carets.Count-1 do
begin
Res[iCaret]:= -1;
Caret:= Ed.Carets[iCaret];
if not Ed.Strings.IsIndexValid(Caret.PosY) then Continue;
S:= Ed.Strings.Lines[Caret.PosY];
if Length(S)=0 then Continue;
X:= Caret.PosX;
if X<=0 then Continue;
if X>Length(S) then Continue;
if not IsCharWordA(S[X]) then Continue;
while (X>0) and IsCharWordA(S[X]) do Dec(X);
if X=0 then
Res[iCaret]:= 0
else
if IsCharSpace(S[X]) or (S[X]='>') then
Res[iCaret]:= X;
end;
end;
//TODO: delete this func
(*
function EditorCompletionNeedsLeadingAngleBracket(Ed: TATSynEdit;
const S: UnicodeString;
const AX, AY: integer): boolean;
var
ch: WideChar;
i: integer;
begin
Result:= false;
if AX>Length(S) then exit;
if AX=0 then
Result:= true
else
if Acp.LastContext<>ctxEntity then
begin
//check that before caret it's not bad position:
//- someword after line start
//- someword after ">"
i:= AX;
if (i>0) and (i<=Length(S)) and IsCharWordA(S[i]) then
begin
while (i>0) and IsCharWordA(S[i]) do Dec(i);
if i=0 then exit;
if S[i]='>' then exit;
end;
//check nearest non-space char lefter than caret
i:= AX;
while (i>0) and (S[i]=' ') do Dec(i);
if i>0 then
begin
ch:= S[i];
if (Pos(ch, '<="''/:.-,')=0) and not IsCharWord(ch, cDefaultNonWordChars) then
Result:= true;
end
else
Result:= true;
end;
end;
*)
procedure DoEditorCompletionHtml(Ed: TATSynEdit);
var
Caret: TATCaretItem;
S_Tag, S_Attr, S_Value: string;
bClosing: boolean;
NextChar: char;
begin
Acp.Ed:= Ed;
CompletionOpsHtml.InitProvider;
if Ed.Carets.Count=0 then exit;
Caret:= Ed.Carets[0];
if not Ed.Strings.IsIndexValid(Caret.PosY) then exit;
Acp.LastContext:= EditorGetHtmlContext(Ed,
Caret.PosX,
Caret.PosY,
S_Tag,
S_Attr,
S_Value,
bClosing,
NextChar);
//we are inside style="..." ? call CSS completions.
if Acp.LastContext=ctxCssStyle then
begin
DoEditorCompletionCss(Ed);
exit;
end;
SetLength(Acp.NeedBracketX, 0);
if Acp.LastContext=ctxTags then
EditorCompletionNeedsLeadBracket(Ed, Acp.NeedBracketX);
{ //TODO: delete this
else
//insert missing '<' if completion was called without it?
if EditorCompletionNeedsLeadingAngleBracket(Ed, S, Caret.PosX, Caret.PosY) then
begin
Insert('<', S, Caret.PosX+1);
Ed.Strings.Lines[Caret.PosY]:= S;
Caret.PosX:= Caret.PosX+1;
Ed.Update(true);
Ed.DoEventChange;
end;
}
EditorShowCompletionListbox(Ed, @Acp.DoOnGetCompleteProp,
nil,
@Acp.DoOnChoose,
'',
0,
true //allow multi-carets in HTML like Sublime does
);
end;
initialization
Acp:= TAcp.Create;
with CompletionOpsHtml do
begin
Provider:= nil;
ListOfTags:= nil;
FilenameHtmlList:= '';
FilenameHtmlGlobals:= '';
FilenameHtmlEntities:= '';
FileMaskHREF:= AllFilesMask;
FileMaskLinkHREF:= '*.css';
FileMaskPictures:= '*.png;*.gif;*.jpg;*.jpeg;*.ico;*.webp;*.avif';
FileMaskScript:= '*.js';
FileMaskFrame:= '*.htm;*.html;*.php*;*.asp;*.aspx';
FileMaskAudio:= '*.mp3;*.ogg;*.wav';
FileMaskVideo:= '*.mp4;*.ogg;*.webm';
FileMaskSomeSrc:= FileMaskAudio+';'+FileMaskVideo;
PrefixTag:= 'tag';
PrefixAttrib:= 'attrib';
PrefixValue:= 'value';
PrefixDir:= 'folder';
PrefixFile:= 'file';
PrefixEntity:= 'entity';
MaxLinesPerTag:= 40;
NonWordChars:= '*=\()[]{}<>"'',:;~?!@#$%^&|`…';
// '-' is word char
// '/' and '+' and '.' -- word char for type='application/exe+name.some'
end;
finalization
with CompletionOpsHtml do
begin
if Assigned(ListOfTags) then
FreeAndNil(ListOfTags);
if Assigned(Provider) then
FreeAndNil(Provider);
end;
FreeAndNil(Acp);
end.
|
unit View.Page.Main.Cadastro;
interface
uses
Winapi.Windows,
Winapi.Messages,
System.SysUtils,
System.Variants,
System.Classes,
Vcl.Graphics,
Vcl.Controls,
Vcl.Forms,
Vcl.Dialogs,
Vcl.ExtCtrls,
Router4D.Interfaces,
Vcl.StdCtrls, Router4D, Router4D.Props;
type
TfViewPageMainCadastro = class(TForm, iRouter4DComponent)
pnlAll: TPanel;
btnProduct: TButton;
btnProductProp: TButton;
btnCustomer: TButton;
btnCustomerWithProps: TButton;
procedure btnProductClick(Sender: TObject);
procedure btnProductPropClick(Sender: TObject);
procedure btnCustomerClick(Sender: TObject);
procedure btnCustomerWithPropsClick(Sender: TObject);
private
function Render: TForm;
procedure UnRender;
public
{ Public declarations }
end;
var
fViewPageMainCadastro: TfViewPageMainCadastro;
implementation
{$R *.dfm}
procedure TfViewPageMainCadastro.btnCustomerClick(Sender: TObject);
begin
TRouter4D.Link.&To('Customer');
end;
procedure TfViewPageMainCadastro.btnCustomerWithPropsClick(Sender: TObject);
begin
TRouter4D.Link
.&To(
'Customer',
TProps
.Create
.PropString(
'Olá Customer, Seu Cadastro Recebeu as Props'
)
.Key('TelaCadastro')
);
end;
procedure TfViewPageMainCadastro.btnProductClick(Sender: TObject);
begin
TRouter4D.Link.&To('Product');
end;
procedure TfViewPageMainCadastro.btnProductPropClick(Sender: TObject);
begin
TRouter4D.Link
.&To(
'Product',
TProps
.Create
.PropString(
'Olá Product, Seu Cadastro Recebeu as Props'
)
.Key('TelaCadastro')
);
end;
function TfViewPageMainCadastro.Render: TForm;
begin
Result := Self;
end;
procedure TfViewPageMainCadastro.UnRender;
begin
end;
end.
|
unit webscktmr_main;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils, Forms, Controls, Graphics, Dialogs, StdCtrls, ExtCtrls,
EditBtn, MaskEdit, Spin, UniqueInstance;
type
{ TFormWebSocketTmr }
TFormWebSocketTmr = class(TForm)
ButtonTXT: TButton;
ButtonFnt: TButton;
ButtonS: TButton;
ButtonR: TButton;
CheckBoxMilli: TCheckBox;
ColorButtonB: TColorButton;
EditTXT: TEdit;
FontDialog1: TFontDialog;
GroupBox1: TGroupBox;
GroupBox2: TGroupBox;
Panel1: TPanel;
StaticTextTmr: TStaticText;
Timer1: TTimer;
UniqueInstance1: TUniqueInstance;
procedure ButtonFntClick(Sender: TObject);
procedure ButtonSClick(Sender: TObject);
procedure ButtonRClick(Sender: TObject);
procedure ButtonTXTClick(Sender: TObject);
procedure ColorButtonBColorChanged(Sender: TObject);
procedure EditTXTKeyPress(Sender: TObject; var Key: char);
procedure FormCloseQuery(Sender: TObject; var CanClose: Boolean);
procedure FormDestroy(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure Timer1Timer(Sender: TObject);
procedure WebSckResIncoming(const msg:RawByteString);
procedure WebSckTXTIncoming(const msg:RawByteString);
private
public
procedure LoadAppConfig;
procedure SaveAppConfig;
end;
var
FormWebSocketTmr: TFormWebSocketTmr;
StartTime: single;
implementation
uses
DefaultTranslator, DateUtils, uwebsockClock, IniFiles;
resourcestring
rsStop = 'Stop';
rsStart = 'Start';
rsResetTimer = 'Reset Timer?';
rsCloseTimer = 'Close Timer?';
rsYes = 'Yes';
rsNo = 'No';
var
stime: TDateTime;
DoReset: Boolean = False;
lastTick, curtick: Int64;
ye, mo, dd, hh, mm, ss, sm: Word;
clockwebsck, clockreswebsck, webscktxt: TWebsocketClockServer;
appconfig: string;
WSPort: string = '57900';
WSPortR: string = '57901';
WSPortT: string = '57902';
{$R *.lfm}
function InitAppConfig:UnicodeString;
begin
CreateDir(GetAppConfigDir(False));
Result:=GetAppConfigFile(False);
end;
{ TFormWebSocketTmr }
procedure TFormWebSocketTmr.FormShow(Sender: TObject);
begin
lastTick:=0;
curtick:=0;
appconfig:=InitAppConfig;
LoadAppConfig;
try
clockwebsck:=TWebsocketClockServer.Create(WSPort,'WebSckClock');
clockreswebsck:=TWebsocketClockServer.Create(WSPortR,'WebSckClockRes');
clockreswebsck.Protocol.Incoming:=@WebSckResIncoming;
webscktxt:=TWebsocketClockServer.Create(WSPortT,'WebSckTXT');
webscktxt.Protocol.Incoming:=@WebSckTXTIncoming;
except
on e:exception do
ShowMessage(e.Message);
end;
stime:=Now;
Timer1.Enabled:=True;
//Timer1Timer(nil);
end;
procedure TFormWebSocketTmr.Timer1Timer(Sender: TObject);
var
CurTime: TDateTime;
s: string;
begin
if ButtonS.Tag<>0 then
curtick:=MilliSecondsBetween(Now,stime);
CurTime:=(lastTick+curtick)/3600/24/1000;
DecodeDateTime(Curtime,ye,mo,dd,hh,mm,ss,sm);
dd:=Trunc(CurTime);
hh:=hh+dd*24;
if CheckBoxMilli.Checked then
s:=Format('%d:%.2d:%.2d.%.3d',[hh,mm,ss,sm])
else
s:=Format('%d:%.2d:%.2d',[hh,mm,ss]);
StaticTextTmr.Caption:=s;
clockwebsck.BroadcastMsg(s);
end;
procedure TFormWebSocketTmr.WebSckResIncoming(const msg: RawByteString);
var
ResTime: TDateTime;
s: string;
ResTick: Int64;
rye, rmo, rdd, rhh, rmm, rss, rsm: Word;
begin
if ButtonS.Tag<>0 then begin
ResTick:=MilliSecondsBetween(Now,stime);
ResTime:=(lastTick+ResTick)/3600/24/1000;
DecodeDateTime(ResTime,rye,rmo,rdd,rhh,rmm,rss,rsm);
rdd:=Trunc(ResTime);
rhh:=rhh+rdd*24;
if CheckBoxMilli.Checked then
s:=Format('%d:%.2d:%.2d.%.3d',[rhh,rmm,rss,rsm])
else
s:=Format('%d:%.2d:%.2d',[rhh,rmm,rss]);
clockreswebsck.BroadcastMsg(msg+' '+s);
end;
end;
procedure TFormWebSocketTmr.WebSckTXTIncoming(const msg: RawByteString);
begin
webscktxt.BroadcastMsg(msg);
end;
procedure TFormWebSocketTmr.LoadAppConfig;
var
inifile:TIniFile;
begin
try
inifile:=TIniFile.Create(appconfig);
try
lastTick:=inifile.ReadInt64('TIME','LASTTICK',0);
WSPort:=inifile.ReadString('NET','PORT','57900');
WSPortR:=inifile.ReadString('NET','PORTR','57901');
WSPortT:=inifile.ReadString('NET','PORTT','57902');
CheckBoxMilli.Checked:=inifile.ReadBool('TIME','SHOWMILLI',False);
StaticTextTmr.Font.Name:=inifile.ReadString('FONT','NAME','');
StaticTextTmr.Font.Size:=inifile.ReadInteger('FONT','SIZE',36);
StaticTextTmr.Font.Color:=inifile.ReadInteger('FONT','COLOR',clHighlight);
ColorButtonB.ButtonColor:=inifile.ReadInteger('FONT','BGCOLOR',clBlack);
finally
inifile.Free;
end;
except
end;
end;
procedure TFormWebSocketTmr.SaveAppConfig;
var
inifile:TIniFile;
begin
try
lastTick:=lastTick+curtick;
inifile:=TIniFile.Create(appconfig);
try
inifile.WriteInt64('TIME','LASTTICK',lastTick);
inifile.WriteString('NET','PORT',WSPort);
inifile.WriteString('NET','PORTR',WSPortR);
inifile.WriteString('NET','PORTT',WSPortT);
inifile.WriteBool('TIME','SHOWMILLI',CheckBoxMilli.Checked);
inifile.WriteString('FONT','NAME',StaticTextTmr.Font.Name);
inifile.WriteInteger('FONT','SIZE',StaticTextTmr.Font.Size);
inifile.WriteInteger('FONT','COLOR',StaticTextTmr.Font.Color);
inifile.WriteInteger('FONT','BGCOLOR',ColorButtonB.ButtonColor);
finally
inifile.Free;
end;
except
end;
end;
procedure TFormWebSocketTmr.ButtonSClick(Sender: TObject);
begin
if ButtonS.Tag=0 then begin
stime:=Now;
ButtonS.Tag:=1;
if DoReset then begin
lastTick:=0;
DoReset:=False;
end;
//Timer1.Enabled:=True;
ButtonS.Caption:=rsStop;
end else begin
ButtonS.Tag:=0;
//Timer1.Enabled:=False;
lastTick:=lastTick+curtick;
curtick:=0;
ButtonS.Caption:=rsStart;
end;
end;
procedure TFormWebSocketTmr.ButtonFntClick(Sender: TObject);
begin
FontDialog1.Font.Name:=StaticTextTmr.Font.Name;
FontDialog1.Font.Size:=StaticTextTmr.Font.Size;
FontDialog1.Font.Color:=StaticTextTmr.Font.Color;
if FontDialog1.Execute then begin
StaticTextTmr.Font.Name:=FontDialog1.Font.Name;
StaticTextTmr.Font.Size:=FontDialog1.Font.Size;
StaticTextTmr.Font.Color:=FontDialog1.Font.Color;
end;
end;
procedure TFormWebSocketTmr.ButtonRClick(Sender: TObject);
begin
if QuestionDlg(Caption, rsResetTimer, mtConfirmation, [mrYes,rsYes, mrNo, rsNo,'IsDefault'], '')=mrYes
then begin
stime:=Now;
if ButtonS.Tag=0 then
DoReset:=True;
lastTick:=0;
Timer1Timer(nil);
end;
end;
procedure TFormWebSocketTmr.ButtonTXTClick(Sender: TObject);
begin
webscktxt.BroadcastMsg(EditTXT.Text);
EditTXT.SelectAll;
end;
procedure TFormWebSocketTmr.ColorButtonBColorChanged(Sender: TObject);
begin
Color:=ColorButtonB.ButtonColor;
end;
procedure TFormWebSocketTmr.EditTXTKeyPress(Sender: TObject; var Key: char);
begin
if Key=#13 then begin
ButtonTXT.Click;
Key:=#0;
end;
end;
procedure TFormWebSocketTmr.FormCloseQuery(Sender: TObject;
var CanClose: Boolean);
begin
if (ButtonS.Tag<>0) and (QuestionDlg(Caption, rsCloseTimer, mtConfirmation, [
mrYes, rsYes, mrNo, rsNo, 'IsDefault'], '')=mrNo) then
CanClose:=False;
end;
procedure TFormWebSocketTmr.FormDestroy(Sender: TObject);
begin
clockwebsck.Free;
clockreswebsck.Free;
webscktxt.free;
SaveAppConfig;
end;
end.
|
unit ImageResizingInformationUnit;
///////////////////////////////////////////////////
// //
// Description: //
// Container for image resizing information //
// Provides information on how to resize images //
// //
// Defaults: //
// FFileName - (blank) //
// FWidth - 800 //
// FHeight - 600 //
// FCurrentWidth - 0 //
// FCurrentHeight - 0 //
// FConvertedWidth - 0 //
// FConvertedHeight - 0 //
// FScale - 1 //
// FCompressMethod - False //
// FJPEGCompression - 80 //
// //
///////////////////////////////////////////////////
interface
uses
Classes;
type
TImageResizingInformation = class
private
///////////////////////
// Image information //
///////////////////////
FFileName: String; // current image filename + path
FWidth: integer; // width to hold to
FHeight: integer; // height ot hold to
FCurrentWidth: integer; // current image width
FCurrentHeight: integer; // current image height
FConvertedWidth: integer; // current image converted width
FConvertedHeight: integer; // current image converted height
FScale: real; // scale to hold to
FCompressMethod: Boolean; // False: use image compression value
FJPEGCompression: integer; // JPEG Compression level setting
public
////////////////////////////
// Constructor/Destructor //
////////////////////////////
constructor Create;
destructor Destroy; reintroduce; overload;
published
property FileName: String read FFileName write FFileName;
property Width: integer read FWidth write FWidth;
property Height: integer read FHeight write FHeight;
property CurrentWidth: integer read FCurrentWidth write FCurrentWidth;
property CurrentHeight: integer read FCurrentHeight write FCurrentHeight;
property ConvertedWidth: integer read FConvertedWidth write FConvertedWidth;
property ConvertedHeight: integer read FConvertedHeight write FConvertedHeight;
property Scale: real read FScale write FScale;
property CompressMethod: Boolean read FCompressMethod write FCompressMethod;
property JPEGCompression: integer read FJPEGCompression write FJPEGCompression;
end; // TImageResizingInformation
implementation
{ TImageResizingInformation }
////////////////////////////
// Constructor/Destructor //
////////////////////////////
constructor TImageResizingInformation.Create;
begin
inherited;
///////////////////////////
// Initialize everything //
///////////////////////////
FFileName := '';
FWidth := 800;
FHeight := 600;
FCurrentWidth := 0;
FCurrentHeight := 0;
FConvertedWidth := 0;
FConvertedHeight := 0;
FScale := 1;
FCompressMethod := False; // use image's compression value
FJPEGCompression := 80; // arbitrary default value, decent quality
end;
destructor TImageResizingInformation.Destroy;
begin
//////////////
// Clean up //
//////////////
inherited;
end;
end.
|
{*********************************************}
{ TeeGrid Software Library }
{ TRows class }
{ Copyright (c) 2016 by Steema Software }
{ All Rights Reserved }
{*********************************************}
unit Tee.Grid.Rows;
{$I Tee.inc}
interface
{
This unit implements a TRows class, derived from TGridBand.
TRows class paints multiple rows of column cells.
It also includes a "Children[]" property, with optional sub-rows for
each row.
This enables implementing hierarchical "rows-inside-rows".
}
uses
{System.}Classes,
{$IFNDEF FPC}
{System.}Types,
{$ENDIF}
{System.}SysUtils,
Tee.Format, Tee.Painter, Tee.Renders,
Tee.Grid.Data, Tee.Grid.Columns, Tee.Grid.Bands,
Tee.Grid.Selection;
type
// Formatting properties to paint odd row cells
TAlternateFormat=class(TVisibleFormat)
public
Constructor Create(const AChanged:TNotifyEvent); override;
function ShouldPaint:Boolean;
published
property Visible default False;
end;
TCellHover=class(TGridSelection)
private
procedure InitFormat;
end;
TRowsBands=record
private
FItems : Array of TGridBand;
procedure FreeAll;
function Get(const AIndex:Integer):TGridBand;
procedure Put(const AIndex:Integer; const AValue:TGridBand);
public
function Count:Integer; inline;
function Height(const ARow: Integer): Single;
function Hit(const X,Y:Single):TGridBand;
property Items[const Index:Integer]:TGridBand read Get write Put; default;
end;
// Grid Band to paint multiple rows of cells
TRows=class(TGridBandLines)
private
FAlternate: TAlternateFormat;
FHeight: Single;
FHover: TCellHover;
FRowLines: TStroke;
FSpacing: TCoordinate;
IData : TVirtualData;
ICustomHeights,
IHeights : Array of Single;
ISpacing : Single;
FChildren,
FSubBands : TRowsBands;
function AllHeightsEqual:Boolean;
function GetHeights(const Index: Integer): Single;
function IsHeightStored: Boolean;
procedure SetAlternate(const Value: TAlternateFormat);
procedure SetHeight(const Value: Single);
procedure SetHeights(const Index: Integer; const Value: Single);
procedure SetHover(const Value: TCellHover);
procedure SetSpacing(const Value: TCoordinate);
procedure SetRowLines(const Value: TStroke);
function SubBandHeight(const ARow:Integer):Single;
protected
procedure PaintRow(var AData:TRenderData; const ARender: TRender);
public
DefaultHeight : Single;
VisibleColumns : TVisibleColumns;
Render : TTextRender;
// Temporary:
XOffset : Single;
XSpacing : Single;
Scroll : TPointF;
Constructor Create(const AChanged:TNotifyEvent); override;
{$IFNDEF AUTOREFCOUNT}
Destructor Destroy; override;
{$ENDIF}
procedure Assign(Source:TPersistent); override;
procedure CalcYSpacing(const AHeight:Single);
procedure Clear;
function Count:Integer;
function DraggedColumn(const X:Single; const AColumn:TColumn):TColumn;
function FirstVisible:Integer;
function HeightOf(const ARow:Integer):Single;
function IsChildrenVisible(const Sender:TRender; const ARow: Integer): Boolean;
function MaxBottom: Single;
procedure Paint(var AData:TRenderData); override;
procedure PaintLines(const AData:TRenderData; const FirstRow:Integer; Y:Single);
function RowAt(const Y, AvailableHeight: Single): Integer;
procedure SetColumnsLeft(const ALeft:Single);
function TopOf(const ARow:Integer):Single;
function TopOfRow(const ARow:Integer):Single;
function TotalHeight(const ARow:Integer):Single;
function UpToRowHeight(const ARow:Integer):Single;
property Children:TRowsBands read FChildren;
property Data:TVirtualData read IData write IData;
property Heights[const Index:Integer]:Single read GetHeights write SetHeights;
property SubBands:TRowsBands read FSubBands;
property YSpacing:Single read ISpacing;
published
property Alternate:TAlternateFormat read FAlternate write SetAlternate;
property Height:Single read FHeight write SetHeight stored IsHeightStored;
property Hover:TCellHover read FHover write SetHover;
property RowLines:TStroke read FRowLines write SetRowLines;
property Spacing:TCoordinate read FSpacing write SetSpacing;
end;
implementation
|
unit PascalCoin.RPC.Test.AccountList;
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.Layouts, FMX.ListBox, FMX.Edit, FMX.Controls.Presentation;
type
TAccountsList = class(TFrame)
Layout1: TLayout;
Label1: TLabel;
PubKey: TEdit;
Button1: TButton;
ListBox1: TListBox;
PasteButton: TButton;
Label2: TLabel;
procedure Button1Click(Sender: TObject);
procedure PasteButtonClick(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
implementation
{$R *.fmx}
uses PascalCoin.RPC.Interfaces, Spring.Container,
FMX.Platform, FMX.Surfaces, System.Rtti, PascalCoin.RPC.Test.DM;
procedure TAccountsList.Button1Click(Sender: TObject);
var lAPI: IPascalCoinAPI;
lAccounts: IPascalCoinAccounts;
I: Integer;
begin
ListBox1.BeginUpdate;
try
ListBox1.Clear;
lAPI := GlobalContainer.Resolve<IPascalCoinAPI>.URI(DM.URI);
Label2.Text := 'Number of Accounts: ' + lAPI.getwalletaccountscount(PubKey.Text, TKeyStyle.ksB58Key).ToString;
lAccounts := lAPI.getwalletaccounts(Pubkey.Text, TKeyStyle.ksB58Key);
for I := 0 to lAccounts.Count - 1 do
begin
ListBox1.Items.Add(
lAccounts[I].account.ToString + ': ' + FloatToStr(lAccounts[I].balance));
end;
finally
ListBox1.EndUpdate
end;
end;
procedure TAccountsList.PasteButtonClick(Sender: TObject);
var
Svc: IFMXClipboardService;
Value: TValue;
begin
if TPlatformServices.Current.SupportsPlatformService(IFMXClipboardService, Svc) then
begin
Value := Svc.GetClipboard;
if not Value.IsEmpty then
begin
if Value.IsType<string> then
begin
PubKey.Text := Value.ToString;
end
end;
end;
end;
end.
|
unit ncaFrmConfigFid;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, ncaFrmBaseOpcaoImgTxtCheckBox, cxGraphics, cxControls,
cxLookAndFeels, cxLookAndFeelPainters, cxContainer, cxEdit, Menus, cxTextEdit,
cxCurrencyEdit, StdCtrls, cxButtons, cxLabel, cxCheckBox, dxGDIPlusClasses,
ExtCtrls, LMDControl, LMDCustomControl, LMDCustomPanel, LMDCustomBevelPanel,
LMDSimplePanel, cxDBEdit, cxMaskEdit, cxSpinEdit, cxGroupBox;
type
TFrmConfigFid = class(TFrmBaseOpcaoImgTxtCheckBox)
cbProdutos: TcxGroupBox;
cbFidParcial: TcxCheckBox;
panPremium: TLMDSimplePanel;
Image1: TImage;
cxLabel3: TcxLabel;
LMDSimplePanel2: TLMDSimplePanel;
lbPontos: TcxLabel;
edFidVendasPontos: TcxSpinEdit;
lbAcumular: TcxLabel;
LMDSimplePanel3: TLMDSimplePanel;
lbGastos: TcxLabel;
edFidVendasValor: TcxCurrencyEdit;
lbACada: TcxLabel;
cbPremio: TcxGroupBox;
cbAutoPremiar: TcxCheckBox;
LMDSimplePanel4: TLMDSimplePanel;
lbAutoPremiarPontos2: TcxLabel;
edAutoPremiarPontos: TcxSpinEdit;
lbAutoPremiarPontos: TcxLabel;
LMDSimplePanel5: TLMDSimplePanel;
edAutoPremiarValor: TcxCurrencyEdit;
lbAutoPremiarValor: TcxLabel;
procedure panPremiumClick(Sender: TObject);
procedure CBClick(Sender: TObject);
procedure cbAutoPremiarClick(Sender: TObject);
private
{ Private declarations }
procedure EnableDisable;
public
procedure Ler; override;
procedure Salvar; override;
function Alterou: Boolean; override;
procedure Renumera; override;
function NumItens: Integer; override;
{ Public declarations }
end;
var
FrmConfigFid: TFrmConfigFid;
implementation
uses ncaFrmPri, ncaDM, ncClassesBase;
{$R *.dfm}
resourcestring
SInformarPontos = 'É necessário informar a quantidade de pontos';
SInformarValor = 'É necessário informar o valor';
{ TFrmBaseOpcaoImgTxtCheckBox1 }
function TFrmConfigFid.Alterou: Boolean;
begin
Result := True;
if CB.Checked <> gConfig.FidAtivo then Exit;
if edFidVendasPontos.Value <> gConfig.FidVendaPontos then Exit;
if edFidVendasValor.Value <> gConfig.FidVendaValor then Exit;
if cbFidParcial.Checked <> gConfig.FidParcial then Exit;
if cbAutoPremiar.Checked <> gConfig.FidAutoPremiar then Exit;
if edAutoPremiarPontos.Value <> gConfig.FidAutoPremiarPontos then Exit;
if edAutoPremiarValor.Value <> gConfig.FidAutoPremiarValor then Exit;
Result := False;
end;
procedure TFrmConfigFid.cbAutoPremiarClick(Sender: TObject);
begin
inherited;
EnableDisable;
if cbAutoPremiar.Focused and cbAutoPremiar.Enabled then edAutoPremiarPontos.SetFocus;
end;
procedure TFrmConfigFid.CBClick(Sender: TObject);
begin
inherited;
EnableDisable;
if CB.Focused and CB.Checked then
edFidVendasPontos.SetFocus;
end;
procedure TFrmConfigFid.EnableDisable;
begin
lbAcumular.Enabled := CB.Checked and CB.Enabled;
edFidVendasPontos.Enabled := lbAcumular.Enabled;
lbPontos.Enabled := lbAcumular.Enabled;
lbAcada.Enabled := lbAcumular.Enabled;
edFidVendasValor.Enabled := lbAcumular.Enabled;
lbGastos.Enabled := lbAcumular.Enabled;
cbFidParcial.Enabled := lbAcumular.Enabled;
cbProdutos.Enabled := lbAcumular.Enabled;
cbPremio.Enabled := lbAcumular.Enabled;
cbAutoPremiar.Enabled := lbAcumular.Enabled;
lbAutoPremiarPontos.Enabled := lbAcumular.Enabled and cbAutoPremiar.Checked;
edAutoPremiarPontos.Enabled := lbAutoPremiarPontos.Enabled;
lbAutoPremiarPontos2.Enabled := lbAutoPremiarPontos.Enabled;
lbAutoPremiarValor.Enabled := lbAutoPremiarPontos.Enabled;
edAutoPremiarValor.Enabled := lbAutoPremiarPontos.Enabled;
end;
procedure TFrmConfigFid.Ler;
begin
inherited;
panPremium.Visible := not gConfig.IsPremium;
CB.Enabled := gConfig.IsPremium or gConfig.FidAtivo;
CB.Checked := gConfig.FidAtivo;
edFidVendasPontos.Value := gConfig.FidVendaPontos;
edFidVendasValor.Value := gConfig.FidVendaValor;
cbFidParcial.Checked := gConfig.FidParcial;
cbAutoPremiar.Checked := gConfig.FidAutoPremiar;
edAutoPremiarPontos.Value := gConfig.FidAutoPremiarPontos;
edAutoPremiarValor.Value := gConfig.FidAutoPremiarValor;
EnableDisable;
end;
function TFrmConfigFid.NumItens: Integer;
begin
Result := 7;
end;
procedure TFrmConfigFid.panPremiumClick(Sender: TObject);
begin
inherited;
OpenPremium('fidelidade');
end;
procedure TFrmConfigFid.Renumera;
begin
inherited;
CB.Caption := IntToStr(InicioNumItem)+'. '+CB.Caption;
lbAcada.Caption := IntToStr(InicioNumItem+2)+lbACada.Caption;
lbAcumular.Caption := IntToStr(InicioNumItem+1)+lbAcumular.Caption;
cbFidParcial.Caption := IntToStr(InicioNumItem+3)+cbFidParcial.Caption;
RenumCB(cbAutoPremiar, 4);
RenumLB(lbAutoPremiarPontos, 5);
RenumLB(lbAutoPremiarValor, 6);
end;
procedure TFrmConfigFid.Salvar;
begin
inherited;
if CB.Checked then begin;
if VarIsNull(edFidVendasPontos.Value) or (edFidVendasPontos.Value<0.01) then begin
edFidVendasPontos.SetFocus;
raise Exception.Create(SInformarPontos);
end;
if edFidVendasValor.Value<0.01 then begin
edFidVendasValor.SetFocus;
raise Exception.Create(SInformarValor);
end;
end;
gConfig.FidAtivo := CB.Checked;
gConfig.FidVendaPontos := edFidVendasPontos.Value;
gConfig.FidVendaValor := edFidVendasValor.Value;
gConfig.FidParcial := cbFidParcial.Checked;
gConfig.FidAutoPremiar := cbAutoPremiar.Checked;
gConfig.FidAutoPremiarPontos := edAutoPremiarPontos.Value;
gConfig.FidAutoPremiarValor := edAutoPremiarValor.Value;
end;
end.
|
unit CoordTransformTests;
interface
uses
TestFramework;
type
// Test methods for unit Geo.pas
TCoordTransformUnitTest = class(TTestCase)
private
public
published
procedure Test00;
procedure Test01;
end;
implementation
uses Math, CoordTransform, LatLon;
procedure TCoordTransformUnitTest.Test00;
var
pWGS84, pOSGB36 : TLatLon;
begin
pWGS84 := TLatLon.Create(53.333373, -0.150160);
pOSGB36 := ConvertWGS84toOSGB36(pWGS84);
CheckTrue((pOSGB36.Lat = 53.333075) and (pOSGB36.Lon = -0.148477), 'Convert WGS84 53.333373, -0.150160 to OSGB36');
end;
procedure TCoordTransformUnitTest.Test01;
var
pWGS84, pOSGB36 : TLatLon;
begin
pOSGB36 := TLatLon.Create(53.333075, -0.148477);
pWGS84 := ConvertOSGB36toWGS84(pOSGB36);
CheckTrue((pWGS84.Lat = 53.333373) and (pWGS84.Lon = -0.150160), 'Convert OSGB36 53.333075 -0.148477 to WGS84');
end;
initialization
// Register any test cases with the test runner
RegisterTest(TCoordTransformUnitTest.Suite);
end.
|
unit SearchProductQuery;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, BaseQuery, FireDAC.Stan.Intf,
FireDAC.Stan.Option, FireDAC.Stan.Param, FireDAC.Stan.Error, FireDAC.DatS,
FireDAC.Phys.Intf, FireDAC.DApt.Intf, FireDAC.Stan.Async, FireDAC.DApt,
Data.DB, FireDAC.Comp.DataSet, FireDAC.Comp.Client, Vcl.StdCtrls, DSWrap;
type
TSearchProductW = class(TDSWrap)
private
FDatasheet: TFieldWrap;
FValue: TFieldWrap;
FDescriptionID: TFieldWrap;
FDiagram: TFieldWrap;
FDrawing: TFieldWrap;
FID: TFieldWrap;
FIDProducer: TFieldWrap;
FImage: TFieldWrap;
public
constructor Create(AOwner: TComponent); override;
property Datasheet: TFieldWrap read FDatasheet;
property Value: TFieldWrap read FValue;
property DescriptionID: TFieldWrap read FDescriptionID;
property Diagram: TFieldWrap read FDiagram;
property Drawing: TFieldWrap read FDrawing;
property ID: TFieldWrap read FID;
property IDProducer: TFieldWrap read FIDProducer;
property Image: TFieldWrap read FImage;
end;
TQuerySearchProduct = class(TQueryBase)
private
FW: TSearchProductW;
{ Private declarations }
public
constructor Create(AOwner: TComponent); override;
function SearchByID(AID: Integer): Integer;
function SearchByValue(const AValue: string): Integer; overload;
function SearchByValue(const AValue: string; const AIDProducer: Integer)
: Integer; overload;
property W: TSearchProductW read FW;
{ Public declarations }
end;
implementation
{$R *.dfm}
uses StrHelper;
constructor TQuerySearchProduct.Create(AOwner: TComponent);
begin
inherited;
FW := TSearchProductW.Create(FDQuery);
end;
function TQuerySearchProduct.SearchByID(AID: Integer): Integer;
begin
Assert(AID > 0);
Result := SearchEx([TParamRec.Create(W.ID.FullName, AID)]);
end;
function TQuerySearchProduct.SearchByValue(const AValue: string;
const AIDProducer: Integer): Integer;
begin
Assert(not AValue.IsEmpty);
Assert(AIDProducer > 0);
// Меняем в запросе условие
Result := SearchEx([TParamRec.Create(W.Value.FullName, AValue, ftWideString),
TParamRec.Create(W.IDProducer.FullName, AIDProducer)])
end;
function TQuerySearchProduct.SearchByValue(const AValue: string): Integer;
begin
Assert(not AValue.IsEmpty);
Result := SearchEx([TParamRec.Create(W.Value.FullName, AValue,
ftWideString)]);
end;
constructor TSearchProductW.Create(AOwner: TComponent);
begin
inherited;
FID := TFieldWrap.Create(Self, 'ID', '', True);
FDatasheet := TFieldWrap.Create(Self, 'Datasheet');
FDescriptionID := TFieldWrap.Create(Self, 'DescriptionID');
FDiagram := TFieldWrap.Create(Self, 'Diagram');
FDrawing := TFieldWrap.Create(Self, 'Drawing');
FIDProducer := TFieldWrap.Create(Self, 'IDProducer');
FImage := TFieldWrap.Create(Self, 'Image');
FValue := TFieldWrap.Create(Self, 'Value');
end;
end.
|
{*******************************************************}
{ }
{ Borland Delphi Visual Component Library }
{ SOAP Support }
{ }
{ Copyright (c) 2001 Borland Software Corporation }
{ }
{*******************************************************}
unit XSBuiltIns;
interface
uses SysUtils, InvokeRegistry;
const
SoapTimePrefix = 'T';
XMLDateSeparator = '-';
XMLHourOffsetMinusMarker = '-';
XMLHourOffsetPlusMarker = '+';
XMLTimeSeparator = ':';
XMLMonthPos = 6;
XMLDayPos = 9;
XMLYearPos = 1;
XMLMilSecPos = 10;
XMLDefaultYearDigits = 4;
XMLDurationStart = 'P';
XMLDurationYear = 'Y';
XMLDurationMonth = 'M';
XMLDurationDay = 'D';
XMLDurationHour = 'H';
XMLDurationMinute = 'M';
XMLDurationSecond = 'S';
resourcestring
SInvalidHour = 'Invalid hour: %d';
SInvalidMinute = 'Invalid minute: %d';
SInvalidSecond = 'Invalid second: %d';
SInvalidFractionSecond = 'Invalid second: %f';
SInvalidMillisecond = 'Invalid millisecond: %d';
SInvalidHourOffset = 'Invalid hour offset: %d';
SInvalidDay = 'Invalid day: %d';
SInvalidMonth = 'Invalid month: %d';
SInvalidDuration = 'Invalid Duration String: %s';
type
{ forward declarations }
TXSDuration = class;
TXSTime = class;
TXSDate = class;
TXSDateTime = class;
{ TXSTime }
TXSTime = class(TRemotableXS)
private
FHour: Word;
FMinute: Word;
FSecond: Word;
FMillisecond: Word;
FHourOffset: SmallInt;
FMinuteOffset: SmallInt;
function BuildHourOffset: WideString;
protected
function GetAsTime: TDateTime;
procedure SetAsTime(Value: TDateTime);
procedure SetHour(const Value: Word);
procedure SetMinute(const Value: Word);
procedure SetSecond(const Value: Word);
procedure SetMillisecond(const Value: Word);
procedure SetHourOffset(const Value: SmallInt);
procedure SetMinuteOffset(const Value: SmallInt);
public
function Clone: TXSTime;
property Hour: Word read FHour write SetHour default 0;
property Minute: Word read FMinute write SetMinute default 0;
property Second: Word read FSecond write SetSecond default 0;
property Millisecond: Word read FMillisecond write SetMillisecond default 0;
property HourOffset: SmallInt read FHourOffset write SetHourOffset default 0;
property MinuteOffset: SmallInt read FMinuteOffset write SetMinuteOffset;
procedure XSToNative(Value: WideString); override;
function NativeToXS: WideString; override;
property AsTime: TDateTime read GetAsTime write SetAsTime;
end;
{ TXSDate }
TXSDate = class(TRemotableXS)
private
FAdditionalYearDigits: Word;
FMonth: Word;
FDay: Word;
FYear: Word;
FMaxDay: Word;
FMaxMonth: Word;
FMinDay: Word;
FMinMonth: Word;
protected
function GetAsDate: TDateTime;
procedure SetAsDate(Value: TDateTime);
procedure SetMonth(const Value: Word);
procedure SetDay(const Value: Word);
procedure SetYear(const Value: Word);
property MaxDay: Word read FMaxDay write FMaxDay;
property MaxMonth: Word read FMaxMonth write FMaxMonth;
property MinDay: Word read FMinDay write FMinDay;
property MinMonth: Word read FMinMonth write FMinMonth;
public
constructor Create; override;
property Month: Word read FMonth write SetMonth default 0;
property Day: Word read FDay write SetDay default 0;
property Year: Word read FYear write SetYear default 0;
function Clone: TXSDate;
procedure XSToNative(Value: WideString); override;
function NativeToXS: WideString; override;
property AsDate: TDateTime read GetAsDate write SetAsDate;
end;
{ TXSCustomDateTime }
TXSCustomDateTime = class(TRemotableXS)
private
FDateParam: TXSDate;
FTimeParam: TXSTime;
protected
function GetAsDateTime: TDateTime;
function GetHour: Word;
function GetMinute: Word;
function GetSecond: Word;
function GetMonth: Word;
function GetDay: Word;
function GetYear: Word;
function GetMillisecond: Word;
function GetHourOffset: SmallInt;
function GetMinuteOffset: SmallInt;
procedure SetAsDateTime(Value: TDateTime);
procedure SetHour(const Value: Word); virtual;
procedure SetMinute(const Value: Word); virtual;
procedure SetSecond(const Value: Word); virtual;
procedure SetMillisecond(const Value: Word); virtual;
procedure SetHourOffset(const Value: SmallInt); virtual;
procedure SetMinuteOffset(const Value: SmallInt); virtual;
procedure SetMonth(const Value: Word); virtual;
procedure SetDay(const Value: Word); virtual;
procedure SetYear(const Value: Word); virtual;
public
constructor Create; override;
destructor Destroy; override;
property AsDateTime: TDateTime read GetAsDateTime write SetAsDateTime;
property Hour: Word read GetHour write SetHour default 0;
property Minute: Word read GetMinute write SetMinute default 0;
property Second: Word read GetSecond write SetSecond default 0;
property Month: Word read GetMonth write SetMonth default 0;
property Day: Word read GetDay write SetDay default 0;
property Year: Word read GetYear write SetYear default 0;
end;
{ TXSDateTime }
TXSDateTime = class(TXSCustomDateTime)
private
function ValidValue(Value, Subtract, Min, Max: Integer; var Remainder: Integer): Integer;
public
function CompareDateTimeParam(const Value1, Value2: TXSDateTime): TXSDuration;
public
function Clone: TXSDateTime;
property Millisecond: Word read GetMillisecond write SetMillisecond default 0;
property HourOffset: SmallInt read GetHourOffset write SetHourOffset default 0;
property MinuteOffset: SmallInt read GetMinuteOffset write SetMinuteOffset default 0;
procedure XSToNative(Value: WideString); override;
function NativeToXS: WideString; override;
end;
TXSDuration = class(TXSCustomDateTime)
private
FDecimalSecond: Double;
function GetDecimalValue(const AParam: String; const AType: string): Double;
function GetIntegerValue(const AParam: String; const AType: string): Integer;
function GetNumericString(const AParam: string; const AType: String;
const Decimals: Boolean = False): WideString;
protected
procedure SetDecimalSecond(const Value: Double);
public
constructor Create; override;
procedure XSToNative(Value: WideString); override;
function NativeToXS: WideString; override;
property DecimalSecond: Double read FDecimalSecond write SetDecimalSecond;
end;
EXSDateTimeException = class(Exception);
{ Utility function }
function DateTimeToXSDateTime(Value: TDateTime; CalcLocalBias: Boolean = False): TXSDateTime;
implementation
uses SoapConst, Windows;
{ exception routines }
procedure SoapDateTimeError(const Message: string); local;
begin
raise EXSDateTimeException.Create(Message);
end;
procedure SoapDateTimeErrorFmt(const Message: string; const Args: array of const); local;
begin
SoapDateTimeError(Format(Message,Args));
end;
{ Utility functions }
procedure AddUTCBias(var DateTime: TXSDateTime);
var
Info: TTimeZoneInformation;
Status: DWORD;
begin
Status := GetTimeZoneInformation(Info);
if (Status = TIME_ZONE_ID_UNKNOWN) or (Status = TIME_ZONE_ID_INVALID) then
SoapDateTimeError(SInvalidTimeZone);
DateTime.HourOffset := Info.Bias div 60;
DateTime.MinuteOffset := Info.Bias - (DateTime.HourOffset * 60);
end;
function DateTimeToXSDateTime(Value: TDateTime; CalcLocalBias: Boolean = False): TXSDateTime;
begin
Result := TXSDateTime.Create;
Result.AsDateTime := Value;
if CalcLocalBias then
AddUTCBias(Result);
end;
procedure ParseXMLDate(ADate: WideString; var Year, Month, Day: Word);
begin
Year := StrToInt(Copy(ADate, XMLYearPos, 4));
Month := StrToInt(Copy(ADate, XMLMonthPos, 2));
Day := StrToInt(Copy(ADate, XMLDayPos, 2));
end;
function XMLDateToStr(ADate: WideString; AddDigits: Word = 0): WideString;
begin
Result := Copy(ADate, XMLMonthPos + AddDigits, 2) + DateSeparator +
Copy(ADate, XMLDayPos + AddDigits, 2 ) +
DateSeparator + Copy(ADate, XMLYearPos, XMLDefaultYearDigits + AddDigits);
end;
// get Small Int Using Digits in value, positive or negative.
function IntFromValue(Value: WideString; Digits: Integer): SmallInt;
begin
Result := 0;
if Value[1] = '-' then
Result := StrToInt(Value)
else if Value <> '' then
Result := StrToInt(Copy(Value, 1, Digits));
end;
{ TXSTime }
function TXSTime.Clone: TXSTime;
begin
Result := TXSTime.Create;
Result.Hour := Hour;
Result.Minute := Minute;
Result.Second := Second;
Result.MilliSecond := MilliSecond;
Result.HourOffset := HourOffset;
Result.MinuteOffset := MinuteOffset;
end;
procedure TXSTime.SetHour(const Value: Word);
begin
if Value < HoursPerDay then
FHour := Value
else
SoapDateTimeErrorFmt(SInvalidHour, [Value]);
end;
procedure TXSTime.SetMinute(const Value: Word);
begin
if Value < 60 then
FMinute := Value
else
SoapDateTimeErrorFmt(SInvalidMinute, [Value]);
end;
procedure TXSTime.SetSecond(const Value: Word);
begin
if Value < 60 then
FSecond := Value
else
SoapDateTimeErrorFmt(SInvalidSecond, [Value]);
end;
procedure TXSTime.SetMillisecond(const Value: Word);
begin
if Value < 1000 then
FMillisecond := Value
else
SoapDateTimeErrorFmt(SInvalidMillisecond, [Value]);
end;
procedure TXSTime.SetHourOffset(const Value: SmallInt);
begin
if Abs(Value) <= (HoursPerDay div 2) then
FHourOffset := Value
else
SoapDateTimeErrorFmt(SInvalidHourOffset, [Value]);
end;
procedure TXSTime.SetMinuteOffset(const Value: SmallInt);
begin
if Abs(Value) < 60 then
FMinuteOffset := Value
else
SoapDateTimeErrorFmt(SInvalidMinute, [Value]);
end;
procedure TXSTime.XSToNative(Value: WideString);
var
TempValue: WideString;
TempTime: TDateTime;
HourOffsetPos: Integer;
begin
TempValue := StringReplace(Copy(Value, 1, 8), XMLTimeSeparator, TimeSeparator, []);
TempTime := StrToTime(TempValue);
DecodeTime(TempTime, FHour, FMinute, FSecond, FMillisecond);
TempValue := Copy(Value, XMLMilSecPos, 3);
Millisecond := IntFromValue(TempValue, 3);
HourOffsetPos := Pos(XMLHourOffsetMinusMarker, Value);
if HourOffsetPos = 0 then
HourOffsetPos := Pos(XMLHourOffsetPlusMarker, Value);
if HourOffsetPos > 0 then
begin
TempValue := Copy(Value, HourOffsetPos + 1, 2);
HourOffset := IntFromValue(TempValue, 2);
TempValue := Copy(Value, HourOffsetPos + 4, 2);
if TempValue <> '' then
MinuteOffSet := IntFromValue(TempValue,2);
end;
end;
function TXSTime.BuildHourOffset: WideString;
var
Marker: String;
begin
if Abs(HourOffset) + MinuteOffset <> 0 then
begin
if HourOffset > 0 then
Marker := XMLHourOffsetPlusMarker
else
Marker := XMLHourOffsetMinusMarker;
Result := IntToStr(Abs(HourOffset));
if Abs(HourOffset) < 10 then
Result := '0' + Result;
if Abs(MinuteOffSet) > 9 then
Result := Result + XMLTimeSeparator + IntToStr(Abs(MinuteOffset))
else if Abs(MinuteOffSet) > 0 then
Result := Result + XMLTimeSeparator + '0' + IntToStr(Abs(MinuteOffset))
else
Result := Result + XMLTimeSeparator + '00';
Result := Marker + Result;
end;
end;
function TXSTime.NativeToXS: WideString;
var
TempTime: TDateTime;
FormatString: string;
begin
if Hour + Minute + Second = 0 then exit;
TempTime := EncodeTime(Hour, Minute, Second, Millisecond); // exception thrown if invalid
FormatString := Format('hh%snn%sss.zzz', [XMLTimeSeparator, XMLTimeSeparator]);
Result := FormatDateTime(FormatString, TempTime) + BuildHourOffset;
end;
procedure TXSTime.SetAsTime(Value: TDateTime);
begin
DecodeTime(Value, FHour, FMinute, FSecond, FMillisecond);
end;
function TXSTime.GetAsTime: TDateTime;
var
TimeString: string;
Colon: string;
begin
Colon := TimeSeparator;
TimeString := IntToStr(Hour) + Colon + IntToStr(Minute) + Colon +
IntToStr(Second);
Result := StrToTime(TimeString);
end;
{ TXSDate }
constructor TXSDate.Create;
begin
inherited Create;
FMaxMonth := 12;
FMinMonth := 1;
FMaxDay := 31;
FMinDay := 1;
end;
function TXSDate.Clone: TXSDate;
begin
Result := TXSDate.Create;
Result.Day := Day;
Result.Month := Month;
Result.Year := Year;
end;
procedure TXSDate.SetMonth(const Value: Word);
begin
if (Value <= FMaxMonth) and (Value >= FMinMonth) then
FMonth := Value
else
SoapDateTimeErrorFmt(SInvalidMonth, [Value]);
end;
procedure TXSDate.SetDay(const Value: Word);
begin
if (Value <= FMaxDay) and (Value >= FMinDay) then // perform more complete check when all values set
FDay := Value
else
SoapDateTimeErrorFmt(SInvalidDay, [Value]);
end;
procedure TXSDate.SetYear(const Value: Word);
begin
FYear := Value
end;
procedure TXSDate.XSToNative(Value: WideString);
var
TempDate: TDateTime;
begin
FAdditionalYearDigits := Pos(XMLDateSeparator,Value) - (1 + XMLDefaultYearDigits);
TempDate := StrToDate(XMLDateToStr(Value, FAdditionalYearDigits));
DecodeDate(TempDate, FYear, FMonth, FDay);
end;
function TXSDate.NativeToXS: WideString;
var
TempDate: TDateTime;
FormatString: string;
begin
if Year + Month + Day = 0 then exit;
TempDate := EncodeDate(Year, Month, Day); // exception thrown if invalid
FormatString := Format('yyyy%smm%sdd', [XMLDateSeparator, XMLDateSeparator]);
Result := FormatDateTime(FormatString, TempDate);
end;
function TXSDate.GetAsDate: TDateTime;
var
DateString: string;
Slash: string;
begin
Slash := DateSeparator;
DateString := IntToStr(Month) + Slash + IntToStr(Day) + Slash + IntToStr(Year);
Result := StrToDate(DateString);
end;
procedure TXSDate.SetAsDate(Value: TDateTime);
begin
DecodeDate(Value, FYear, FMonth, FDay);
end;
{ TXSCustomDateTime }
constructor TXSCustomDateTime.Create;
begin
Inherited Create;
FDateParam := TXSDate.Create;
FTimeParam := TXSTime.Create;
end;
destructor TXSCustomDateTime.Destroy;
begin
FDateParam.Free;
FTimeParam.Free;
inherited Destroy;
end;
function TXSCustomDateTime.GetHour: Word;
begin
Result := FTimeParam.Hour;
end;
function TXSCustomDateTime.GetMinute: Word;
begin
Result := FTimeParam.Minute;
end;
function TXSCustomDateTime.GetSecond: Word;
begin
Result := FTimeParam.Second;
end;
function TXSCustomDateTime.GetMilliSecond: Word;
begin
Result := FTimeParam.MilliSecond;
end;
function TXSCustomDateTime.GetHourOffset: SmallInt;
begin
Result := FTimeParam.HourOffset;
end;
function TXSCustomDateTime.GetMinuteOffset: SmallInt;
begin
Result := FTimeParam.MinuteOffset;
end;
function TXSCustomDateTime.GetMonth: Word;
begin
Result := FDateParam.Month;
end;
function TXSCustomDateTime.GetDay: Word;
begin
Result := FDateParam.Day;
end;
function TXSCustomDateTime.GetYear: Word;
begin
Result := FDateParam.Year;
end;
procedure TXSCustomDateTime.SetHour(const Value: Word);
begin
FTimeParam.SetHour(Value);
end;
procedure TXSCustomDateTime.SetMinute(const Value: Word);
begin
FTimeParam.SetMinute(Value);
end;
procedure TXSCustomDateTime.SetSecond(const Value: Word);
begin
FTimeParam.SetSecond(Value);
end;
procedure TXSCustomDateTime.SetMillisecond(const Value: Word);
begin
FTimeParam.SetMillisecond(Value);
end;
procedure TXSCustomDateTime.SetHourOffset(const Value: SmallInt);
begin
FTimeParam.SetHourOffset(Value);
end;
procedure TXSCustomDateTime.SetMinuteOffset(const Value: SmallInt);
begin
FTimeParam.SetMinuteOffset(Value);
end;
procedure TXSCustomDateTime.SetMonth(const Value: Word);
begin
FDateParam.SetMonth(Value);
end;
procedure TXSCustomDateTime.SetDay(const Value: Word);
begin
FDateParam.SetDay(Value);
end;
procedure TXSCustomDateTime.SetYear(const Value: Word);
begin
FDateParam.SetYear(Value);
end;
procedure TXSCustomDateTime.SetAsDateTime(Value: TDateTime);
begin
FDateParam.AsDate := Value;
FTimeParam.AsTime := Value;
end;
function TXSCustomDateTime.GetAsDateTime: TDateTime;
var
DateString: string;
Slash: string;
Colon: string;
begin
Slash := DateSeparator;
Colon := TimeSeparator;
DateString := IntToStr(Month) + Slash + IntToStr(Day) + Slash + IntToStr(Year)
+ ' ' + IntToStr(Hour) + Colon + IntToStr(Minute) + Colon +
IntToStr(Second);
Result := StrToDateTime(DateString);
end;
{ TXSDateTime }
function TXSDateTime.Clone: TXSDateTime;
begin
Result := TXSDateTime.Create;
Result.FDateParam.Day := Day;
Result.FDateParam.Month := Month;
Result.FDateParam.Year := Year;
Result.FTimeParam.Hour := Hour;
Result.FTimeParam.Minute := Minute;
Result.FTimeParam.Second := Second;
Result.FTimeParam.MilliSecond := MilliSecond;
Result.FTimeParam.HourOffset := HourOffset;
Result.FTimeParam.MinuteOffset := MinuteOffset;
end;
procedure TXSDateTime.XSToNative(Value: WideString);
var
TimeString, DateString: WideString;
TimePosition: Integer;
begin
TimePosition := Pos(SoapTimePrefix, Value);
if TimePosition > 0 then
begin
DateString := Copy(Value, 1, TimePosition -1);
TimeString := Copy(Value, TimePosition + 1, Length(Value) - TimePosition);
FDateParam.XSToNative(DateString);
FTimeParam.XSToNative(TimeString);
end else
FDateParam.XSToNative(Value);
end;
function TXSDateTime.NativeToXS: WideString;
var
TimeString: WideString;
begin
TimeString := FTimeParam.NativeToXS;
if TimeString <> '' then
Result := FDateParam.NativeToXS + SoapTimePrefix + TimeString
else
Result := FDateParam.NativeToXS;
end;
function TXSDateTime.ValidValue(Value, Subtract, Min, Max: Integer; var Remainder: Integer): Integer;
begin
Result := Value - Subtract;
Remainder := 0;
if Result < Min then
begin
Remainder := 1;
Inc(Result,Max);
end;
end;
function TXSDateTime.CompareDateTimeParam(const Value1, Value2: TXSDateTime): TXSDuration;
var
Remainder, Milliseconds, Seconds: Integer;
begin
Result := TXSDuration.Create;
try
MilliSeconds := ValidValue(Value1.Millisecond, Value2.Millisecond, 0, 1000, Remainder);
Seconds := ValidValue(Value1.Second + Remainder, Value2.Second, 0, 60, Remainder);
Result.DecimalSecond := Seconds + Milliseconds / 1000;
Result.Minute := ValidValue(Value1.Minute + Remainder, Value2.Minute, 0, 60, Remainder);
Result.Hour := ValidValue(Value1.Hour + Remainder, Value2.Hour, 0, 24, Remainder);
Result.Day := ValidValue(Value1.Day + Remainder, Value2.Day, 0, 31, Remainder);
Result.Month := ValidValue(Value1.Month + Remainder, Value2.Month, 0, 12, Remainder);
Result.Year := ValidValue(Value1.Year + Remainder, Value2.Year, -9999, 0, Remainder);
except
Result.Free;
Result := nil;
end;
end;
{ TXSDuration }
constructor TXSDuration.Create;
begin
inherited Create;
FDateParam.MaxDay := 30;
FDateParam.MinDay := 0;
FDateParam.MaxMonth := 11;
FDateParam.MinMonth := 0;
end;
procedure TXSDuration.SetDecimalSecond(const Value: Double);
begin
if Value < 60 then
FDecimalSecond := Value
else
SoapDateTimeErrorFmt(SInvalidFractionSecond, [Value]);
end;
function TXSDuration.GetNumericString(const AParam: string; const AType: string;
const Decimals: Boolean = False): WideString;
var
I, J: Integer;
begin
I := Pos(AType, AParam);
J := I;
while (I > 0) and ((AParam[I-1] in ['0'..'9']) or
(Decimals and (AParam[I-1] = '.'))) do
Dec(I);
if J > I then
Result := Copy(AParam, I, J-I)
else
Result := '0';
end;
function TXSDuration.GetIntegerValue(const AParam: string; const AType: string): Integer;
begin
Result := StrToInt(GetNumericString(AParam, AType));
end;
function TXSDuration.GetDecimalValue(const AParam: string; const AType: string): Double;
begin
Result := StrToFloat(GetNumericString(AParam, AType, True));
end;
procedure TXSDuration.XSToNative(Value: WideString);
var
DateString, TimeString: string;
TimePosition: Integer;
begin
if Value[1] <> XMLDurationStart then
SoapDateTimeErrorFmt(SInvalidDuration, [Value]);
TimePosition := Pos(SoapTimePrefix, Value);
if TimePosition > 0 then
begin
TimeString := Copy(Value, TimePosition + 1, Length(Value) - TimePosition);
DateString := Copy(Value, 1, TimePosition - 1);
end else
DateString := Value;
Year := GetIntegerValue(DateString, XMLDurationYear);
Month := GetIntegerValue(DateString, XMLDurationMonth);
Day := GetIntegerValue(DateString, XMLDurationDay);
if TimePosition > 0 then
begin
Hour := GetIntegerValue(TimeString, XMLDurationHour);
Minute := GetIntegerValue(TimeString, XMLDurationMinute);
DecimalSecond := GetDecimalValue(TimeString, XMLDurationSecond);
end;
end;
{ format is 'P1Y2M3DT10H30M12.3S' }
function TXSDuration.NativeToXS: WideString;
begin
Result := XMLDurationStart +
IntToStr(Year) + XMLDurationYear +
IntToStr(Month) + XMLDurationMonth +
IntToStr(Day) + XMLDurationDay + SoapTimePrefix +
IntToStr(Hour) + XMLDurationHour +
IntToStr(Minute) + XMLDurationMinute +
FloatToStr(DecimalSecond) + XMLDurationSecond;
end;
initialization
RemClassRegistry.RegisterXSClass(TXSDateTime, XMLSchemaNameSpace, 'dateTime', '',True );
RemClassRegistry.RegisterXSClass(TXSTime, XMLSchemaNameSpace, 'time', '', True );
RemClassRegistry.RegisterXSClass(TXSDate, XMLSchemaNameSpace, 'date', '', True );
RemClassRegistry.RegisterXSClass(TXSDuration, XMLSchemaNameSpace, 'duration', '', True );
finalization
RemClassRegistry.UnRegisterXSClass(TXSDateTime);
RemClassRegistry.UnRegisterXSClass(TXSTime);
RemClassRegistry.UnRegisterXSClass(TXSDate);
RemClassRegistry.UnRegisterXSClass(TXSDuration);
end.
|
{*******************************************************}
{ }
{ Delphi LiveBindings Framework }
{ }
{ Copyright(c) 2011-2018 Embarcadero Technologies, Inc. }
{ All rights reserved }
{ }
{*******************************************************}
unit System.Bindings.Helper;
interface
uses
System.SysUtils, System.Classes, System.Generics.Collections, System.TypInfo, System.Bindings.EvalProtocol, System.Bindings.EvalSys,
System.Bindings.NotifierContracts, System.Bindings.NotifierDefaults, System.Bindings.Factories,
System.Bindings.Expression, System.Bindings.ExpressionDefaults, System.Bindings.Manager, System.Bindings.Outputs;
type
EBindHelperException = class(Exception);
/// <summary>Binding Events Record</summary>
TBindingEventRec = record
public
EvalErrorEvent: TBindingEvalErrorEvent;
AssigningValueEvent: TBindingAssigningValueEvent;
AssignedValueEvent: TBindingAssignedValueEvent;
LocationUpdatedEvent: TBindingLocationUpdatedEvent;
class function Create: TBindingEventRec; overload; static;
constructor Create(AEvalErrorEvent: TBindingEvalErrorEvent); overload;
constructor Create(AAssigningValueEvent: TBindingAssigningValueEvent); overload;
constructor Create(AEvalErrorEvent: TBindingEvalErrorEvent; AAssigningValueEvent: TBindingAssigningValueEvent); overload;
constructor Create(AEvalErrorEvent: TBindingEvalErrorEvent; AAssigningValueEvent: TBindingAssigningValueEvent;
AAssignedValueEvent: TBindingAssignedValueEvent); overload;
constructor Create(AEvalErrorEvent: TBindingEvalErrorEvent; AAssigningValueEvent: TBindingAssigningValueEvent;
AAssignedValueEvent: TBindingAssignedValueEvent; ALocationUpdatedEvent: TBindingLocationUpdatedEvent); overload;
end;
/// <summary>Binding Helper class with utility methods.</summary>
TBindings = class
public type
TCreateOption = (coNotifyOutput, coEvaluate);
TCreateOptions = set of TCreateOption;
public
/// <summary>Creates a bindingNotifier which is used to trigger corresponding expression objects to be re-evaluated</summary>
/// <param name="AObject">Object used in expression that should be re-evaluated</param>
/// <param name="Manager">The bindingManager that the expression belongs in. AppManager is used when left nil</param>
/// <returns>Returns IBindingNotifier which can be used to trigger found expression object</returns>
class function CreateNotifier(const AObject: TObject; Manager: TBindingManager = nil): IBindingNotifier;
/// <summary>Trigger corresponding expression objects to be re-evaluated given an Object and Property</summary>
/// <param name="Sender">Object used in expression that should be re-evaluated</param>
/// <param name="PropName">Property used in expression that should be re-evaluated</param>
/// <param name="Manager">The bindingManager that the expression belongs in. AppManager is used when left nil</param>
class procedure Notify(Sender: TObject; PropName: string = ''; Manager: TBindingManager = nil);
/// <summary>Returns a Scope capable of handling a Invokable function represented by an method alias in a string expression</summary>
/// <param name="MethodName">Method name or alias that will be used in binding string expressions</param>
/// <param name="InvokableMethod">Function that will be used in binding string expressions</param>
/// <returns>Input Scope containing the invokable method which is used when method alias is being looked up by engine evaluator</returns>
class function CreateMethodScope(const MethodName: string; InvokableMethod: IInvokable): IScope; overload;
class function CreateMethodScope(AMethod: TArray<TPair<string, IInvokable>>): IScope; overload;
class function CreateAssociationScope(Assocs: array of TBindingAssociation): IScope;
/// <summary>Helper function to create a managed binding expression</summary>
/// <remark>A managed binding expression will be automatically notified based on dependencies with respect to other existing bindings</remark>
/// <param name="InputScopes">Array of input scopes used for lookups of the binding expression string</param>
/// <param name="BindExprStr">String expression to be evaluated by the binding engine</param>
/// <param name="OutputScopes">Array of output scopes used for lookups of the output assignment location</param>
/// <param name="OutputExpr">String expression to be evaluated with the OutputScopes to determine assignment location</param>
/// <param name="OutputConverter">Output converters to use with the binding expression. All default converters will be used if nil</param>
/// <param name="BindingEventRec">Record containing binding expression events</param>
/// <param name="Manager">Manager to create the binding expression object in. Root AppManager will be used if unprovided</param>
/// <param name="Options">Options which affect behavior of binding expression</param>
/// <returns>Returns the instantiated binding expression object</returns>
class function CreateManagedBinding(
const InputScopes: array of IScope;
const BindExprStr: string;
const OutputScopes: array of IScope;
const OutputExpr: string;
const OutputConverter: IValueRefConverter;
BindingEventRec: TBindingEventRec;
Manager: TBindingManager = nil;
Options: TCreateOptions = [coNotifyOutput]): TBindingExpression; overload;
class function CreateManagedBinding(
const InputScopes: array of IScope;
const BindExprStr: string;
const OutputScopes: array of IScope;
const OutputExpr: string;
const OutputConverter: IValueRefConverter;
Manager: TBindingManager = nil;
Options: TCreateOptions = [coNotifyOutput]): TBindingExpression; overload;
/// <summary>Helper function to create a unmanaged binding expression</summary>
/// <remark>An umanaged binding expression will not be evaluated automatically and will not trigger other existing bindings. It will assign the calculated expression value to the designated outputs when evaluated manually.</remark>
/// <param name="InputScopes">Array of input scopes used for lookups of the binding expression string</param>
/// <param name="BindExprStr">String expression to be evaluated by the binding engine</param>
/// <param name="OutputScopes">Array of output scopes used for lookups of the output assignment location</param>
/// <param name="OutputExpr">String expression to be evaluated with the OutputScopes to determine assignment location</param>
/// <param name="OutputConverter">Output converters to use with the binding expression. All default converters will be used if nil</param>
/// <param name="BindingEventRec">Record containing binding expression events</param>
/// <param name="Options">Options which affect behavior of binding expression</param>
/// <returns>Returns the instantiated binding expression object</returns>
class function CreateUnmanagedBinding(
const InputScopes: array of IScope;
const BindExprStr: string;
const OutputScopes: array of IScope;
const OutputExpr: string;
const OutputConverter: IValueRefConverter;
BindingEventRec: TBindingEventRec;
Options: TCreateOptions = [coNotifyOutput]): TBindingExpression; overload;
class function CreateUnmanagedBinding(
const InputScopes: array of IScope;
const BindExprStr: string;
const OutputScopes: array of IScope;
const OutputExpr: string;
const OutputConverter: IValueRefConverter;
Options: TCreateOptions = []): TBindingExpression; overload;
/// <summary>Helper function to create an expression</summary>
/// <remark>An expression is evaluated manually and the resulting value can be retrieved manually.</remark>
/// <param name="InputScopes">Array of input scopes used for lookups of the binding expression string</param>
/// <param name="BindExprStr">String expression to be evaluated by the binding engine</param>
/// <param name="BindingEventRec">Record containing binding expression events</param>
/// <returns>Returns the instantiated binding expression object</returns>
class function CreateExpression(
const InputScopes: array of IScope;
const BindExprStr: string;
BindingEventRec: TBindingEventRec): TBindingExpression; overload;
class function CreateExpression(
const InputScopes: array of IScope;
const BindExprStr: string): TBindingExpression; overload;
/// <summary>Removes the binding expression object supplied</summary>
/// <param name="Expression">Expression object to remove and delete from the engine</param>
/// <param name="Manager">Manager which the expression can be found. It will be looked up if unprovided</param>
class procedure RemoveBinding(const Expression: TBindingExpression; Manager: TBindingManager = nil); overload;
end;
implementation
uses
System.Bindings.ObjEval, System.Bindings.Consts;
{ TBindings }
class function TBindings.CreateExpression(const InputScopes: array of IScope;
const BindExprStr: string): TBindingExpression;
begin
Result := CreateExpression(InputScopes, BindExprStr, TBindingEventRec.Create);
end;
class function TBindings.CreateExpression(
const InputScopes: array of IScope;
const BindExprStr: string;
BindingEventRec: TBindingEventRec): TBindingExpression;
begin
Result := TBindingExpressionDefault.Create(nil);
try
Result.Source := BindExprStr;
Result.OnEvalErrorEvent := BindingEventRec.EvalErrorEvent;
Result.OnAssigningValueEvent := BindingEventRec.AssigningValueEvent;
Result.OnAssignedValueEvent := BindingEventRec.AssignedValueEvent;
Result.OnLocationUpdatedEvent := BindingEventRec.LocationUpdatedEvent;
Result.Compile(InputScopes);
except on E: Exception do
begin
Result.Free;
raise;
end;
end;
end;
class function TBindings.CreateManagedBinding(
const InputScopes: array of IScope; const BindExprStr: string;
const OutputScopes: array of IScope; const OutputExpr: string;
const OutputConverter: IValueRefConverter; Manager: TBindingManager;
Options: TCreateOptions): TBindingExpression;
begin
Result :=
CreateManagedBinding(InputScopes, BindExprStr, OutputScopes,
OutputExpr, OutputConverter, TBindingEventRec.Create, Manager, Options);
end;
class function TBindings.CreateManagedBinding(
const InputScopes: array of IScope;
const BindExprStr: string;
const OutputScopes: array of IScope;
const OutputExpr: string;
const OutputConverter: IValueRefConverter;
BindingEventRec: TBindingEventRec;
Manager: TBindingManager;
Options: TCreateOptions): TBindingExpression;
var
LOutputScope: IScope;
LScope: IScope;
begin
if Manager = nil then
Manager := TBindingManagerFactory.AppManager;
Result := Manager.AddExpr(BindExprStr);
try
Result.Outputs.Notify := coNotifyOutput in Options;
Result.OnEvalErrorEvent := BindingEventRec.EvalErrorEvent;
Result.OnAssigningValueEvent := BindingEventRec.AssigningValueEvent;
Result.OnAssignedValueEvent := BindingEventRec.AssignedValueEvent;
Result.OnLocationUpdatedEvent := BindingEventRec.LocationUpdatedEvent;
Result.Compile(InputScopes);
// Create nested scopes as needed
LOutputScope := nil;
for LScope in OutputScopes do
if LOutputScope = nil then
LOutputScope := LScope
else
LOutputScope := TNestedScope.Create(LOutputScope,
LScope);
if LOutputScope = nil then
raise EBindHelperException.Create(sNoOutputScopes);
Result.Outputs.Add(LOutputScope, OutputExpr);
Result.Outputs.ValueConverter := OutputConverter;
if coEvaluate in Options then
Result.Evaluate;
except on E: Exception do
begin
RemoveBinding(Result, Manager);
raise;
end;
end;
end;
class function TBindings.CreateUnmanagedBinding(
const InputScopes: array of IScope; const BindExprStr: string;
const OutputScopes: array of IScope; const OutputExpr: string;
const OutputConverter: IValueRefConverter;
Options: TCreateOptions): TBindingExpression;
begin
Result :=
CreateUnmanagedBinding(InputScopes, BindExprStr, OutputScopes, OutputExpr,
OutputConverter, TBindingEventRec.Create, Options);
end;
class function TBindings.CreateUnmanagedBinding(
const InputScopes: array of IScope;
const BindExprStr: string;
const OutputScopes: array of IScope;
const OutputExpr: string;
const OutputConverter: IValueRefConverter;
BindingEventRec: TBindingEventRec;
Options: TCreateOptions): TBindingExpression;
var
LOutputScope: IScope;
LScope: IScope;
begin
Result := TBindingExpressionDefault.Create(nil);
try
Result.Outputs.Notify := coNotifyOutput in Options;
Result.Source := BindExprStr;
Result.OnEvalErrorEvent := BindingEventRec.EvalErrorEvent;
Result.OnAssigningValueEvent := BindingEventRec.AssigningValueEvent;
Result.OnAssignedValueEvent := BindingEventRec.AssignedValueEvent;
Result.OnLocationUpdatedEvent := BindingEventRec.LocationUpdatedEvent;
Result.Compile(InputScopes);
// Create nested scopes as needed
LOutputScope := nil;
for LScope in OutputScopes do
if LOutputScope = nil then
LOutputScope := LScope
else
LOutputScope := TNestedScope.Create(LOutputScope,
LScope);
if LOutputScope = nil then
raise EBindHelperException.Create(sNoOutputScopes);
Result.Outputs.Add(LOutputScope, OutputExpr);
Result.Outputs.ValueConverter := OutputConverter;
if coEvaluate in Options then
Result.Evaluate;
except on E: Exception do
begin
Result.Free;
raise;
end;
end;
end;
class procedure TBindings.RemoveBinding(const Expression: TBindingExpression; Manager: TBindingManager);
var
DefBindExpr: TBindingExpressionDefault;
begin
if Assigned(Manager) then
Manager.Remove(Expression)
else
if Expression is TBindingExpressionDefault then
begin
DefBindExpr := TBindingExpressionDefault(Expression);
if Assigned(DefBindExpr.Manager) then
DefBindExpr.Manager.Remove(Expression)
else
DefBindExpr.Free;
end;
end;
class function TBindings.CreateMethodScope(const MethodName: string;
InvokableMethod: IInvokable): IScope;
begin
Result := TPairScope.Create(MethodName, InvokableMethod);
end;
class function TBindings.CreateAssociationScope(
Assocs: array of TBindingAssociation): IScope;
var
LScope: TDictionaryScope;
I: Integer;
begin
// add the mappings to a local and specific scope for the expression
LScope := TDictionaryScope.Create;
Result := LScope;
for I := 0 to Length(Assocs) - 1 do
begin
// and possibly remove them on TObjectWrapper.Destroy? (with ref count)
LScope.Map.Add(Assocs[I].ScriptObject, WrapObject(Assocs[I].RealObject));
end;
end;
class function TBindings.CreateMethodScope(AMethod: TArray<TPair<string, IInvokable>>): IScope;
var
LDictionaryScope: TDictionaryScope;
LPair: TPair<string, IInvokable>;
begin
LDictionaryScope := TDictionaryScope.Create;
Result := LDictionaryScope; // Will free if exception
for LPair in AMethod do
LDictionaryScope.Map.Add(LPair.Key, LPair.Value);
end;
class function TBindings.CreateNotifier(const AObject: TObject;
Manager: TBindingManager): IBindingNotifier;
begin
if Manager = nil then
Manager := TBindingManagerFactory.AppManager;
//Result := TBindingNotifierFactory.CreateNotifier(AObject, Manager);
Result := TBindingNotifier.Create(AObject, Manager);
end;
class procedure TBindings.Notify(Sender: TObject; PropName: string; Manager: TBindingManager);
var
Notifier: IBindingNotifier;
begin
Notifier := CreateNotifier(Sender, Manager);
Notifier.Notify(PropName);
end;
{ TBindingEventRec }
constructor TBindingEventRec.Create(AEvalErrorEvent: TBindingEvalErrorEvent);
begin
EvalErrorEvent := AEvalErrorEvent;
AssignedValueEvent := nil;
AssigningValueEvent := nil;
LocationUpdatedEvent := nil;
end;
constructor TBindingEventRec.Create(
AAssigningValueEvent: TBindingAssigningValueEvent);
begin
EvalErrorEvent := nil;
AssigningValueEvent := AAssigningValueEvent;
AssignedValueEvent := nil;
LocationUpdatedEvent := nil;
end;
constructor TBindingEventRec.Create(AEvalErrorEvent: TBindingEvalErrorEvent;
AAssigningValueEvent: TBindingAssigningValueEvent);
begin
EvalErrorEvent := AEvalErrorEvent;
AssigningValueEvent := AAssigningValueEvent;
AssignedValueEvent := nil;
LocationUpdatedEvent := nil;
end;
constructor TBindingEventRec.Create(AEvalErrorEvent: TBindingEvalErrorEvent;
AAssigningValueEvent: TBindingAssigningValueEvent;
AAssignedValueEvent: TBindingAssignedValueEvent);
begin
EvalErrorEvent := AEvalErrorEvent;
AssigningValueEvent := AAssigningValueEvent;
AssignedValueEvent := AAssignedValueEvent;
LocationUpdatedEvent := nil;
end;
constructor TBindingEventRec.Create(AEvalErrorEvent: TBindingEvalErrorEvent;
AAssigningValueEvent: TBindingAssigningValueEvent;
AAssignedValueEvent: TBindingAssignedValueEvent;
ALocationUpdatedEvent: TBindingLocationUpdatedEvent);
begin
EvalErrorEvent := AEvalErrorEvent;
AssigningValueEvent := AAssigningValueEvent;
AssignedValueEvent := AAssignedValueEvent;
LocationUpdatedEvent := ALocationUpdatedEvent;
end;
class function TBindingEventRec.Create: TBindingEventRec;
begin
Result.EvalErrorEvent := nil;
Result.AssigningValueEvent := nil;
Result.AssignedValueEvent := nil;
Result.LocationUpdatedEvent := nil;
end;
end.
|
unit ccMain;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, ComCtrls,
ExtCtrls, StdCtrls,
ccBaseFrame;
type
{ TMainForm }
TMainForm = class(TForm)
BtnCalculate: TButton;
BtnClose: TButton;
LblAccuracy: TLabel;
PageControl: TPageControl;
Panel1: TPanel;
PgPlanar: TTabSheet;
PgSpherical: TTabSheet;
PgCylindrical: TTabSheet;
PgLinePlane: TTabSheet;
PgCylPlane: TTabSheet;
Pg2Cyl: TTabSheet;
PgSeries: TTabSheet;
PgPNJunction: TTabSheet;
PgParallel: TTabSheet;
procedure BtnCloseClick(Sender: TObject);
procedure BtnCalculateClick(Sender: TObject);
procedure FormCloseQuery(Sender: TObject; var CanClose: boolean);
procedure FormCreate(Sender: TObject);
procedure PageControlChange(Sender: TObject);
private
{ private declarations }
procedure CalcCompleteHandler(Sender: TObject; AMsg: String; isOK: Boolean);
procedure Calculate;
function FindFrame(APage: TTabsheet): TBaseFrame;
procedure ReadFromIni;
procedure WriteToIni;
public
{ public declarations }
procedure BeforeRun;
end;
var
MainForm: TMainForm;
implementation
{$R *.lfm}
uses
IniFiles, ccGlobal,
ccPlanarCapFrame, ccSphericalCapFrame, ccCylindricalCapFrame,
ccLinePlaneCapFrame, ccCylPlaneCapFrame, cc2CylCapFrame,
ccSeriesCapFrame, ccParallelCapFrame, ccPNJunctionCapFrame;
function CreateIni: TCustomIniFile;
var
fn: String;
begin
fn := ChangeFileExt(GetAppConfigFile(false), '.ini');;
Result := TMemIniFile.Create(fn);
end;
{ TMainForm }
procedure TMainForm.BeforeRun;
begin
ReadFromIni;
end;
procedure TMainForm.BtnCloseClick(Sender: TObject);
begin
Close;
end;
procedure TMainForm.BtnCalculateClick(Sender: TObject);
begin
Calculate;
end;
procedure TMainForm.CalcCompleteHandler(Sender: TObject;
AMsg: String; isOK: Boolean);
begin
if isOK then
LblAccuracy.Font.Color := clWindowText else
LblAccuracy.Font.Color := clRed;
LblAccuracy.Caption := AMsg;
end;
procedure TMainForm.Calculate;
var
msg: String;
C: TWinControl;
frame: TBaseFrame;
begin
frame := FindFrame(PageControl.ActivePage);
if frame = nil then
exit;
frame.OnCalcComplete := @CalcCompleteHandler;
if frame.ValidData(msg, C) then begin
frame.Calculate;
if frame.ErrMsg <> '' then
MessageDlg(frame.ErrMsg, mtError,[mbOK], 0);
end
else begin
LblAccuracy.Caption := '';
if C <> nil then C.SetFocus;
MessageDlg(msg, mtError, [mbOK], 0);
end;
end;
function TMainForm.FindFrame(APage: TTabSheet): TBaseFrame;
var
i: Integer;
c: TControl;
begin
for i:=0 to APage.ControlCount-1 do begin
c := APage.Controls[i];
if c is TBaseFrame then begin
Result := TBaseFrame(c);
exit;
end;
end;
Result := nil;
end;
procedure TMainForm.FormCloseQuery(Sender: TObject; var CanClose: boolean);
begin
if CanClose then
try
WriteToIni;
except
end;
end;
procedure TMainForm.FormCreate(Sender: TObject);
var
x: Integer;
begin
x := lblAccuracy.Canvas.TextWidth('Line center-to-plane dist. (d)');
// before TPlanarCapFrame to avoid naming conflict
with TLinePlaneCapFrame.Create(self) do begin
EditLeft := x; // + 4*ControlDist;
Parent := PgLinePlane;
Align := alClient;
end;
with TPlanarCapFrame.Create(self) do begin
EditLeft := x + 4*ControlDist;
if Width > self.ClientWidth then
self.ClientWidth := Width;
Parent := PgPlanar;
Align := alClient;
end;
with TCylindricalCapFrame.Create(self) do begin
EditLeft := x + 4*ControlDist;
if Width > self.ClientWidth then
self.ClientWidth := Width;
Parent := PgCylindrical;
Align := alClient;
end;
// must be created after CylindricalCapFrame, otherwise naming conflict...
with TSphericalCapFrame.Create(self) do begin
EditLeft := x + 4*ControlDist;
if Width > self.ClientWidth then
self.ClientWidth := Width;
Parent := PgSpherical;
Align := alClient;
end;
// before TCylPlaneCapFrame !
with TTwoCylCapFrame.Create(self) do begin
EditLeft := x + 4*ControlDist;
if Width > self.ClientWidth then
self.ClientWidth := Width;
Parent := Pg2Cyl;
Align := alClient;
end;
with TCylPlaneCapFrame.Create(self) do begin
EditLeft := x + 4*ControlDist;
if Width > self.ClientWidth then
self.ClientWidth := Width;
Parent := PgCylPlane;
Align := alClient;
end;
with TSeriesCapFrame.Create(self) do begin
EditLeft := x + 4*ControlDist;
if Width > self.ClientWidth then
self.ClientWidth := Width;
Parent := PgSeries;
Align := alClient;
end;
with TParallelCapFrame.Create(self) do begin
EditLeft := x + 4*ControlDist;
if Width > self.ClientWidth then
self.ClientWidth := Width;
Parent := PgParallel;
Align := alClient;
end;
with TPNJunctionCapFrame.Create(self) do begin
EditLeft := x + 4*ControlDist;
if Width > self.ClientWidth then
self.ClientWidth := Width;
Parent := PgPNJunction;
Align := alClient;
end;
end;
procedure TMainForm.PageControlChange(Sender: TObject);
begin
LblAccuracy.Caption := '';
end;
procedure TMainForm.ReadFromIni;
var
ini: TCustomIniFile;
frame: TBaseFrame;
i: Integer;
s: String;
begin
ini := CreateIni;
try
PageControl.TabIndex := 0;
s := ini.ReadString('MainForm', 'Page', '');
if s <> '' then
for i:=0 to PageControl.PageCount-1 do
if s = PageControl.Pages[i].Caption then begin
PageControl.ActivePage := PageControl.Pages[i];
break;
end;
for i:=0 to PageControl.PageCount-1 do
begin
frame := FindFrame(PageControl.Pages[i]);
if frame <> nil then
frame.ReadfromIni(ini);
end;
finally
ini.Free;
end;
end;
procedure TMainForm.WriteToIni;
var
i: Integer;
ini: TCustomIniFile;
frame: TBaseFrame;
begin
ini := CreateIni;
try
ini.WriteString('MainForm', 'Page', PageControl.Activepage.Caption);
for i:=0 to PageControl.PageCount-1 do begin
frame := FindFrame(PageControl.Pages[i]);
if frame <> nil then
frame.WriteToIni(ini);
end;
if ini is TMemIniFile then ini.UpdateFile;
finally
ini.Free;
end;
end;
end.
|
(*************************************************************************
DESCRIPTION : GUI demo for CRC/HASH
REQUIREMENTS : D2-D7/D9-D10/D12/D17-D18/D25S
MEMORY USAGE : ---
DISPLAY MODUS : ---
REFERENCES : ---
REMARK : For Delphi2 ignore/remove all unsupported properties
Version Date Author Modification
------- -------- ------- ------------------------------------------
0.10 18.03.02 W.Ehrhardt Initial version
0.20 06.05.03 we with hints, Info button, icon, version info
0.30 13.09.03 we with Adler32, CRC64
0.50 03.11.03 we Speedups (V0.5 as CCH)
0.60 24.11.03 we SHA384/512, TMemo -> TRichEdit
0.61 24.11.03 we INI file
0.62 02.01.04 we SHA224
0.63 04.01.04 we Base64 display format
0.64 12.04.04 we with mem_util.hexstr
0.65 04.01.05 we recompiled to fix SHA512/384 bug
0.66 02.12.05 we Hex Upcase checkbox
0.67 11.12.05 we Whirlpool
0.68 22.01.06 we New hash unit
0.69 01.02.06 we RIPEMD-160
0.69a 12.02.06 we Output sequence: RIPEMD-160 then SHA1
0.70.0 28.02.06 we try blocks for load/save ini
0.71.0 14.03.06 we New layout, print button, URL label
0.71.1 15.03.06 we Self test button, un/check all
0.71.2 05.04.06 we CRC24
0.71.3 05.04.06 we Process command line files on start
0.71.4 22.01.07 we New release with fixed Whirlpool unit
0.71.5 10.02.07 we Without filesize
0.72.0 17.02.07 we Stop button, status bar
0.72.1 21.02.07 we MD4, eDonkey
0.72.2 21.02.07 we Export as text
0.72.3 21.02.07 we blkcnt: helper count to display update
0.72.4 23.02.07 we eDonkey AND eMule
0.72.5 30.09.07 we Bug fix SHA512/384 for file sizes above 512MB
0.72.6 15.11.07 we Replaced string with ansistring
0.73 21.07.09 we D12 fixes
0.74 11.03.12 we SHA512/224, SHA512/256, new homepage
0.75 11.08.15 we SHA3-224 .. SHA3-512, D17+D18
0.76 18.05.17 we Blake2s changes
0.77 07.19.17 we Blake2b if HAS_INT64
0.78 12.11.17 we Blake2b for all
0.78.1 12.06.18 we Lazarus adjustments
**************************************************************************)
(*-------------------------------------------------------------------------
(C) Copyright 2002-2018 Wolfgang Ehrhardt
This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from
the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software in
a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
----------------------------------------------------------------------------*)
unit chksum_l;
{$IFDEF FPC}
{$MODE Delphi}
{$ENDIF}
interface
{$i std.inc}
{$i-,j+}
uses
{$ifndef UNIT_SCOPE}
{$IFnDEF FPC}
shellapi, Windows,
{$ELSE}
LCLIntf, LCLType, LMessages,
{$ENDIF}
Messages, SysUtils, Classes, Forms, Dialogs, StdCtrls, Buttons, ExtCtrls,
ComCtrls, IniFiles, clipbrd, Controls, PrintersDlgs;
{$else}
winapi.Windows, winapi.Messages, system.SysUtils, System.UITypes,
system.Classes, vcl.Graphics, vcl.Controls, vcl.Forms, vcl.Dialogs,
vcl.StdCtrls, vcl.Buttons, vcl.ExtCtrls,
winapi.shellapi, vcl.ComCtrls, system.IniFiles, vcl.clipbrd;
{$endif}
const
Version = '';
XVersion = '0.78.1';
HomePage = 'http://wolfgang-ehrhardt.de/';
type
TCS_Main = class(TForm)
OpenDialog1: TOpenDialog;
Panel1: TPanel;
SB_OpenFile: TSpeedButton;
SB_Clear: TSpeedButton;
SB_Info: TSpeedButton;
CB_CRC16: TCheckBox;
CB_CRC32: TCheckBox;
CB_MD5: TCheckBox;
CB_SHA1: TCheckBox;
CB_SHA224: TCheckBox;
CB_SHA256: TCheckBox;
CB_Adler32: TCheckBox;
CB_CRC64: TCheckBox;
CB_SHA384: TCheckBox;
CB_SHA512: TCheckBox;
Memo1: TMemo;
RG_Format: TRadioGroup;
CB_Upcase: TCheckBox;
CB_Whirl: TCheckBox;
CB_RMD160: TCheckBox;
Panel2: TPanel;
SB_Print: TSpeedButton;
SB_UncheckAll: TSpeedButton;
PrintDialog: TPrintDialog;
GCH_Label: TLabel;
SB_Test: TSpeedButton;
SB_CheckAll: TSpeedButton;
CB_CRC24: TCheckBox;
SB_Stop: TSpeedButton;
StatusBar: TStatusBar;
CB_ED2K: TCheckBox;
CB_MD4: TCheckBox;
SB_Export: TSpeedButton;
SaveDialog1: TSaveDialog;
CB_SHA5_224: TCheckBox;
CB_SHA5_256: TCheckBox;
CB_SHA3_224: TCheckBox;
CB_SHA3_256: TCheckBox;
CB_SHA3_384: TCheckBox;
CB_SHA3_512: TCheckBox;
CB_Blaks224: TCheckBox;
CB_Blaks256: TCheckBox;
CB_Blakb384: TCheckBox;
CB_Blakb512: TCheckBox;
procedure SB_OpenFileClick(Sender: TObject);
{-Select and process files}
procedure SB_ClearClick(Sender: TObject);
{-Clear memo}
procedure SB_InfoClick(Sender: TObject);
{-Show info}
procedure MLAppend(const s: ansistring);
{-Append a line to file data result string}
procedure LoadIni;
{-read INI file}
procedure SaveIni;
{-write INI file}
procedure FormShow(Sender: TObject);
{-Load INI, set version label ...}
procedure FormClose(Sender: TObject; var Action: TCloseAction);
{-Save INI on exit}
procedure RG_FormatExit(Sender: TObject);
{-Update Base64 flag}
procedure SB_UncheckAllClick(Sender: TObject);
{-Uncheck all algorithm check boxes}
procedure SB_PrintClick(Sender: TObject);
{-Print calculated check sums}
procedure GCH_LabelClick(Sender: TObject);
{-Browse WE home page}
procedure SB_TestClick(Sender: TObject);
{-Self test of all check sum algorithms}
procedure SB_CheckAllClick(Sender: TObject);
{-Check all algorithm check boxes}
procedure SB_StopClick(Sender: TObject);
{-Stop a running calculation}
procedure SB_ExportClick(Sender: TObject);
{-Export as text file}
private
buf: array[1..$F000] of byte; {File read buffer}
FData: string; {Check sums of a file as string}
Base64: boolean; {use base64}
bailout: boolean;
Hashing: boolean;
public
procedure ProcessFiles(const FName: string; var blkcnt: longint);
{-Process one file}
procedure SB_SetAll(value: boolean);
{-Set all algorithm check boxes}
end;
var
CS_Main: TCS_Main;
implementation
uses
Mem_util,
CRC16, CRC24, CRC32, CRC64, ADLER32, ED2K, MD4,
Hash, MD5, RMD160, SHA1, SHA224, SHA256,
SHA384, SHA512, SHA5_224, SHA5_256, Whirl512,
SHA3_224, SHA3_256, SHA3_384, SHA3_512,
Blakb384, Blakb512,
Blaks224, Blaks256;
{$IFnDEF FPC}
{$R *.dfm}
{$ELSE}
{$R *.lfm}
{$ENDIF}
{---------------------------------------------------------------------------}
function HexString(const x: array of byte): ansistring;
{-HEX string from memory}
begin
Result := HexStr(@x, sizeof(x));
end;
{---------------------------------------------------------------------------}
procedure TCS_Main.MLAppend(const s: ansistring);
{-Append a line to file data result string}
begin
FData := FData+{$ifdef D12Plus} string {$endif}(s)+#13#10;
end;
{---------------------------------------------------------------------------}
procedure TCS_Main.ProcessFiles(const FName: string; var blkcnt: longint);
{-Process one file}
var
n: integer;
SHA1Context : THashContext; SHA1Digest : TSHA1Digest;
RMD160Context: THashContext; RMD160Digest : TRMD160Digest;
SHA224Context: THashContext; SHA256Context: THashContext;
SHA384Context: THashContext; SHA512Context: THashContext;
WhirlContext : THashContext; SHA256Digest : TSHA256Digest;
SHA224Digest : TSHA224Digest; SHA384Digest : TSHA384Digest;
SHA512Digest : TSHA512Digest; WhirlDigest : TWhirlDigest;
MD5Context : THashContext; MD5Digest : TMD5Digest;
MD4Context : THashContext; MD4Digest : TMD4Digest;
ED2KContext : TED2KContext; ED2KResults : TED2KResult;
SHA5_224Context: THashContext; SHA5_224Digest: TSHA5_224Digest;
SHA5_256Context: THashContext; SHA5_256Digest: TSHA5_256Digest;
SHA3_224Context: THashContext; SHA3_224Digest: TSHA3_224Digest;
SHA3_256Context: THashContext; SHA3_256Digest: TSHA3_256Digest;
SHA3_384Context: THashContext; SHA3_384Digest: TSHA3_384Digest;
SHA3_512Context: THashContext; SHA3_512Digest: TSHA3_512Digest;
Blaks_224Context: THashContext; Blaks_224Digest: TBlake2S_224Digest;
Blaks_256Context: THashContext; Blaks_256Digest: TBlake2S_256Digest;
Blakb_384Context: THashContext; Blakb_384Digest: TBlake2B_384Digest;
Blakb_512Context: THashContext; Blakb_512Digest: TBlake2B_512Digest;
CRC16: word;
CRC24: longint; pgpsig: TPGPDigest;
CRC32: longint;
CRC64: TCRC64;
Adler: longint;
f: file;
procedure Mwriteln(const s: ansistring);
{-Writeln a line to richedit}
begin
MLAppend(s);
MLAppend('');
Memo1.Text := Memo1.Text+#10+{$ifdef D12Plus} string {$endif}(s);
end;
function RB(A: longint): longint;
{-rotate byte of longint}
begin
RB := (A shr 24) or ((A shr 8) and $FF00) or ((A shl 8) and $FF0000) or (A shl 24);
end;
begin
StatusBar.SimpleText := Fname;
MLAppend({$ifdef D12Plus} ansistring {$endif}(FName));
filemode := 0;
blkcnt := 0;
if not FileExists(FName) then begin
Mwriteln('*** file not found');
exit;
end;
assignfile(f,FName);
system.reset(f,1);
if IOresult<>0 then begin
Mwriteln('*** could not be opened');
exit;
end;
SHA1Init(SHA1Context);
RMD160Init(RMD160Context);
SHA224Init(SHA224Context);
SHA256Init(SHA256Context);
SHA384Init(SHA384Context);
SHA512Init(SHA512Context);
Whirl_Init(WhirlContext);
SHA5_224Init(SHA5_224Context);
SHA5_256Init(SHA5_256Context);
SHA3_224Init(SHA3_224Context);
SHA3_256Init(SHA3_256Context);
SHA3_384Init(SHA3_384Context);
SHA3_512Init(SHA3_512Context);
Blaks224Init(Blaks_224Context);
Blaks256Init(Blaks_256Context);
Blakb384Init(Blakb_384Context);
Blakb512Init(Blakb_512Context);
ED2K_Init(ED2KContext);
MD4Init(MD4Context);
MD5Init(MD5Context);
Adler32Init(adler);
CRC16Init(CRC16);
CRC24Init(CRC24);
CRC32Init(CRC32);
CRC64Init(CRC64);
repeat
if bailout then exit;
blockread(f,buf,sizeof(buf),n);
if IOResult<>0 then begin
Mwriteln('*** read error');
break;
end;
if n<>0 then begin
Application.ProcessMessages;
inc(blkcnt);
if CB_SHA1.Checked then SHA1Update(SHA1Context,@buf,n);
if CB_RMD160.Checked then RMD160Update(RMD160Context,@buf,n);
if CB_SHA224.Checked then SHA224Update(SHA224Context,@buf,n);
if CB_SHA256.Checked then SHA256Update(SHA256Context,@buf,n);
if CB_SHA384.Checked then SHA384Update(SHA384Context,@buf,n);
if CB_SHA512.Checked then SHA512Update(SHA512Context,@buf,n);
if CB_SHA5_224.Checked then SHA5_224Update(SHA5_224Context,@buf,n);
if CB_SHA5_256.Checked then SHA5_256Update(SHA5_256Context,@buf,n);
if CB_SHA3_224.Checked then SHA3_224Update(SHA3_224Context,@buf,n);
if CB_SHA3_256.Checked then SHA3_256Update(SHA3_256Context,@buf,n);
if CB_SHA3_384.Checked then SHA3_384Update(SHA3_384Context,@buf,n);
if CB_SHA3_512.Checked then SHA3_512Update(SHA3_512Context,@buf,n);
if CB_Blaks224.Checked then Blaks224Update(Blaks_224Context,@buf,n);
if CB_Blaks256.Checked then Blaks256Update(Blaks_256Context,@buf,n);
if CB_Blakb384.Checked then Blakb384Update(Blakb_384Context,@buf,n);
if CB_Blakb512.Checked then Blakb512Update(Blakb_512Context,@buf,n);
if CB_Whirl.Checked then Whirl_Update(WhirlContext,@buf,n);
if CB_ED2K.Checked then ED2K_Update(ED2KContext,@buf,n);
if CB_MD4.Checked then MD4Update(MD4Context,@buf,n);
if CB_MD5.Checked then MD5Update(MD5Context,@buf,n);
if CB_Adler32.Checked then Adler32Update(adler,@buf,n);
if CB_CRC16.Checked then CRC16Update(CRC16,@buf,n);
if CB_CRC24.Checked then CRC24Update(CRC24,@buf,n);
if CB_CRC32.Checked then CRC32Update(CRC32,@buf,n);
if CB_CRC64.Checked then CRC64Update(CRC64,@buf,n);
end;
until n<>sizeof(buf);
closefile(f);
IOResult;
SHA1Final(SHA1Context,SHA1Digest);
RMD160Final(RMD160Context,RMD160Digest);
SHA224Final(SHA224Context,SHA224Digest);
SHA256Final(SHA256Context,SHA256Digest);
SHA384Final(SHA384Context,SHA384Digest);
SHA512Final(SHA512Context,SHA512Digest);
SHA5_224Final(SHA5_224Context,SHA5_224Digest);
SHA5_256Final(SHA5_256Context,SHA5_256Digest);
SHA3_224Final(SHA3_224Context,SHA3_224Digest);
SHA3_256Final(SHA3_256Context,SHA3_256Digest);
SHA3_384Final(SHA3_384Context,SHA3_384Digest);
SHA3_512Final(SHA3_512Context,SHA3_512Digest);
Blaks224Final(Blaks_224Context,Blaks_224Digest);
Blaks256Final(Blaks_256Context,Blaks_256Digest);
Blakb384Final(Blakb_384Context,Blakb_384Digest);
Blakb512Final(Blakb_512Context,Blakb_512Digest);
Whirl_Final(WhirlContext,WhirlDigest);
ED2K_Final(ED2KContext,ED2KResults);
MD4Final(MD4Context,MD4Digest);
MD5Final(MD5Context,MD5Digest);
Adler32Final(adler);
CRC16Final(CRC16);
CRC24Final(CRC24); Long2PGP(CRC24, pgpsig);
CRC32Final(CRC32);
CRC64Final(CRC64);
if Base64 then begin
if CB_CRC16.Checked then MLAppend(' CRC16: '+Base64Str(@CRC16 , sizeof(CRC16 )));
if CB_CRC24.Checked then MLAppend(' CRC24: '+Base64Str(@pgpsig , sizeof(pgpsig )));
if CB_CRC32.Checked then MLAppend(' CRC32: '+Base64Str(@CRC32 , sizeof(CRC32 )));
if CB_Adler32.Checked then MLAppend(' Adler32: '+Base64Str(@adler , sizeof(adler )));
if CB_CRC64.Checked then MLAppend(' CRC64: '+Base64Str(@CRC64 , sizeof(CRC64 )));
if CB_ED2K.Checked then begin
MLAppend(' eDonkey: '+Base64Str(@ED2KResults.eDonkey, sizeof(ED2KResults.eDonkey)));
if ED2KResults.differ then MLAppend(' eMule: '+Base64Str(@ED2KResults.eMule, sizeof(ED2KResults.eMule)));
end;
if CB_MD4.Checked then MLAppend(' MD4: '+Base64Str(@MD4Digest , sizeof(MD4Digest )));
if CB_MD5.Checked then MLAppend(' MD5: '+Base64Str(@MD5Digest , sizeof(MD5Digest )));
if CB_RMD160.Checked then MLAppend(' RIPEMD160: '+Base64Str(@RMD160Digest, sizeof(RMD160Digest)));
if CB_SHA1.Checked then MLAppend(' SHA1: '+Base64Str(@SHA1Digest , sizeof(SHA1Digest )));
if CB_SHA224.Checked then MLAppend(' SHA224: '+Base64Str(@SHA224Digest, sizeof(SHA224Digest)));
if CB_SHA256.Checked then MLAppend(' SHA256: '+Base64Str(@SHA256Digest, sizeof(SHA256Digest)));
if CB_SHA384.Checked then MLAppend(' SHA384: '+Base64Str(@SHA384Digest, sizeof(SHA384Digest)));
if CB_SHA512.Checked then MLAppend(' SHA512: '+Base64Str(@SHA512Digest, sizeof(SHA512Digest)));
if CB_SHA5_224.Checked then MLAppend(' SHA512/224: '+Base64Str(@SHA5_224Digest, sizeof(SHA5_224Digest)));
if CB_SHA5_256.Checked then MLAppend(' SHA512/256: '+Base64Str(@SHA5_256Digest, sizeof(SHA5_256Digest)));
if CB_Whirl.Checked then MLAppend(' Whirlpool: '+Base64Str(@WhirlDigest, sizeof(WhirlDigest)));
if CB_SHA3_224.Checked then MLAppend(' SHA3-224: '+Base64Str(@SHA3_224Digest, sizeof(SHA3_224Digest)));
if CB_SHA3_256.Checked then MLAppend(' SHA3-256: '+Base64Str(@SHA3_256Digest, sizeof(SHA3_256Digest)));
if CB_SHA3_384.Checked then MLAppend(' SHA3-384: '+Base64Str(@SHA3_384Digest, sizeof(SHA3_384Digest)));
if CB_SHA3_512.Checked then MLAppend(' SHA3-512: '+Base64Str(@SHA3_512Digest, sizeof(SHA3_512Digest)));
if CB_Blaks224.Checked then MLAppend('Blake2s-224: '+Base64Str(@Blaks_224Digest, sizeof(Blaks_224Digest)));
if CB_Blaks256.Checked then MLAppend('Blake2s-256: '+Base64Str(@Blaks_256Digest, sizeof(Blaks_256Digest)));
if CB_Blakb384.Checked then MLAppend('Blake2b-384: '+Base64Str(@Blakb_384Digest, sizeof(Blakb_384Digest)));
if CB_Blakb512.Checked then MLAppend('Blake2b-512: '+Base64Str(@Blakb_512Digest, sizeof(Blakb_512Digest)));
end
else begin
{swap bytes: display shall look like word / longint}
{but HexStr constructs LSB first}
HexUpper := CB_Upcase.checked;
CRC16 := swap(CRC16);
CRC32 := RB(CRC32);
Adler := RB(Adler);
if CB_CRC16.Checked then MLAppend(' CRC16: '+HexStr(@CRC16,2));
if CB_CRC24.Checked then MLAppend(' CRC24: '+HexStr(@pgpsig,3));
if CB_CRC32.Checked then MLAppend(' CRC32: '+HexStr(@CRC32,4));
if CB_Adler32.Checked then MLAppend(' Adler32: '+HexStr(@adler,4));
if CB_CRC64.Checked then MLAppend(' CRC64: '+HexStr(@CRC64,8));
if CB_ED2K.Checked then begin
MLAppend(' eDonkey: '+HexString(ED2KResults.eDonkey));
if ED2KResults.differ then MLAppend(' eMule: '+HexString(ED2KResults.eMule));
end;
if CB_MD4.Checked then MLAppend(' MD4: '+HexString(MD4Digest));
if CB_MD5.Checked then MLAppend(' MD5: '+HexString(MD5Digest));
if CB_RMD160.Checked then MLAppend(' RIPEMD160: '+HexString(RMD160Digest));
if CB_SHA1.Checked then MLAppend(' SHA1: '+HexString(SHA1Digest));
if CB_SHA224.Checked then MLAppend(' SHA224: '+HexString(SHA224Digest));
if CB_SHA256.Checked then MLAppend(' SHA256: '+HexString(SHA256Digest));
if CB_SHA384.Checked then MLAppend(' SHA384: '+HexString(SHA384Digest));
if CB_SHA512.Checked then MLAppend(' SHA512: '+HexString(SHA512Digest));
if CB_SHA5_224.Checked then MLAppend(' SHA512/224: '+HexString(SHA5_224Digest));
if CB_SHA5_256.Checked then MLAppend(' SHA512/256: '+HexString(SHA5_256Digest));
if CB_Whirl.Checked then MLAppend(' Whirlpool: '+HexString(WhirlDigest));
if CB_SHA3_224.Checked then MLAppend(' SHA3-224: '+HexString(SHA3_224Digest));
if CB_SHA3_256.Checked then MLAppend(' SHA3-256: '+HexString(SHA3_256Digest));
if CB_SHA3_384.Checked then MLAppend(' SHA3-384: '+HexString(SHA3_384Digest));
if CB_SHA3_512.Checked then MLAppend(' SHA3-512: '+HexString(SHA3_512Digest));
if CB_Blaks224.Checked then MLAppend('Blake2s-224: '+HexString(Blaks_224Digest));
if CB_Blaks256.Checked then MLAppend('Blake2s-256: '+HexString(Blaks_256Digest));
if CB_Blakb384.Checked then MLAppend('Blake2b-384: '+HexString(Blakb_384Digest));
if CB_Blakb512.Checked then MLAppend('Blake2b-512: '+HexString(Blakb_512Digest));
end;
MLAppend('');
end;
{---------------------------------------------------------------------------}
procedure TCS_Main.SB_OpenFileClick(Sender: TObject);
{-Select and process files}
var
i: integer;
blkcnt: longint;
begin
if Hashing then begin
bailout := true;
exit;
end;
if Opendialog1.Execute then begin
Hashing := true;
bailout := false;
SB_Openfile.Enabled := false;
SB_Clear.Enabled := false;
SB_Print.Enabled := false;
SB_Test.Enabled := false;
SB_Stop.Enabled := true;
Screen.Cursor := crHourGlass;
Application.ProcessMessages;
Base64 := RG_Format.ItemIndex=1;
Memo1.Lines.BeginUpdate;
for i:=0 to Opendialog1.Files.Count-1 do begin
FData := '';
ProcessFiles(Opendialog1.Files[i],blkcnt);
if bailout then break;
{Add results for one file to display text}
Memo1.Text := Memo1.Text + {$ifdef D12Plus} string {$endif}(FData);
if (i and 15 = 0) or (blkcnt>7) then begin
{Update display every 16th file or after a file with more than 500KB}
memo1.Lines.EndUpdate;
// Memo1.SetFocus;
// Memo1.SelStart := length(memo1.text);
memo1.Lines.BeginUpdate;
end;
Application.ProcessMessages;
end;
StatusBar.SimpleText := '';
SB_Openfile.Enabled := true;
SB_Clear.Enabled := true;
SB_Print.Enabled := true;
SB_Test.Enabled := true;
SB_Stop.Enabled := false;
Hashing := false;
if bailout then begin
Memo1.Text := Memo1.Text + {$ifdef D12Plus} string {$endif}(FData) + #13#10'** Stopped **'#13#10;
end;
memo1.Lines.EndUpdate;
Screen.Cursor := crDefault;
{caret to end of text}
Memo1.SetFocus;
Memo1.SelStart := length(memo1.text);
Application.ProcessMessages;
end;
end;
{---------------------------------------------------------------------------}
procedure TCS_Main.SB_ClearClick(Sender: TObject);
{-Clear memo}
begin
Memo1.Clear;
end;
{---------------------------------------------------------------------------}
procedure TCS_Main.SB_InfoClick(Sender: TObject);
{-Show info}
begin
MessageDlg( 'LazGCH Version '+XVersion+' (c) 2002-2018 W.Ehrhardt'+#13+#10
+'Open source freeware demo for Hash/CRC units'+#13+#10
+HomePage+#13+#10+''+#13+#10
+'To calculate hash und CRC check sums:'+#13+#10+''+#13+#10
+'1. Select the display format: Hex (Upcase is optional) or Base64,'+#13+#10
+'2. Check the items you want to calculate,'+#13+#10
+'3. Press the calculator button, select the files to process, and press open. '+
'Check sums will be calculated and displayed in the memo area. '+
'Note that multiple files can be selected. '+
'Processed files are displayed in the status bar. '+
'Calculations can be aborted with the stop button.'+#13#10
+'4. Check sums can be printed with the print button, '+
'saved to a text file with the export button, '+
'or selected/copied to the clipboard with standard Windows keys.',
mtInformation, [mbOK], 0);
end;
{---------------------------------------------------------------------------}
procedure TCS_Main.LoadIni;
{-read INI file}
var
IniFile : TInifile;
begin
Inifile := TInifile.Create(ChangeFileExt(ParamStr(0), '.INI'));
try
CB_Adler32.Checked := IniFile.ReadBool('Options','Adler32' , true);
CB_CRC16.Checked := IniFile.ReadBool('Options','CRC16' , true);
CB_CRC24.Checked := IniFile.ReadBool('Options','CRC24' , true);
CB_CRC32.Checked := IniFile.ReadBool('Options','CRC32' , true);
CB_CRC64.Checked := IniFile.ReadBool('Options','CRC64' , true);
CB_ED2K.Checked := IniFile.ReadBool('Options','eDonkey' , true);
CB_MD4.Checked := IniFile.ReadBool('Options','MD4' , true);
CB_MD5.Checked := IniFile.ReadBool('Options','MD5' , true);
CB_RMD160.Checked := IniFile.ReadBool('Options','RIPEMD160', true);
CB_SHA1.Checked := IniFile.ReadBool('Options','SHA1' , true);
CB_SHA224.Checked := IniFile.ReadBool('Options','SHA224' , true);
CB_SHA256.Checked := IniFile.ReadBool('Options','SHA256' , true);
CB_SHA384.Checked := IniFile.ReadBool('Options','SHA384' , true);
CB_SHA5_224.Checked:= IniFile.ReadBool('Options','SHA512/224', true);
CB_SHA5_256.Checked:= IniFile.ReadBool('Options','SHA512/256', true);
CB_SHA512.Checked := IniFile.ReadBool('Options','SHA512' , true);
CB_Whirl.Checked := IniFile.ReadBool('Options','Whirlpool', true);
CB_SHA3_224.Checked:= IniFile.ReadBool('Options','SHA3-224', true);
CB_SHA3_256.Checked:= IniFile.ReadBool('Options','SHA3-256', true);
CB_SHA3_384.Checked:= IniFile.ReadBool('Options','SHA3-384', true);
CB_SHA3_512.Checked:= IniFile.ReadBool('Options','SHA3-512', true);
CB_Blaks224.Checked:= IniFile.ReadBool('Options','Blake2s-224', true);
CB_Blaks256.Checked:= IniFile.ReadBool('Options','Blake2s-256', true);
CB_Blakb384.Checked:= IniFile.ReadBool('Options','Blake2b-384', true);
CB_Blakb512.Checked:= IniFile.ReadBool('Options','Blake2b-512', true);
Base64 := IniFile.ReadBool('Options','Base64' , false);
CB_Upcase.Checked := IniFile.ReadBool('Options','Upcase' , false);
RG_Format.ItemIndex := ord(Base64);
finally
IniFile.Free;
end;
end;
{---------------------------------------------------------------------------}
procedure TCS_Main.SaveIni;
{-write INI file}
var
IniFile : TInifile;
begin
Inifile := TInifile.Create(ChangeFileExt(ParamStr(0), '.INI'));
try
try
IniFile.EraseSection('Options');
IniFile.WriteBool('Options','Adler32' , CB_Adler32.Checked);
IniFile.WriteBool('Options','CRC16' , CB_CRC16.Checked );
IniFile.WriteBool('Options','CRC24' , CB_CRC24.Checked );
IniFile.WriteBool('Options','CRC32' , CB_CRC32.Checked );
IniFile.WriteBool('Options','CRC64' , CB_CRC64.Checked );
IniFile.WriteBool('Options','eDonkey' , CB_ED2K.Checked );
IniFile.WriteBool('Options','MD4' , CB_MD4.Checked );
IniFile.WriteBool('Options','MD5' , CB_MD5.Checked );
IniFile.WriteBool('Options','RIPEMD160', CB_RMD160.Checked );
IniFile.WriteBool('Options','SHA1' , CB_SHA1.Checked );
IniFile.WriteBool('Options','SHA224' , CB_SHA224.Checked );
IniFile.WriteBool('Options','SHA256' , CB_SHA256.Checked );
IniFile.WriteBool('Options','SHA384' , CB_SHA384.Checked );
IniFile.WriteBool('Options','SHA512' , CB_SHA512.Checked );
IniFile.WriteBool('Options','SHA512/224', CB_SHA5_224.Checked );
IniFile.WriteBool('Options','SHA512/256', CB_SHA5_256.Checked );
IniFile.WriteBool('Options','Blake2s-224', CB_Blaks224.Checked );
IniFile.WriteBool('Options','Blake2s-256', CB_Blaks256.Checked );
IniFile.WriteBool('Options','Blake2b-384', CB_Blakb384.Checked );
IniFile.WriteBool('Options','Blake2b-512', CB_Blakb512.Checked );
IniFile.WriteBool('Options','Whirlpool', CB_Whirl.Checked );
IniFile.WriteBool('Options','SHA3-224', CB_SHA3_224.Checked );
IniFile.WriteBool('Options','SHA3-256', CB_SHA3_256.Checked );
IniFile.WriteBool('Options','SHA3-384', CB_SHA3_384.Checked );
IniFile.WriteBool('Options','SHA3-512', CB_SHA3_512.Checked );
IniFile.WriteBool('Options','Upcase' , CB_Upcase.Checked );
IniFile.WriteBool('Options','Base64' , Base64 );
except
MessageDlg('Cannot save to GCH.INI', mtError, [mbOK], 0);
end;
finally
IniFile.Free;
end;
end;
{---------------------------------------------------------------------------}
procedure TCS_Main.FormShow(Sender: TObject);
{-Load INI, set version label ...}
const
first: boolean = true;
var
i: integer;
blkcnt: longint;
begin
if first then begin
GCH_Label.Caption := 'LazGCH';
GCH_Label.Hint := HomePage;
first := false;
Hashing := false;
bailout := false;
LoadIni;
{process command line files (no wild cards)}
for i:=1 to ParamCount do begin
if FileExists(Paramstr(i)) then ProcessFiles(Paramstr(i), blkcnt);
end;
Memo1.Text := {$ifdef D12Plus} string {$endif}(FData);
Memo1.SetFocus;
Memo1.SelStart := length(memo1.text);
StatusBar.SimpleText := '';
end;
end;
{---------------------------------------------------------------------------}
procedure TCS_Main.FormClose(Sender: TObject; var Action: TCloseAction);
{-Save INI on exit}
begin
SaveIni;
end;
{---------------------------------------------------------------------------}
procedure TCS_Main.RG_FormatExit(Sender: TObject);
{-Update Base64 flag}
begin
Base64 := RG_Format.ItemIndex=1;
end;
{---------------------------------------------------------------------------}
procedure TCS_Main.SB_SetAll(value: boolean);
{-Set all algorithm check boxes}
begin
CB_Adler32.Checked := value;
CB_CRC16.Checked := value;
CB_CRC24.Checked := value;
CB_CRC32.Checked := value;
CB_CRC64.Checked := value;
CB_ED2K.Checked := value;
CB_MD4.Checked := value;
CB_MD5.Checked := value;
CB_RMD160.Checked := value;
CB_SHA1.Checked := value;
CB_SHA224.Checked := value;
CB_SHA256.Checked := value;
CB_SHA384.Checked := value;
CB_SHA512.Checked := value;
CB_SHA5_224.Checked:= value;
CB_SHA5_256.Checked:= value;
CB_Whirl.Checked := value;
CB_SHA3_224.Checked:= value;
CB_SHA3_256.Checked:= value;
CB_SHA3_384.Checked:= value;
CB_SHA3_512.Checked:= value;
CB_Blaks224.Checked:= value;
CB_Blaks256.Checked:= value;
CB_Blakb384.Checked:= value;
CB_Blakb512.Checked:= value;
end;
{---------------------------------------------------------------------------}
procedure TCS_Main.SB_UncheckAllClick(Sender: TObject);
{-Uncheck all algorithm check boxes}
begin
SB_SetAll(false);
end;
{---------------------------------------------------------------------------}
procedure TCS_Main.SB_CheckAllClick(Sender: TObject);
{-Check all algorithm check boxes}
begin
SB_SetAll(true);
end;
{---------------------------------------------------------------------------}
procedure TCS_Main.SB_PrintClick(Sender: TObject);
{-Print calculated check sums}
begin
if PrintDialog.Execute then begin
Application.ProcessMessages;
Memo1.Append('GCH file checksums');
end;
end;
{---------------------------------------------------------------------------}
procedure TCS_Main.GCH_LabelClick(Sender: TObject);
{-Browse WE home page}
begin
OpenDocument(HomePage); { *Converted from ShellExecute* }
end;
{---------------------------------------------------------------------------}
procedure TCS_Main.SB_TestClick(Sender: TObject);
{-Self test of all check sum algorithms}
procedure report(const aname: ansistring; passed: boolean);
const
res: array[boolean] of ansistring = ('failed', 'passed');
begin
memo1.Lines.Append({$ifdef D12Plus} string {$endif}('Self test ' + aname + ' : '+res[passed]));
end;
begin
Memo1.Lines.Append('------------------------------');
report('CRC16 ', CRC16SelfTest );
report('CRC24 ', CRC24SelfTest );
report('CRC32 ', CRC32SelfTest );
report('Adler32 ', Adler32SelfTest );
report('CRC64 ', CRC64SelfTest );
report('eDonkey ', ED2K_SelfTest );
report('MD4 ', MD4SelfTest );
report('MD5 ', MD5SelfTest );
report('RIPEMD160 ', RMD160SelfTest );
report('SHA1 ', SHA1SelfTest );
report('SHA224 ', SHA224SelfTest );
report('SHA256 ', SHA256SelfTest );
report('SHA384 ', SHA384SelfTest );
report('SHA512 ', SHA512SelfTest );
report('SHA512/224 ', SHA5_224SelfTest);
report('SHA512/256 ', SHA5_256SelfTest);
report('Whirlpool ', Whirl_SelfTest );
report('SHA3-224 ', SHA3_224SelfTest);
report('SHA3-256 ', SHA3_256SelfTest);
report('SHA3-384 ', SHA3_384SelfTest);
report('SHA3-512 ', SHA3_512SelfTest);
report('Blake2s-224', Blaks224SelfTest);
report('Blake2s-256', Blaks256SelfTest);
report('Blake2b-384', Blakb384SelfTest);
report('Blake2b-512', Blakb512SelfTest);
Memo1.Lines.Append('------------------------------');
end;
{---------------------------------------------------------------------------}
procedure TCS_Main.SB_StopClick(Sender: TObject);
{-Stop a running calculation}
begin
if Hashing then begin
bailout := true;
exit;
end;
end;
{---------------------------------------------------------------------------}
procedure TCS_Main.SB_ExportClick(Sender: TObject);
{-Export as text file}
begin
if SaveDialog1.Execute then begin
Memo1.Lines.SaveToFile(SaveDialog1.Filename);
end;
end;
end.
|
unit uOpenFIleDialog;
interface
uses
{$IF CompilerVersion > 22}
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls,
{$ELSE}
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls,
{$IFEND}
CNClrLib.Control.EnumTypes, CNClrLib.Control.Base, CNClrLib.Component.OpenFileDialog;
type
TForm18 = class(TForm)
Button1: TButton;
CnOpenFileDialog1: TCnOpenFileDialog;
procedure Button1Click(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
var
Form18: TForm18;
implementation
{$R *.dfm}
uses CNClrLib.Core;
procedure TForm18.Button1Click(Sender: TObject);
var
fileContent,
filePath: String;
fileStream: _Stream;
reader: _StreamReader;
begin
CnOpenFileDialog1.InitialDirectory := 'c:\\';
CnOpenFileDialog1.Filter := 'txt files (*.txt)|*.txt|All files (*.*)|*.*';
CnOpenFileDialog1.FilterIndex := 2;
CnOpenFileDialog1.RestoreDirectory := True;
if CnOpenFileDialog1.ShowDialog = TDialogResult.drOK then
begin
//Get the path of specified file
filePath := CnOpenFileDialog1.FileName;
//Read the contents of the file into a stream
fileStream := CnOpenFileDialog1.OpenFile();
reader := CoStreamReader.CreateInstance(fileStream);
try
fileContent := reader.ReadToEnd();
finally
reader.Close;
reader.Dispose;
reader := nil;
end;
TClrMessageBox.Show(fileContent, 'File Content at path: ' + filePath, TMessageBoxButtons.mbbsOK);
end;
end;
end.
|
unit ufphttphelper;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils, fphttpclient, URIParser;
{ TFPHTTPClient override }
type
TFPHTTPClient = class(fphttpclient.TFPHTTPClient)
protected
FOnDataSent: TDataEvent;
procedure SendRequest(const AMethod: string; URI: TURI); override;
public
property OnDataSent: TDataEvent read FOnDataSent write FOnDataSent;
end;
implementation
uses base64;
function CopyFromStreamToStream(Source, Destination: TStream; Count: int64;
Callback: TDataEvent): int64;
var
Buffer: Pointer;
BufferSize, i: longint;
MaxCount: Int64;
const
MaxSize = $20000;
begin
Result := 0;
MaxCount := Count;
if Count = 0 then
Source.Position := 0; // This WILL fail for non-seekable streams...
BufferSize := MaxSize;
if (Count > 0) and (Count < BufferSize) then
BufferSize := Count; // do not allocate more than needed
GetMem(Buffer, BufferSize);
try
if Count = 0 then
repeat
i := Source.Read(buffer^, BufferSize);
if i > 0 then
Destination.WriteBuffer(buffer^, i);
Inc(Result, i);
until i < BufferSize
else
while Count > 0 do
begin
if Count > BufferSize then
i := BufferSize
else
i := Count;
Source.ReadBuffer(buffer^, i);
Destination.WriteBuffer(buffer^, i);
Dec(Count, i);
Inc(Result, i);
if Assigned(Callback) then
Callback(nil, MaxCount, Result);
end;
finally
FreeMem(Buffer);
end;
end;
procedure TFPHTTPClient.SendRequest(const AMethod: string; URI: TURI);
const
CRLF = #13#10;
var
UN, PW, S, L: string;
I: integer;
begin
S := Uppercase(AMethod) + ' ' + GetServerURL(URI) + ' ' + 'HTTP/' + HTTPVersion + CRLF;
UN := URI.Username;
PW := URI.Password;
if (UserName <> '') then
begin
UN := UserName;
PW := Password;
end;
if (UN <> '') then
begin
S := S + 'Authorization: Basic ' + EncodeStringBase64(UN + ':' + PW) + CRLF;
I := IndexOfHeader('Authorization');
if I <> -1 then
RequestHeaders.Delete(i);
end;
S := S + 'Host: ' + URI.Host;
if (URI.Port <> 0) then
S := S + ':' + IntToStr(URI.Port);
S := S + CRLF;
if Assigned(RequestBody) and (IndexOfHeader('Content-Length') = -1) then
AddHeader('Content-Length', IntToStr(RequestBody.Size));
for I := 0 to RequestHeaders.Count - 1 do
begin
l := RequestHeaders[i];
if AllowHeader(L) then
S := S + L + CRLF;
end;
S := S + CRLF;
Socket.WriteBuffer(S[1], Length(S));
if Assigned(RequestBody) then
CopyFromStreamToStream(RequestBody, Socket, RequestBody.Size, Self.OnDataSent);
//Socket.CopyFrom(RequestBody, RequestBody.Size);
end;
end.
|
unit UFrmClientInfoEdit;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, uFrmModal, cxGraphics, cxLookAndFeels, cxLookAndFeelPainters, Menus,
ActnList, StdCtrls, cxButtons, ExtCtrls, cxControls, cxContainer, cxEdit,
dxSkinsCore, dxSkinsDefaultPainters, cxTextEdit, cxMemo, cxMaskEdit,
cxDropDownEdit, cxLookupEdit, cxDBLookupEdit, cxDBLookupComboBox,
DBClient, DB;
type
TFrmClientInfoEdit = class(TFrmModal)
lbl1: TLabel;
lbl2: TLabel;
lbl3: TLabel;
lbl4: TLabel;
lbl5: TLabel;
lbl6: TLabel;
lbl7: TLabel;
lbl8: TLabel;
lbl9: TLabel;
lbl10: TLabel;
edtClientID: TcxTextEdit;
edtClientName: TcxTextEdit;
edtClientPYM: TcxTextEdit;
edtLinkMan: TcxTextEdit;
edtPhone: TcxTextEdit;
edtAddress: TcxTextEdit;
edtPostCode: TcxTextEdit;
edtEmail: TcxTextEdit;
cbbClassGuid: TcxLookupComboBox;
dsClientClass: TDataSource;
edtRemark: TcxTextEdit;
procedure btnOkClick(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure edtClientNamePropertiesChange(Sender: TObject);
private
FDataSet: TClientDataSet;
FAction: string;
function BeforeExecute: Boolean;
function DoExecute: Boolean;
public
class function ShowClassInfoEdit(DataSet, ClientClass: TClientDataSet;
AAction: string): Boolean;
end;
var
FrmClientInfoEdit: TFrmClientInfoEdit;
implementation
uses UMsgBox, UDBAccess, UPubFunLib;
{$R *.dfm}
{ TFrmClientInfoEdit }
function TFrmClientInfoEdit.BeforeExecute: Boolean;
const
cCheckIDExistsSQL = 'select * from ClientInfo where ClientID=''%s''';
var
lStrSql: string;
iResult: Integer;
begin
Result := False;
if Trim(edtClientID.Text) = '' then
begin
edtClientID.SetFocus;
ShowMsg('客户编号不能为空，请输入！');
Exit;
end;
if Trim(edtClientName.Text) = '' then
begin
edtClientName.SetFocus;
ShowMsg('客户名称不能为空，请输入！');
Exit;
end;
if cbbClassGuid.ItemIndex = -1 then
begin
cbbClassGuid.SetFocus;
ShowMsg('客户类型不能为空，请选择！');
Exit;
end;
if FAction = 'Append' then
lStrSql := Format(cCheckIDExistsSQL, [Trim(edtClientID.Text)])
else
begin
lStrSql := Format(cCheckIDExistsSQL + ' and Guid <> ''%s''',
[Trim(edtClientID.Text), FDataSet.FindField('Guid').AsString]);
end;
iResult := DBAccess.DataSetIsEmpty(lStrSql);
if iResult = -1 then
begin
ShowMsg('判断客户编码是否重复失败！');
Exit;
end;
if iResult = 0 then
begin
ShowMsg('当前客户编码已经存在，请重新输入！');
Exit;
end;
Result := True;
end;
procedure TFrmClientInfoEdit.btnOkClick(Sender: TObject);
begin
if not BeforeExecute then Exit;
if not DoExecute then Exit;
ModalResult := mrOk;
end;
function TFrmClientInfoEdit.DoExecute: Boolean;
const
InsertClientInfoSQL = 'insert into ClientInfo(Guid, ClientID, ClientName, '+
' ClientPYM, ClassGuid, LinkMan, Phone, Address, PostCode, Email, Remark, Deleted) '+
' values(''%s'', ''%s'', ''%s'', ''%s'', ''%s'', ''%s'', ''%s'', ''%s'', '+
' ''%s'', ''%s'', ''%s'',0);';
UpdateClientInfoSQL = 'update ClientInfo set ClientID=''%s'', '+
' ClientName=''%s'', ClientPYM=''%s'', ClassGuid=''%s'', LinkMan=''%s'', '+
' Phone=''%s'', Address=''%s'', PostCode=''%s'', Email=''%s'', '+
' Remark=''%s'' where Guid=''%s''';
var
lStrSql: string;
lGuid, lClientID, lClientName, lClientPYM, lClassGuid,
lLinkMan, lPhone, lAddress, lPostCode, lEmail, lRemark: string;
begin
lClientID := Trim(edtClientID.Text);
lClientName := Trim(edtClientName.Text);
lClientPYM := Trim(edtClientPYM.Text);
lClassGuid := cbbClassGuid.EditValue;
lLinkMan := Trim(edtLinkMan.Text);
lPhone := Trim(edtPhone.Text);
lAddress := Trim(edtAddress.Text);
lPostCode := Trim(edtPostCode.Text);
lEmail := Trim(edtEmail.Text);
lRemark := Trim(edtRemark.Text);
if FAction = 'Append' then
begin
lGuid := CreateGuid;
lStrSql := Format(InsertClientInfoSQL, [lGuid, lClientID, lClientName,
lClientPYM, lClassGuid, lLinkMan, lPhone, lAddress, lPostCode,
lEmail, lRemark]);
end else begin
lGuid := FDataSet.FindField('Guid').AsString;
lStrSql := Format(UpdateClientInfoSQL, [lClientID, lClientName,
lClientPYM, lClassGuid, lLinkMan, lPhone, lAddress, lPostCode,
lEmail, lRemark, lGuid]);
end;
Result := DBAccess.ExecuteSQL(lStrSql);
if not Result then
ShowMsg('客户信息保存失败！');
end;
procedure TFrmClientInfoEdit.edtClientNamePropertiesChange(Sender: TObject);
begin
inherited;
edtClientPYM.Text := GetPYM(Trim(edtClientName.Text));
end;
procedure TFrmClientInfoEdit.FormShow(Sender: TObject);
begin
inherited;
if FAction = 'Edit' then
begin
with FDataSet do
begin
edtClientID.Text := FindField('ClientID').AsString;
edtClientName.Text := FindField('ClientName').AsString;
edtClientPYM.Text := FindField('ClientPYM').AsString;
cbbClassGuid.EditValue := FindField('ClassGuid').AsString;
edtLinkMan.Text := FindField('LinkMan').AsString;
edtPhone.Text := FindField('Phone').AsString;
edtAddress.Text := FindField('Address').AsString;
edtPostCode.Text := FindField('PostCode').AsString;
edtEmail.Text := FindField('Email').AsString;
edtRemark.Text := FindField('Remark').AsString;
end;
end;
end;
class function TFrmClientInfoEdit.ShowClassInfoEdit(DataSet,
ClientClass: TClientDataSet; AAction: string): Boolean;
begin
with TFrmClientInfoEdit.Create(nil) do
begin
try
FDataSet := DataSet;
FAction := AAction;
dsClientClass.DataSet := ClientClass;
Result := ShowModal = mrOk;
finally
Free;
end;
end;
end;
end.
|
unit testtsortunit;
interface
uses Math, Sysutils, Ap, tsort;
function TestSort(Silent : Boolean):Boolean;
function testtsortunit_test_silent():Boolean;
function testtsortunit_test():Boolean;
implementation
procedure Unset2D(var A : TComplex2DArray);forward;
procedure Unset1D(var A : TReal1DArray);forward;
procedure Unset1DI(var A : TInteger1DArray);forward;
procedure TestSortResults(const ASorted : TReal1DArray;
const P1 : TInteger1DArray;
const P2 : TInteger1DArray;
const AOriginal : TReal1DArray;
N : AlglibInteger;
var WasErrors : Boolean);forward;
(*************************************************************************
Testing tag sort
*************************************************************************)
function TestSort(Silent : Boolean):Boolean;
var
WasErrors : Boolean;
N : AlglibInteger;
I : AlglibInteger;
Pass : AlglibInteger;
PassCount : AlglibInteger;
MaxN : AlglibInteger;
A : TReal1DArray;
A0 : TReal1DArray;
A2 : TReal1DArray;
P1 : TInteger1DArray;
P2 : TInteger1DArray;
begin
WasErrors := False;
MaxN := 100;
PassCount := 10;
//
// Test
//
N:=1;
while N<=MaxN do
begin
Pass:=1;
while Pass<=PassCount do
begin
//
// (probably) distinct sort
//
Unset1DI(P1);
Unset1DI(P2);
SetLength(A, N-1+1);
SetLength(A0, N-1+1);
I:=0;
while I<=N-1 do
begin
A[I] := 2*RandomReal-1;
A0[I] := A[I];
Inc(I);
end;
TagSort(A0, N, P1, P2);
TestSortResults(A0, P1, P2, A, N, WasErrors);
//
// non-distinct sort
//
Unset1DI(P1);
Unset1DI(P2);
SetLength(A, N-1+1);
SetLength(A0, N-1+1);
I:=0;
while I<=N-1 do
begin
A[I] := I div 2;
A0[I] := A[I];
Inc(I);
end;
TagSort(A0, N, P1, P2);
TestSortResults(A0, P1, P2, A, N, WasErrors);
Inc(Pass);
end;
Inc(N);
end;
//
// report
//
if not Silent then
begin
Write(Format('TESTING TAGSORT'#13#10'',[]));
if WasErrors then
begin
Write(Format('TEST FAILED'#13#10'',[]));
end
else
begin
Write(Format('TEST PASSED'#13#10'',[]));
end;
Write(Format(''#13#10''#13#10'',[]));
end;
Result := not WasErrors;
end;
(*************************************************************************
Unsets 2D array.
*************************************************************************)
procedure Unset2D(var A : TComplex2DArray);
begin
SetLength(A, 0+1, 0+1);
A[0,0] := C_Complex(2*RandomReal-1);
end;
(*************************************************************************
Unsets 1D array.
*************************************************************************)
procedure Unset1D(var A : TReal1DArray);
begin
SetLength(A, 0+1);
A[0] := 2*RandomReal-1;
end;
(*************************************************************************
Unsets 1D array.
*************************************************************************)
procedure Unset1DI(var A : TInteger1DArray);
begin
SetLength(A, 0+1);
A[0] := RandomInteger(3)-1;
end;
procedure TestSortResults(const ASorted : TReal1DArray;
const P1 : TInteger1DArray;
const P2 : TInteger1DArray;
const AOriginal : TReal1DArray;
N : AlglibInteger;
var WasErrors : Boolean);
var
I : AlglibInteger;
A2 : TReal1DArray;
T : Double;
F : TInteger1DArray;
begin
SetLength(A2, N-1+1);
SetLength(F, N-1+1);
//
// is set ordered?
//
I:=0;
while I<=N-2 do
begin
WasErrors := WasErrors or AP_FP_Greater(ASorted[I],ASorted[I+1]);
Inc(I);
end;
//
// P1 correctness
//
I:=0;
while I<=N-1 do
begin
WasErrors := WasErrors or AP_FP_Neq(ASorted[I],AOriginal[P1[I]]);
Inc(I);
end;
I:=0;
while I<=N-1 do
begin
F[I] := 0;
Inc(I);
end;
I:=0;
while I<=N-1 do
begin
F[P1[I]] := F[P1[I]]+1;
Inc(I);
end;
I:=0;
while I<=N-1 do
begin
WasErrors := WasErrors or (F[I]<>1);
Inc(I);
end;
//
// P2 correctness
//
I:=0;
while I<=N-1 do
begin
A2[I] := AOriginal[I];
Inc(I);
end;
I:=0;
while I<=N-1 do
begin
if P2[I]<>I then
begin
T := A2[I];
A2[I] := A2[P2[I]];
A2[P2[I]] := T;
end;
Inc(I);
end;
I:=0;
while I<=N-1 do
begin
WasErrors := WasErrors or AP_FP_Neq(ASorted[I],A2[I]);
Inc(I);
end;
end;
(*************************************************************************
Silent unit test
*************************************************************************)
function testtsortunit_test_silent():Boolean;
begin
Result := TestSort(True);
end;
(*************************************************************************
Unit test
*************************************************************************)
function testtsortunit_test():Boolean;
begin
Result := TestSort(False);
end;
end. |
(******************************************************************************)
(* This file conteins definitions, data sructures and the implementations of *)
(* a two channels 2681 serial device. *)
(* Designed to be interfaced with MC68k Class. *)
(* *)
(******************************************************************************)
unit Uart;
(***********************************************************)
(**) interface (**)
(***********************************************************)
uses fifo4bits,ictrl;
const RxRDY = $01;
FFULL = $02;
TxRDY = $04;
TxEMT = $08;
nRxRDY= $FE;
nFFULL= $FD;
nTxRDY= $FB;
nTxEMT= $F7;
rdyC = $400;
SaveFileName='.\sav\scn2681.sav';
type ReadFun = function:byte of object;
WriteFun = procedure (data:byte) of object;
channel=record //Defines the structure of a 2681's channel.
MRP:byte; //indicates which MR is accessed reading from addr 0x0
MR1:byte; //[(1)RxRTS control|(1)RxINT select|(1)Error mode|(2)Parity mode|(1)parity type|(2)Bits per Character]
MR2:byte; //[(2)Channel mode|(1)TxRTS control|(1)CTS Enavle Tx|(4)bitstop length]
SR:byte; //Status Register
RHR:byte; //Rx Holding Register
THR:byte; //Tx Holding Register
CSR:byte; //Clock Set Register
CR:byte; //Command Register
TxEnable,RxEnable:boolean;
Data_available:boolean;
NoUseButItsAddress:byte;
RxFIFO:fifo; //Ingoing buffer.
end;
type uart2681=class //2681 serial device class definition.
(***********************************************************)
(**) private (**)
(***********************************************************)
A,B : channel; //Channel A, B
ACR : byte; //Aux Control Register
IMR : byte; //Interrupt Mask Register
IPCR : byte; //Input Port Change Register
ISR : byte; //Interrupt Status Register
CT : word; //Counter Timer Lower value
counter:word;
BRG : byte; //
OPCR : byte; //Output Port Configuration Register
CounterStart : boolean; //Status register.
LastCH : byte;
NoUseButItsAddress:byte;
ToBecomeReadyTx: longword;
ToBecomeReadyRx: longword;
intc : ^IntrCtrl;
ReadHandlingRoutines : array[0..$f] of ReadFun;
WriteHandlingRoutines : array[0..$f] of WriteFun;
function ModeRegisterxARead:byte;
function StatusRegisterARead:byte;
function BRGRead:byte;
function RxHoldingARegister:byte;
function InputPortChangeRegister:byte;
function InterruptStatusRegister:byte;
function CounterTimerUpperValue:byte;
function CounterTimerLowerValue:byte;
function ModeRegisterxBRead:byte;
function StatusRegisterBRead:byte;
function RxHoldingBRegister:byte;
function reservedRead:byte;
function startcounter:byte;
function Stopcounter:byte;
procedure reservedWrite(data:byte);
procedure ModeRegisterxAWrite(data:byte);
procedure ClockSelectRegisterA(data:byte);
procedure CommandRegisterA(data:byte);
procedure TxHoldingARegister(data:byte);
procedure AuxControlRegister(data:byte);
procedure InterruptMaskRegister(data:byte);
procedure CounterTimerUpperValueSet(data:byte);
procedure CounterTimerLowerValueSet(data:byte);
procedure ModeRegisterxBWrite(data:byte);
procedure ClockSelectRegisterB(data:byte);
procedure CommandRegisterB(data:byte);
procedure TxHoldingBRegister(data:byte);
procedure OutputPortConfigurationRegister(data:byte);
procedure SetOutputPortBitsCommand(data:byte);
procedure ResetOutputPortBitsCommand(data:byte);
(***********************************************************)
(**) protected (**)
(***********************************************************)
(***********************************************************)
(**) public (**)
(***********************************************************)
imr_copy :byte;
timedivisor:longword;
procedure reset ; //Resets the status of the selected channel.
procedure interfaceWrite8 (address:word;data:byte) ; //Interface to CPU Routine. Simulates a CPU reading from selected Address.
procedure SendBreakConsole;
procedure SendBreakAux;
function InterfaceRead8 (address:word): byte; //Interface to CPU Routine. Simulates a CPU writing from selected Address.
function UserReadConsole (var data:byte): boolean; //Interface to others Routine. Simulates a user reading from A channel fifo (console).
function UserWriteConsole (data:byte): boolean; //Interface to others Routine. Simulates a user writing from A channel fifo (console).
function UserReadAux (var data:byte): boolean; //Interface to others Routine. Simulates a user reading from B channel fifo (aux aux).
function UserWriteAux (data:byte): boolean; //Interface to others Routine. Simulates a user writing from B channel fifo (aux port).
procedure tick;
procedure intrq;
procedure switchTxRDY;
constructor uart2681; //Default Constructor for this class.
procedure StatusSave;
procedure StatusRestore;
procedure SetInterruptController(ic:pointer);
function sra:byte;
end;
(******************************************************************************)
(**) (**)
(**) implementation (**)
(**) (**)
(******************************************************************************)
(******************************************************************************)
function uart2681.sra:byte;
begin
result:=a.SR;
end;
(******************************************************************************)
procedure uart2681.reset;
begin
a.MRP:=0; a.MR1:=0; a.MR2:=0; a.SR:=0; a.RHR:=0; a.THR:=0; a.CSR:=0; a.CR:=0;
a.RxFIFO.clear;
b.MRP:=0; b.MR1:=0; b.MR2:=0; b.SR:=0; b.RHR:=0; b.THR:=0; b.CSR:=0; b.CR:=0;
b.RxFIFO.clear;
ReadHandlingRoutines[$0] := self.ModeRegisterxARead;
ReadHandlingRoutines[$1] := self.StatusRegisterARead;
ReadHandlingRoutines[$2] := self.reservedread;
ReadHandlingRoutines[$3] := self.RxHoldingARegister;
ReadHandlingRoutines[$4] := self.InputPortChangeRegister;
ReadHandlingRoutines[$5] := self.InterruptStatusRegister;
ReadHandlingRoutines[$6] := self.CounterTimerUpperValue;
ReadHandlingRoutines[$7] := self.CounterTimerLowerValue;
ReadHandlingRoutines[$8] := self.ModeRegisterxBRead;
ReadHandlingRoutines[$9] := self.StatusRegisterBRead;
ReadHandlingRoutines[$A] := self.reservedread;
ReadHandlingRoutines[$B] := self.RxHoldingBRegister;
ReadHandlingRoutines[$C] := self.reservedread;
ReadHandlingRoutines[$D] := self.reservedread;
ReadHandlingRoutines[$E] := self.startcounter;
ReadHandlingRoutines[$F] := self.stopcounter;
WriteHandlingRoutines[$0]:= self.ModeRegisterxAWrite;
WriteHandlingRoutines[$1]:= self.ClockSelectRegisterA;
WriteHandlingRoutines[$2]:= self.CommandRegisterA;
WriteHandlingRoutines[$3]:= self.TxHoldingARegister;
WriteHandlingRoutines[$4]:= self.AuxControlRegister;
WriteHandlingRoutines[$5]:= self.InterruptMaskRegister;
WriteHandlingRoutines[$6]:= self.CounterTimerUpperValueSet;
WriteHandlingRoutines[$7]:= self.CounterTimerLowerValueSet;
WriteHandlingRoutines[$8]:= self.ModeRegisterxBWrite;
WriteHandlingRoutines[$9]:= self.ClockSelectRegisterB;
WriteHandlingRoutines[$A]:= self.CommandRegisterB;
WriteHandlingRoutines[$B]:= self.TxHoldingBRegister;
WriteHandlingRoutines[$C]:= self.reservedWrite;
WriteHandlingRoutines[$D]:= self.OutputPortConfigurationRegister;
WriteHandlingRoutines[$E]:= self.SetOutputPortBitsCommand;
WriteHandlingRoutines[$F]:= self.ResetOutputPortBitsCommand;
end;
(******************************************************************************)
procedure uart2681.interfaceWrite8(address:word;data:byte);
begin
WriteHandlingRoutines[address](data);
end;
(******************************************************************************)
function uart2681.InterfaceRead8(address:word):byte;
begin
result:=ReadHandlingRoutines[address];
end;
(******************************************************************************)
function uart2681.UserwriteConsole(data:byte):boolean;
begin
if not a.RxFIFO.full then begin
a.RxFIFO.put(data);a.SR:=a.SR and nFFULL;
if a.RxFIFO.full then a.SR:=a.SR or FFULL;
//else a.SR:=a.SR and nFFULL;
result:=true;
end
else begin
if a.MR1 and $40<>0 then isr:=isr or 2;
result:=false;
end;
if a.MR1 and $40=0 then isr:=isr or 2;
a.SR:=a.SR or RxRDY;
end;
(******************************************************************************)
function uart2681.UserreadConsole(var data:byte):boolean;
begin
result:=a.Data_available;
data:=a.THR;
a.SR:= a.SR or TxRDY;
a.sr:= a.sr or TXEMT;
a.Data_available:=false;
end;
(******************************************************************************)
procedure uart2681.intrq;
begin
end;
(******************************************************************************)
function uart2681.UserwriteAux(data:byte):boolean;
begin
end;
(******************************************************************************)
function uart2681.UserreadAux(var data:byte):boolean;
begin
b.SR:= b.SR or 4;
end;
(******************************************************************************)
constructor uart2681.uart2681;
begin
a.RxFIFO:=fifo.Create;
b.RxFIFO:=fifo.Create;
reset;
end;
(******************************************************************************)
procedure uart2681.SendBreakConsole;
begin
end;
(******************************************************************************)
procedure uart2681.SendBreakAux;
begin
end;
(******************************************************************************)
procedure uart2681.SetInterruptController(ic:pointer);
begin
intc:=ic;
end;
(******************************************************************************)
procedure uart2681.StatusSave;
var f:file;
function addrcalc(addr1,addr2:pointer):longword; assembler;
asm
push ebx
mov eax,addr1
mov ebx,addr2
sub eax,ebx
pop ebx
end;
begin
assignfile(f,SaveFileName);
rewrite(f,1);
blockwrite(f,a.MRP,addrcalc(@a.NoUseButItsAddress,@a.mrp)); //channel A
blockwrite(f,b.MRP,addrcalc(@b.NoUseButItsAddress,@b.mrp)); //channel B
blockwrite(f,acr,addrcalc(@NoUseButItsAddress,@ACR)); //others
closefile(f);
end;
(******************************************************************************)
procedure uart2681.StatusRestore;
var f:file;
function addrcalc(addr1,addr2:pointer):longword; assembler;
asm
push ebx
mov eax,addr1
mov ebx,addr2
sub eax,ebx
pop ebx
end;
begin
assignfile(f,SaveFileName);
system.Reset(f,1);
blockread (f,a.MRP,addrcalc(@a.NoUseButItsAddress,@a.mrp)); //11); //channel A
blockread (f,b.MRP,addrcalc(@b.NoUseButItsAddress,@b.mrp));//11); //channel B
blockread (f,acr,addrcalc(@NoUseButItsAddress,@ACR)); //12); //others
closefile(f);
end;
(******************************************************************************)
procedure uart2681.tick;
begin
if tobecomereadytx>0 then begin
dec(tobecomereadytx);
if tobecomereadytx=0 then a.SR:=a.SR and nTxRDY;
end;
if tobecomereadyRx>0 then begin
dec(tobecomereadyrx);
if tobecomereadyrx=0 then a.sr:=a.sr or RxRDY;
end;
timedivisor:=(timedivisor +1) and $ff;
if timedivisor=0 then begin
//a.SR:= a.SR or TxRDY;
//a.sr:= a.sr or TXEMT;
if counterstart then begin
dec(counter);
if counter=0 then begin
counter:=ct;
isr:=isr or $8;
end;
end;
end;
if isr and imr <>0 then
intc^.irq($1d);
isr:=0;
imr_copy:=imr;
end;
(******************************************************************************)
procedure uart2681.switchTxRDY;
begin
{ a.SR:=a.SR or RxRDY;
isr:=1; }
end;
(******************************************************************************)
function uart2681.ModeRegisterxARead;
begin
if a.MRP=0 then begin
result:=a.MR1;
a.MRP:=1;
end
else result:=a.MR2;
end;
(******************************************************************************)
function uart2681.StatusRegisterARead;
begin
result:=a.SR;
end;
(******************************************************************************)
function uart2681.BRGRead;
begin
result:=$ff;
end;
(******************************************************************************)
function uart2681.RxHoldingARegister;
begin
a.SR:=a.SR and nFFULL; // dopo una lettura sicuramente la fifo non è + piena.
a.sr:=a.sr or RxRDY; // lo metto a 1 in previsione che ci siano altri caratteri in attesa.
a.RHR:=a.RxFIFO.get; //leggo il carattere dalla fifo
if a.RxFIFO.empty then a.SR:=a.SR and nRxRDY; //se dopo la lettura la fifo risultasse vuota metto il ricevitore in NON pronto
result:=a.RHR; //returns read caracter
end;
(******************************************************************************)
function uart2681.InputPortChangeRegister;
begin
result:=IPCR;
ipcr:=ipcr and $0f; //When reading occurs IL clears IPCR[7:4]
isr:=isr and $7f; //and ISR[7]
end;
(******************************************************************************)
function uart2681.InterruptStatusRegister;
begin
result:=ISR;
end;
(******************************************************************************)
function uart2681.CounterTimerUpperValue;
begin
result:=hi(ct);
end;
(******************************************************************************)
function uart2681.CounterTimerLowerValue;
begin
result:=lo(ct);
end;
(******************************************************************************)
function uart2681.ModeRegisterxBRead;
begin
if b.MRP=0 then begin
result:=b.MR1;
b.MRP:=1;
end
else result:=b.MR2;
end;
(******************************************************************************)
function uart2681.StatusRegisterBRead;
begin
result:=b.SR;
end;
(******************************************************************************)
function uart2681.RxHoldingBRegister;
begin
b.SR:=b.SR and nFFULL; // dopo una lettura sicuramente la fifo non è + piena.
b.sr:=b.sr or RxRDY; // lo metto a 1 in previsione che ci siano altri caratteri in attesa.
b.RHR:=b.RxFIFO.get; //leggo il carattere dalla fifo
if b.RxFIFO.empty then b.SR:=b.SR and nRxRDY; //se dopo la lettura la fifo risultasse vuota metto il ricevitore in NON pronto
result:=b.RHR; //returns read caracter
end;
(******************************************************************************)
function uart2681.reservedRead;
begin
result:=$ff;
end;
(******************************************************************************)
function uart2681.startcounter;
begin
result:=$ff;
counterStart:=true;
counter:=ct;
end;
(******************************************************************************)
function uart2681.Stopcounter;
begin
result:=$ff;
counterStart:=false;
end;
(******************************************************************************)
procedure uart2681.ModeRegisterxAWrite(data:byte);
begin
if a.MRP=0 then begin
a.MR1:=data;
a.MRP:=1;
end
else a.MR2:=data;
end;
(******************************************************************************)
procedure uart2681.reservedWrite(data:byte);
begin
end;
(******************************************************************************)
procedure uart2681.ClockSelectRegisterA(data:byte);
begin
a.CSR:=data;
end;
(******************************************************************************)
procedure uart2681.CommandRegisterA(data:byte);
begin
if data and 1<>0 then Begin //enable Rx
a.RxEnable:=true;
end;
if data and 2<>0 then Begin //disable Rx
a.RxEnable:=false;
end;
if data and 4<>0 then Begin //enable Tx
a.TxEnable:=true;
end;
if data and 8<>0 then Begin //disable Tx
a.TxEnable:=false;
end;
case data and $70 of
$10:begin
a.MRP:=0;
end;
$20:begin
a.RxFIFO.clear;
end;
$30:begin
end;
$40:begin
a.SR:=a.SR and $0f;
end;
$50:begin
isr:=isr and $fb;
end;
$60:begin // elettrical status command Force TxD(A/B) pin low. Not emulated
end;
$70:begin // elettrical status command Force TxD(A/B) pin high. Not emulated
end;
end;
end;
(******************************************************************************)
procedure uart2681.TxHoldingARegister(data:byte);
begin
if a.TxEnable then begin
a.THR:=data;
a.sr:=a.sr and nTxEMT;
a.SR:=a.SR and nTxRDY;
a.Data_available:=true;
end;
end;
(******************************************************************************)
procedure uart2681.AuxControlRegister(data:byte);
begin
acr:=data;
end;
(******************************************************************************)
procedure uart2681.InterruptMaskRegister(data:byte);
begin
imr:=data;
end;
(******************************************************************************)
procedure uart2681.CounterTimerUpperValueSet(data:byte);
type x=array[0..1]of byte;
var a:^x;
begin
a:=@ct;
a^[1]:=data;
end;
(******************************************************************************)
procedure uart2681.CounterTimerLowerValueSet(data:byte);
var a:^byte;
begin
a:=@ct;
a^:=data;
end;
(******************************************************************************)
procedure uart2681.ModeRegisterxBWrite(data:byte);
begin
if b.MRP=0 then begin
b.MR1:=data;
b.MRP:=1;
end
else b.MR2:=data;
end;
(******************************************************************************)
procedure uart2681.ClockSelectRegisterB(data:byte);
begin
b.CSR:=data;
end;
(******************************************************************************)
procedure uart2681.CommandRegisterB(data:byte);
begin
if data and 1<>0 then Begin //enable Rx
b.RxEnable:=true;
end;
if data and 2<>0 then Begin //disable Rx
b.RxEnable:=false;
end;
if data and 4<>0 then Begin //enable Tx
b.TxEnable:=true;
end;
if data and 8<>0 then Begin //disable Tx
b.TxEnable:=false;
end;
case data and $70 of
$10:begin
b.MRP:=0;
end;
$20:begin
b.RxFIFO.clear;
end;
$30:begin
end;
$40:begin
b.SR:=b.SR and $0f;
end;
$50:begin
isr:=isr and $fb;
end;
$60:begin // elettrical status command Force TxD(A/B) pin low. Not emulated
end;
$70:begin // elettrical status command Force TxD(A/B) pin high. Not emulated
end;
end;
end;
(******************************************************************************)
procedure uart2681.TxHoldingBRegister(data:byte);
begin
if b.TxEnable then begin
b.THR:=data;
b.sr:=b.sr and nTxEMT;
b.SR:=b.SR and nTxRDY;
b.Data_available:=true;
end;
end;
(******************************************************************************)
procedure uart2681.OutputPortConfigurationRegister(data:byte);
begin
end;
(******************************************************************************)
procedure uart2681.SetOutputPortBitsCommand(data:byte);
begin
end;
(******************************************************************************)
procedure uart2681.ResetOutputPortBitsCommand(data:byte);
begin
end;
end.
|
unit BackgroundFrm;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, Buttons, ExtCtrls, FlexProps, FlexUtils, RXSpin, cxGraphics, cxLookAndFeels, cxLookAndFeelPainters,
Vcl.Menus, dxSkinsCore, dxSkinOffice2010Silver, cxControls, cxContainer, cxEdit, cxTextEdit, cxMaskEdit, cxSpinEdit,
cxCheckBox, cxGroupBox, cxButtons;
type
TBackgroundOptionsForm = class(TForm)
chBrushEnabled: TcxCheckBox;
chPictureEnabled: TcxCheckBox;
gbPicture: TcxGroupBox;
chLeft: TcxCheckBox;
chTop: TcxCheckBox;
chWidth: TcxCheckBox;
chHeight: TcxCheckBox;
chCenterHoriz: TcxCheckBox;
chCenterVert: TcxCheckBox;
chAlignRight: TcxCheckBox;
chAlignBottom: TcxCheckBox;
chStretchHoriz: TcxCheckBox;
chStretchVert: TcxCheckBox;
chScaledSize: TcxCheckBox;
bbOk: TcxButton;
bbCancel: TcxButton;
sedLeft: TcxSpinEdit;
sedTop: TcxSpinEdit;
sedWidth: TcxSpinEdit;
sedHeight: TcxSpinEdit;
procedure FormShow(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
procedure chClick(Sender: TObject);
private
FBackgroundOptions: TBackgroundOptionsProp;
procedure CheckTools;
end;
var
BackgroundOptionsForm: TBackgroundOptionsForm;
implementation
{$R *.dfm}
procedure TBackgroundOptionsForm.FormShow(Sender: TObject);
var Options: TBackgroundPictureOptions;
begin
if (Tag <> 0) and (TObject(Tag) is TBackgroundOptionsProp) then
FBackgroundOptions := TBackgroundOptionsProp(Tag);
if Assigned(FBackgroundOptions) then with FBackgroundOptions do begin
chBrushEnabled.Checked := BrushEnabled;
chPictureEnabled.Checked := PictureEnabled;
Options := PictureOptions;
chLeft.Checked := bpOffsetLeft in Options;
sedLeft.Value := Left / PixelScaleFactor;
chTop.Checked := bpOffsetTop in Options;
sedTop.Value := Top / PixelScaleFactor;
chWidth.Checked := bpNewWidth in Options;
sedWidth.Value := Width / PixelScaleFactor;
chHeight.Checked := bpNewHeight in Options;
sedHeight.Value := Height / PixelScaleFactor;
chCenterHoriz.Checked := bpCenterHoriz in Options;
chCenterVert.Checked := bpCenterVert in Options;
chAlignRight.Checked := bpAlignRight in Options;
chAlignBottom.Checked := bpAlignBottom in Options;
chStretchHoriz.Checked := bpStretchHoriz in Options;
chStretchVert.Checked := bpStretchVert in Options;
chScaledSize.Checked := bpScaledSize in Options;
CheckTools;
end;
end;
procedure TBackgroundOptionsForm.FormClose(Sender: TObject; var Action: TCloseAction);
var Recording: boolean;
Options: TBackgroundPictureOptions;
begin
if (ModalResult <> mrOk) or not Assigned(FBackgroundOptions) then exit;
with FBackgroundOptions do begin
Recording := Assigned(Owner.History) and
Assigned(Owner.History.BeginAction(TPropHistoryGroup, FBackgroundOptions));
try
BrushEnabled := chBrushEnabled.Checked;
PictureEnabled := chPictureEnabled.Checked;
Options := [];
if chLeft.Checked then Include(Options, bpOffsetLeft);
Left := Round(sedLeft.Value * PixelScaleFactor);
if chTop.Checked then Include(Options, bpOffsetTop);
Top := Round(sedTop.Value * PixelScaleFactor);
if chWidth.Checked then Include(Options, bpNewWidth);
Width := Round(sedWidth.Value * PixelScaleFactor);
if chHeight.Checked then Include(Options, bpNewHeight);
Height := Round(sedHeight.Value * PixelScaleFactor);
if chCenterHoriz.Checked then Include(Options, bpCenterHoriz);
if chCenterVert.Checked then Include(Options, bpCenterVert);
if chAlignRight.Checked then Include(Options, bpAlignRight);
if chAlignBottom.Checked then Include(Options, bpAlignBottom);
if chStretchHoriz.Checked then Include(Options, bpStretchHoriz);
if chStretchVert.Checked then Include(Options, bpStretchVert);
if chScaledSize.Checked then Include(Options, bpScaledSize);
PictureOptions := Options;
finally
if Recording then Owner.History.EndAction;
end;
end;
end;
procedure TBackgroundOptionsForm.chClick(Sender: TObject);
begin
CheckTools;
end;
procedure TBackgroundOptionsForm.CheckTools;
begin
sedTop.Enabled := chTop.Checked;
sedLeft.Enabled := chLeft.Checked;
sedWidth.Enabled := chWidth.Checked;
sedHeight.Enabled := chHeight.Checked;
end;
initialization
RegisterDefaultPropEditForm(TBackgroundOptionsProp, TBackgroundOptionsForm);
end.
|
program vectores8
{
Simular el funcionamiento de un conjunto de caracteres de la ‘a’ a la ‘z’ utilizando un arreglo. Defina
un tipo de datos adecuado e implemente módulos que realicen las operaciones de unión y diferencia
de dos conjuntos y una función que permite determinar si una letra pertenece al conjunto.
Nota: realice los chequeos correspondientes en cada módulo para procesar solo letras.
}
var
let: 'a'..'z';
{letras: set of let: tenemos que remplazar el conjunto con el uso de un array}
type
vectormatrix = Array[1..1000]of vectorchar;{seria necesario para despues acceder pero solo queremos operar con dos conjuntos}
vectorchar = Array[] of char;
proccedure check(a,b,var cond)
begin
if(a in let and b in let)then begin
cond:= true;
end else then begin
cond:= false;
end
end
proccedure un(a,b,var res)
begin
res:= a+b;
end
proccedure dif(a,b,var res)
begin
res:=a-b;
end
var
res:vectorchar;
a:vectorchar;
b:vectorchar;
op:string;
cond: boolean; {this is the condition of the entered data}
begin
cond:= false;
write('Las operaciones disponibles son union y diferencia')
readln('ingrese la operacion',op);
while(op <> 'exit') do begin
if(op == 'union')then begin
readln('ingrese el primer conjunto de letras',a);
readln('ingrese el segundo conjunto de letras',b);
check(a,b);
if(cond == true)then begin
un(a,b);
end else begin
write('Los elementos ingresados no corresponden con el tipo esperado');
end
end else if(op == 'diferencia')then begin
readln('ingrese el primer conjunto de letras',a);
readln('ingrese el segundo conjunto de letras',b);
check(a,b);
if(cond == true)then begin
dif(a,b);
end else begin
write('Los elementos ingresados no corresponden con el tipo esperado');
end
end
end
readln('ingrese el primer conjunto de letras',a);
readln('ingrese el segundo conjunto de letras',b);
end;
|
unit intf_2;
interface
implementation
uses System;
type
II1 = interface
function AAA(V: Int32): Int32;
function BBB(V: Int32): Int32;
end;
TT1 = class(TObject, II1)
function AAA(V: Int32): Int32;
function BBB(V: Int32): Int32;
end;
var
G: Int32;
function TT1.AAA(V: Int32): Int32;
begin
Result := V + 1;
end;
function TT1.BBB(V: Int32): Int32;
begin
Result := V + 2;
end;
procedure Test;
var
T: TT1;
I: II1;
begin
T := TT1.Create();
I := T;
G := I.AAA(1);
G := I.BBB(G);
end;
initialization
Test();
finalization
Assert(G = 4);
end. |
unit uObjectFeature;
interface
uses uMyTypes, Classes, Math, Graphics, Types, SysUtils, ShellAPI, Windows;
type
TFeatureObject = class(TObject)
private
objID: integer;
objComboID: integer; // -1 znamena, ze nie je clenom ziadneho comba
objTyp: integer;
objPoloha: TMyPoint;
objRozmer1: Double;
objRozmer2: Double;
objRozmer3: Double;
objRozmer4: Double;
objRozmer5: Double;
objParam1: string;
objParam2: string;
objParam3: string;
objParam4: string;
objParam5: string; // pouzite (ako prve) u grav.textov ako nazov fontu
objHlbka1: Double;
objFarba: TColor;
objNatocenie: Double;
objNazov: string;
objBoundingRect: TMyRect;
objSelected: boolean;
objHighlighted: Boolean; // toto je ine ako SELECTED, lebo to len vyfarbi objekt inou farbou ked sa napr. vybera spomedzi viacerych aby ho odlisilo
objStrana: byte; // na ktorej strane je prvok umiestneny (1=predna strana, 2=zadna strana)
objLocked: boolean;
objRodic: TObject;
procedure setTyp(typ: integer);
procedure setPoloha(p: TMyPoint);
procedure setX(x: Double);
procedure setY(y: Double);
procedure setRozmer1(r: Double);
procedure setRozmer2(r: Double);
procedure setRozmer3(r: Double);
procedure setRozmer4(r: Double);
procedure setRozmer5(r: Double);
procedure setParam1(p: string);
procedure setParam2(p: string);
procedure setParam3(p: string);
procedure setParam4(p: string);
procedure setParam5(p: string);
procedure setSelected(sel: boolean);
procedure setLocked(lock: boolean);
published
constructor Create(rodicPanel: TObject; stranaPanela: integer = -1; typPrvku: Integer = -1);
// === kazdu novu property zapisat aj do COPYFROM metody !!! === (aj do ukladania do suboru, do ukladania comba a do nahravania tychto veci tiez)
property ID: integer read objID write objID;
property ComboID: integer read objComboID write objComboID;
property Typ: integer read objTyp write setTyp;
property BoundingBox: TMyRect read objBoundingRect write objBoundingRect;
property Poloha: TMyPoint read objPoloha write setPoloha;
// === kazdu novu property zapisat aj do COPYFROM metody !!! === (aj do ukladania do suboru, do ukladania comba a do nahravania tychto veci tiez)
property X: double read objPoloha.X write setX;
property Y: double read objPoloha.Y write setY;
property Rozmer1: Double read objRozmer1 write setRozmer1;
property Rozmer2: Double read objRozmer2 write setRozmer2;
property Rozmer3: Double read objRozmer3 write setRozmer3;
property Rozmer4: Double read objRozmer4 write setRozmer4;
property Rozmer5: Double read objRozmer5 write setRozmer5;
// === kazdu novu property zapisat aj do COPYFROM metody !!! === (aj do ukladania do suboru, do ukladania comba a do nahravania tychto veci tiez)
property Param1: string read objParam1 write setParam1;
property Param2: string read objParam2 write setParam2;
property Param3: string read objParam3 write setParam3;
property Param4: string read objParam4 write setParam4;
property Param5: string read objParam5 write setParam5;
// === kazdu novu property zapisat aj do COPYFROM metody !!! === (aj do ukladania do suboru, do ukladania comba a do nahravania tychto veci tiez)
property Hlbka1: Double read objHlbka1 write objHlbka1;
property Farba: TColor read objFarba write objFarba;
property Natocenie: Double read objNatocenie write objNatocenie;
property Nazov: string read objNazov write objNazov;
property Selected: boolean read objSelected write setSelected;
property Highlighted: boolean read objHighlighted write objHighlighted;
property Strana: byte read objStrana write objStrana;
property Locked: boolean read objLocked write setLocked;
// === kazdu novu property zapisat aj do COPYFROM metody !!! === (aj do ukladania do suboru, do ukladania comba a do nahravania tychto veci tiez)
procedure Inicializuj;
procedure AdjustBoundingBox;
procedure Draw_Blind;
procedure Draw_Cosmetic;
procedure Draw_CosmeticLowPriority;
procedure Draw_CosmeticHighPriority;
procedure Draw_Through;
procedure DrawSelected;
procedure DrawHighlighted;
procedure StartEditing;
function GetFeatureInfo(withID: boolean = false; withPosition: boolean = false; exploded: boolean = false): string;
function IsOnPoint(bod_MM: TMyPoint): boolean;
procedure CopyFrom(src: TFeatureObject);
procedure MirrorFeature(var parentPanel: TObject; smer: char = 'x');
end;
implementation
uses uMain, uConfig, uFeaHole, uFeaPocket, uFeaThread, uFeaEngrave,
uFeaConus, uDebug, uFeaGroove, uDrawLib, uTranslate,
uObjectFeaturePolyLine, uObjectPanel, uObjectFont, uFeaCosmetic;
constructor TFeatureObject.Create(rodicPanel: TObject; stranaPanela: integer = -1; typPrvku: Integer = -1);
begin
inherited Create;
objRodic := rodicPanel;
objComboID := -1; // -1 znamena, ze nie je clenom ziadneho comba
objTyp := typPrvku;
objPoloha.X := 0;
objPoloha.Y := 0;
objRozmer1 := -1;
objRozmer2 := -1;
objRozmer3 := -1;
objRozmer4 := -1;
objRozmer5 := -1;
objHlbka1 := -1;
objNatocenie := 0;
objFarba := -1;
// gravirovanemu textu dame defaultne prvy font co sa najde nahraty v paneli
if (objTyp = ftTxtGrav) AND (objParam5 = '') then
objParam5 := (objRodic as TPanelObject).Fonty[0];
// gravirovanemu textu dame defaultne nulove natocenie
if (objTyp = ftTxtGrav) then
objRozmer2 := 0;
if (stranaPanela = -1) then begin // ak nie je zadefinovane, na ktorej strane panela ho mam vytvorit...
if (Assigned(objRodic)) then // ...ak je zadefinovany rodic prvku (panel) tak podla neho...
objStrana := TPanelObject(objRodic).StranaVisible // na ktorej strane je prvok umiestneny (1=predna strana, 2=zadna strana)
else
objStrana := 1; // ...ak nie je rodicovsky panel definovany, standardne ho vytvorim na prednej strane...
end else
objStrana := stranaPanela; // ...ak je zadefinovana strana explicitne, priradim ju.
objSelected := false;
objLocked := false;
end;
procedure TFeatureObject.Inicializuj;
var
FontTextu: TMyFont;
temp_vyska: double;
begin
// ******** uvodne inicializacne veci po vytvoreni prvku (ale nie len) ******************
// pri gravirovanom texte dopocitame celkovu sirku textu / vysku textu (podla toho, co uzivatel zadal a co treba dopocitat)
// tuto vypocitanu hodnotu ulozime do nepouziteho ObjRozmer4
if (objTyp = ftTxtGrav) then begin
if (objParam1 <> '') AND (objParam5 <> '') then begin
FontTextu := TMyFont(TPanelObject(objRodic).Fonty.Objects[ TPanelObject(objRodic).Fonty.IndexOf( objParam5 ) ]); // param5 = font name
if objParam2 = 'HEIGHT' then begin
objRozmer4 := FontTextu.ZistiSirkuTextu(objParam1, objRozmer1);
end;
if objParam2 = 'WIDTHALL' then begin
// hladanie zacneme od textu s nejakou minimalnou vyskou
temp_vyska := 0.5;
// najprv hrubsie hladanie
while FontTextu.ZistiSirkuTextu(objParam1, temp_vyska) < objRozmer1 do
temp_vyska := temp_vyska + 0.1;
// este jeden prechod jemnejsi
temp_vyska := temp_vyska - 0.1;
while FontTextu.ZistiSirkuTextu(objParam1, temp_vyska) < objRozmer1 do
temp_vyska := temp_vyska + 0.02;
// najdenu vysku textu ulozime do vlastnosti daneho ficru
objRozmer4 := temp_vyska;
end;
AdjustBoundingBox;
end;
end;
end;
procedure TFeatureObject.CopyFrom(src: TFeatureObject);
begin
// ID sa nekopiruje !!! //
objComboID := src.ComboID;
objTyp := src.Typ;
objBoundingRect := src.BoundingBox;
objPoloha := src.Poloha;
objRozmer1 := src.Rozmer1;
objRozmer2 := src.Rozmer2;
objRozmer3 := src.Rozmer3;
objRozmer4 := src.Rozmer4;
objRozmer5 := src.Rozmer5;
objParam1 := src.Param1;
objParam2 := src.Param2;
objParam3 := src.Param3;
objParam4 := src.Param4;
objParam5 := src.Param5;
objHlbka1 := src.Hlbka1;
objFarba := src.Farba;
objNatocenie := src.Natocenie;
objNazov := src.Nazov;
objSelected := src.Selected;
objStrana := src.Strana;
objLocked := src.Locked;
// gravirovany text MUSI mat priradeny nejaky font. Ak nema, dame mu prvy co najdeme nahraty v paneli
if (objTyp = ftTxtGrav) AND (objParam5 = '') then
objParam5 := (objRodic as TPanelObject).Fonty[0];
end;
procedure TFeatureObject.setTyp(typ: integer);
begin
objTyp := typ;
// ak pozname typ prvku, nastavime nejake jeho default vlastnosti
case objTyp of
ftTxtGrav, ftLine2Grav, ftCircleGrav, ftRectGrav, ftPolyLineGrav: begin
objParam4 := 'NOFILL';
end;
end;
end;
procedure TFeatureObject.setRozmer1(r: Double);
begin
objRozmer1 := r;
AdjustBoundingBox;
if Assigned(objRodic) then TPanelObject(objRodic).HasChanged := true;
end;
procedure TFeatureObject.setRozmer2(r: Double);
begin
objRozmer2 := r;
AdjustBoundingBox;
if Assigned(objRodic) then TPanelObject(objRodic).HasChanged := true;
end;
procedure TFeatureObject.setRozmer3(r: Double);
begin
objRozmer3 := r;
AdjustBoundingBox;
if Assigned(objRodic) then TPanelObject(objRodic).HasChanged := true;
end;
procedure TFeatureObject.setRozmer4(r: Double);
begin
objRozmer4 := r;
AdjustBoundingBox;
if Assigned(objRodic) then TPanelObject(objRodic).HasChanged := true;
end;
procedure TFeatureObject.setRozmer5(r: Double);
begin
objRozmer5 := r;
AdjustBoundingBox;
if Assigned(objRodic) then TPanelObject(objRodic).HasChanged := true;
end;
procedure TFeatureObject.setSelected(sel: boolean);
begin
if (not objLocked) then
objSelected := sel;
end;
procedure TFeatureObject.setLocked(lock: boolean);
begin
if (objSelected) AND (lock) then
objSelected := false;
objLocked := lock;
if Assigned(objRodic) then TPanelObject(objRodic).HasChanged := true;
end;
procedure TFeatureObject.setParam1(p: string);
begin
objParam1 := p;
if Assigned(objRodic) then TPanelObject(objRodic).HasChanged := true;
AdjustBoundingBox;
end;
procedure TFeatureObject.setParam2(p: string);
begin
objParam2 := p;
if Assigned(objRodic) then TPanelObject(objRodic).HasChanged := true;
end;
procedure TFeatureObject.setParam3(p: string);
begin
objParam3 := p;
if Assigned(objRodic) then TPanelObject(objRodic).HasChanged := true;
end;
procedure TFeatureObject.setParam4(p: string);
begin
objParam4 := p;
case objTyp of
ftTxtGrav, ftLine2Grav, ftCircleGrav, ftRectGrav, ftPolyLineGrav: begin
if (objParam4 = '') then objParam4 := 'NOFILL';
end;
end;
if Assigned(objRodic) then TPanelObject(objRodic).HasChanged := true;
end;
procedure TFeatureObject.setParam5(p: string);
begin
objParam5 := p;
if Assigned(objRodic) then TPanelObject(objRodic).HasChanged := true;
end;
procedure TFeatureObject.setPoloha(p: TMyPoint);
begin
objPoloha := p;
AdjustBoundingBox;
if Assigned(objRodic) then TPanelObject(objRodic).HasChanged := true;
end;
procedure TFeatureObject.setX(x: double);
begin
objPoloha.X := x;
AdjustBoundingBox;
if Assigned(objRodic) then TPanelObject(objRodic).HasChanged := true;
end;
procedure TFeatureObject.setY(y: double);
begin
objPoloha.Y := y;
AdjustBoundingBox;
if Assigned(objRodic) then TPanelObject(objRodic).HasChanged := true;
end;
procedure TFeatureObject.AdjustBoundingBox;
var
i: integer;
txt_off_x, txt_off_y: double;
ang1, ang2: double;
bodyLave, bodyPrave: TMyPoint2D;
begin
if Assigned(objRodic) then
TPanelObject(objRodic).CurrentSide := objStrana
else
Exit;
case objTyp of
ftHoleCirc, ftPocketCirc, ftCosmeticCircle: begin
objBoundingRect.TopL.X := objPoloha.X - (objRozmer1/2) - objRozmer5 - rozsirenieBoxu;
objBoundingRect.TopL.Y := objPoloha.Y + (objRozmer1/2) + objRozmer5 + rozsirenieBoxu;
objBoundingRect.BtmR.X := objPoloha.X + (objRozmer1/2) + objRozmer5 + rozsirenieBoxu;
objBoundingRect.BtmR.Y := objPoloha.Y - (objRozmer1/2) - objRozmer5 - rozsirenieBoxu;
end;
ftThread, ftCircleGrav, ftSink, ftSinkSpecial, ftSinkCyl: begin
objBoundingRect.TopL.X := objPoloha.X - (objRozmer1/2) - rozsirenieBoxu;
objBoundingRect.TopL.Y := objPoloha.Y + (objRozmer1/2) + rozsirenieBoxu;
objBoundingRect.BtmR.X := objPoloha.X + (objRozmer1/2) + rozsirenieBoxu;
objBoundingRect.BtmR.Y := objPoloha.Y - (objRozmer1/2) - rozsirenieBoxu;
end;
ftHoleRect, ftPocketRect, ftCosmeticRect: begin
objBoundingRect.TopL.X := objPoloha.X - (objRozmer1/2) - objRozmer5 - rozsirenieBoxu;
objBoundingRect.TopL.Y := objPoloha.Y + (objRozmer2/2) + objRozmer5 + rozsirenieBoxu;
objBoundingRect.BtmR.X := objPoloha.X + (objRozmer1/2) + objRozmer5 + rozsirenieBoxu;
objBoundingRect.BtmR.Y := objPoloha.Y - (objRozmer2/2) - objRozmer5 - rozsirenieBoxu;
end;
ftRectGrav: begin
objBoundingRect.TopL.X := objPoloha.X - (objRozmer1/2) - rozsirenieBoxu;
objBoundingRect.TopL.Y := objPoloha.Y + (objRozmer2/2) + rozsirenieBoxu;
objBoundingRect.BtmR.X := objPoloha.X + (objRozmer1/2) + rozsirenieBoxu;
objBoundingRect.BtmR.Y := objPoloha.Y - (objRozmer2/2) - rozsirenieBoxu;
end;
ftTxtGrav: begin
if objParam2 = 'HEIGHT' then begin
if objParam3 = taCenter then // zarovnaj na stred
txt_off_x := objRozmer4 / 2;
if objParam3 = taRight then // zarovnaj doprava
txt_off_x := 0;
if objParam3 = taLeft then // zarovnaj dolava
txt_off_x := objRozmer4;
txt_off_y := objRozmer1 / 2;
objBoundingRect.TopL.X := objPoloha.X - txt_off_x - rozsirenieBoxu;
objBoundingRect.TopL.Y := objPoloha.Y + txt_off_y + rozsirenieBoxu;
objBoundingRect.BtmR.X := objPoloha.X + objRozmer4 - txt_off_x + rozsirenieBoxu;
objBoundingRect.BtmR.Y := objPoloha.Y - objRozmer1 + txt_off_y - rozsirenieBoxu;
end;
if objParam2 = 'WIDTHALL' then begin
if objParam3 = taCenter then // zarovnaj na stred
txt_off_x := objRozmer1 / 2;
if objParam3 = taRight then // zarovnaj doprava
txt_off_x := 0;
if objParam3 = taLeft then // zarovnaj dolava
txt_off_x := objRozmer1;
txt_off_y := objRozmer4 / 2;
objBoundingRect.TopL.X := objPoloha.X - txt_off_x - rozsirenieBoxu;
objBoundingRect.TopL.Y := objPoloha.Y + txt_off_y + rozsirenieBoxu;
objBoundingRect.BtmR.X := objPoloha.X + objRozmer1 - txt_off_x + rozsirenieBoxu;
objBoundingRect.BtmR.Y := objPoloha.Y - objRozmer4 + txt_off_y - rozsirenieBoxu;
end;
// este prepocet boxu ak je text rotovany
if (objRozmer2 <> 0) then begin
// potrebujem vediet vsetky 4 ohranicovacie body textu - z nich budem skladat vysledny box
// TopLeft a BottomRight su uz vypocitane...
bodyLave.first := objBoundingRect.TopL;
bodyPrave.second := objBoundingRect.BtmR;
// no a dalsie dva si odvodim z nich:
bodyLave.second.X := bodyLave.first.X;
bodyLave.second.Y := objBoundingRect.BtmR.Y;
bodyPrave.first.X := bodyPrave.second.X;
bodyPrave.first.Y := objBoundingRect.TopL.Y;
// teraz ich zrotujeme na dany uhol
bodyLave.first := uDrawLib.RotujBodOkoloBoduMM( bodyLave.first, objPoloha, objRozmer2);
bodyLave.second := uDrawLib.RotujBodOkoloBoduMM( bodyLave.second, objPoloha, objRozmer2);
bodyPrave.first := uDrawLib.RotujBodOkoloBoduMM( bodyPrave.first, objPoloha, objRozmer2);
bodyPrave.second := uDrawLib.RotujBodOkoloBoduMM( bodyPrave.second, objPoloha, objRozmer2);
// a teraz z nich vyskladam vysledny bounding box
if objRozmer2 <= 90 then begin
objBoundingRect.TopL.X := bodyLave.first.X;
objBoundingRect.TopL.Y := bodyPrave.first.Y;
objBoundingRect.BtmR.X := bodyPrave.second.X;
objBoundingRect.BtmR.Y := bodyLave.second.Y;
end else if objRozmer2 <= 180 then begin
objBoundingRect.TopL.X := bodyPrave.first.X;
objBoundingRect.TopL.Y := bodyPrave.second.Y;
objBoundingRect.BtmR.X := bodyLave.second.X;
objBoundingRect.BtmR.Y := bodyLave.first.Y;
end else if objRozmer2 <= 270 then begin
objBoundingRect.TopL.X := bodyPrave.second.X;
objBoundingRect.TopL.Y := bodyLave.second.Y;
objBoundingRect.BtmR.X := bodyLave.first.X;
objBoundingRect.BtmR.Y := bodyPrave.first.Y;
end else if objRozmer2 <= 360 then begin
objBoundingRect.TopL.X := bodyLave.second.X;
objBoundingRect.TopL.Y := bodyLave.first.Y;
objBoundingRect.BtmR.X := bodyPrave.first.X;
objBoundingRect.BtmR.Y := bodyPrave.second.Y;
end;
end;
end;
ftLine2Grav: begin
objBoundingRect.TopL.X := Min(objPoloha.X, (objPoloha.X+objRozmer1)) - rozsirenieBoxu;
objBoundingRect.TopL.Y := Max(objPoloha.Y, (objPoloha.Y+objRozmer2)) + rozsirenieBoxu;
objBoundingRect.BtmR.X := Max(objPoloha.X, (objPoloha.X+objRozmer1)) + rozsirenieBoxu;
objBoundingRect.BtmR.Y := Min(objPoloha.Y, (objPoloha.Y+objRozmer2)) - rozsirenieBoxu;
end;
ftGrooveLin: begin
objBoundingRect.TopL.X := Min(objPoloha.X, (objPoloha.X+objRozmer1)) - (objRozmer3/2) - rozsirenieBoxu;
objBoundingRect.TopL.Y := Max(objPoloha.Y, (objPoloha.Y+objRozmer2)) + (objRozmer3/2) + rozsirenieBoxu;
objBoundingRect.BtmR.X := Max(objPoloha.X, (objPoloha.X+objRozmer1)) + (objRozmer3/2) + rozsirenieBoxu;
objBoundingRect.BtmR.Y := Min(objPoloha.Y, (objPoloha.Y+objRozmer2)) - (objRozmer3/2) - rozsirenieBoxu;
end;
ftGrooveArc: begin
objBoundingRect.TopL := MyPoint(9999 , -9999);
objBoundingRect.BtmR := MyPoint(-9999 , 9999);
// najjednoduchsi sposob - prejst po celej drahe obluka a najst max/minima
ang1 := objRozmer2;
ang2 := objRozmer3;
if ang2 < ang1 then ang2 := ang2+360;
for i:=Round(ang1) to Round(ang2) do begin
objBoundingRect.TopL.X := Min(
objBoundingRect.TopL.X,
objPoloha.X + ( (objRozmer1/2) * cos(DegToRad(i)) )
);
objBoundingRect.TopL.Y := Max(
objBoundingRect.TopL.Y,
objPoloha.Y + ( (objRozmer1/2) * sin(DegToRad(i)) )
);
objBoundingRect.BtmR.X := Max(
objBoundingRect.BtmR.X,
objPoloha.X + ( (objRozmer1/2) * cos(DegToRad(i)) )
);
objBoundingRect.BtmR.Y := Min(
objBoundingRect.BtmR.Y,
objPoloha.Y + ( (objRozmer1/2) * sin(DegToRad(i)) )
);
end; // for
objBoundingRect.TopL.X := objBoundingRect.TopL.X - (objRozmer4/2) - rozsirenieBoxu;
objBoundingRect.TopL.Y := objBoundingRect.TopL.Y + (objRozmer4/2) + rozsirenieBoxu;
objBoundingRect.BtmR.X := objBoundingRect.BtmR.X + (objRozmer4/2) + rozsirenieBoxu;
objBoundingRect.BtmR.Y := objBoundingRect.BtmR.Y - (objRozmer4/2) - rozsirenieBoxu;
end;
end;
end;
{
Zabezpecuje vykreslenie samotneho objektu - konkretne tych casti objektov, ktore su slepe - nejdu skrz panel
}
procedure TFeatureObject.Draw_Blind;
var
farVypln, farOkolo: TColor;
isOnBackSide: boolean;
QPFont: TMyFont;
begin
// if objHlbka1 = 9999 then Exit; // nemoze to tu byt, lebo by sa nevykreslili kuzelove a valcove zahlbenia okolo dier
BackPlane.Canvas.Brush.Style := bsSolid;
BackPlane.Canvas.Pen.Style := psSolid;
isOnBackSide := objStrana <> _PNL.StranaVisible;
// ak je prvok na zadnej strane, musi sa vykreslovat podla zadneho nul.bodu
_PNL.CurrentSide := objStrana;
case objTyp of
////////////////// kruhova kapsa
ftPocketCirc: begin
if isOnBackSide then begin
KruzObvod(objPoloha, ObjRozmer1, farbaOtherSideContours, 1, psDash);
end else begin
KruzPlocha(objPoloha, objRozmer1, farbaKapsaPlocha, farbaObvod);
end;
end;
/////////////////// obdlznikova kapsa
ftPocketRect: begin
if isOnBackSide then begin
ObdlzObvod(objPoloha, ObjRozmer1, objRozmer2, objRozmer3, farbaOtherSideContours, 1, psDash);
end else begin
ObdlzPlocha(objPoloha, objRozmer1, objRozmer2, objRozmer3, objRozmer4, farbaKapsaPlocha, farbaObvod);
end;
end;
/////////////////// zavit
ftThread: begin
if isOnBackSide then begin
KruzObvod(objPoloha, objRozmer1*0.83, farbaOtherSideContours, 1, psDash);
end else begin
KruzPlocha(objPoloha, objRozmer1*0.83, farbaKapsaPlocha, farbaObvod);
end;
end;
/////////////////// text
ftTxtGrav: begin
if (not isOnBackSide) then begin
if objParam4 = 'NOFILL' then farVypln := farbaGravirSurovy;
if objParam4 = 'BLACK' then farVypln := clBlack;
if objParam4 = 'WHITE' then farVypln := clWhite;
if objParam4 = 'RED' then farVypln := clRed;
if objParam4 = 'GREEN' then farVypln := farbaOtherSideContours;
if objParam4 = 'BLUE' then farVypln := clBlue;
//Text_old(objParam1, objPoloha, objRozmer1, objParam2, objParam3, farVypln);
QPFont := TMyFont(TPanelObject(objRodic).Fonty.Objects[ TPanelObject(objRodic).Fonty.IndexOf( objParam5 ) ]); // param5 = font name
if objParam2 = 'HEIGHT' then begin
if (objRozmer3 < 1) then
Text(objParam1, objPoloha, objRozmer1, objRozmer4, objParam2, objParam3, farVypln, objRozmer3+rozsirenieGravira, QPFont, objRozmer2) // pri gravirovani grav.hrotmi (predpokladam, ze pod 1mm su vsetko len grav.hroty) rozsirim trosku stopu aby sa to priblizilo realu
else
Text(objParam1, objPoloha, objRozmer1, objRozmer4, objParam2, objParam3, farVypln, objRozmer3, QPFont, objRozmer2);
end else if objParam2 = 'WIDTHALL' then begin
if (objRozmer3 < 1) then
Text(objParam1, objPoloha, objRozmer4, objRozmer1, objParam2, objParam3, farVypln, objRozmer3+rozsirenieGravira, QPFont, objRozmer2) // pri gravirovani grav.hrotmi (predpokladam, ze pod 1mm su vsetko len grav.hroty) rozsirim trosku stopu aby sa to priblizilo realu
else
Text(objParam1, objPoloha, objRozmer4, objRozmer1, objParam2, objParam3, farVypln, objRozmer3, QPFont, objRozmer2);
end;
end;
end;
/////////////////// gravirovana ciara
ftLine2Grav: begin
if (not isOnBackSide) then begin
if objParam4 = 'NOFILL' then farVypln := farbaGravirSurovy;
if objParam4 = 'BLACK' then farVypln := clBlack;
if objParam4 = 'WHITE' then farVypln := clWhite;
if objParam4 = 'RED' then farVypln := clRed;
if objParam4 = 'GREEN' then farVypln := farbaOtherSideContours;
if objParam4 = 'BLUE' then farVypln := clBlue;
// pri gravirovani grav.hrotmi (predpokladam, ze pod 1mm su vsetko len grav.hroty) rozsirim trosuk stopu aby sa to priblizilo realu
if (objRozmer3 < 1) then
Ciara( objPoloha, MyPoint(objPoloha.X+objRozmer1, objPoloha.Y+objRozmer2), farVypln, objRozmer3+rozsirenieGravira )
else
Ciara( objPoloha, MyPoint(objPoloha.X+objRozmer1, objPoloha.Y+objRozmer2), farVypln, objRozmer3 );
end;
end;
/////////////////// gravirovany obdlznik
ftRectGrav: begin
if (not isOnBackSide) then begin
if objParam4 = 'NOFILL' then farVypln := farbaGravirSurovy;
if objParam4 = 'BLACK' then farVypln := clBlack;
if objParam4 = 'WHITE' then farVypln := clWhite;
if objParam4 = 'RED' then farVypln := clRed;
if objParam4 = 'GREEN' then farVypln := farbaOtherSideContours;
if objParam4 = 'BLUE' then farVypln := clBlue;
// pri gravirovani grav.hrotmi (predpokladam, ze pod 1mm su vsetko len grav.hroty) rozsirim trosuk stopu aby sa to priblizilo realu
if (objRozmer3 < 1) then
ObdlzObvod( objPoloha, objRozmer1, objRozmer2, objRozmer4, farVypln, PX(objRozmer3+rozsirenieGravira) )
else
ObdlzObvod( objPoloha, objRozmer1, objRozmer2, objRozmer4, farVypln, PX(objRozmer3) );
end;
end;
/////////////////// gravirovana kruznica
ftCircleGrav: begin // engraved shapes
if (not isOnBackSide) then begin
if objParam4 = 'NOFILL' then farVypln := farbaGravirSurovy;
if objParam4 = 'BLACK' then farVypln := clBlack;
if objParam4 = 'WHITE' then farVypln := clWhite;
if objParam4 = 'RED' then farVypln := clRed;
if objParam4 = 'GREEN' then farVypln := farbaOtherSideContours;
if objParam4 = 'BLUE' then farVypln := clBlue;
// pri gravirovani grav.hrotmi (predpokladam, ze pod 1mm su vsetko len grav.hroty) rozsirim trosuk stopu aby sa to priblizilo realu
if (objRozmer3 < 1) then
KruzObvod( objPoloha, objRozmer1, farVypln, PX(objRozmer3+rozsirenieGravira) )
else
KruzObvod( objPoloha, objRozmer1, farVypln, PX(objRozmer3) );
end;
end;
/////////////////// zahlbenie kuzelove
ftSink: begin
// tu len kruh zahlbenia
if isOnBackSide then begin
KruzObvod(objPoloha, objRozmer1, farbaOtherSideContours, 1, psDash);
end else begin
KruzPlocha( objPoloha, objRozmer1, farbaKapsaPlocha, farbaObvodZrazenaHrana );
end;
end;
/////////////////// zahlbenie kuzelove specialne
ftSinkSpecial: begin
end;
/////////////////// zahlbenie valcove
ftSinkCyl: begin
// tu len kruh zahlbenia
if isOnBackSide then begin
KruzObvod(objPoloha, objRozmer1, farbaOtherSideContours, 1, psDash);
end else begin
KruzPlocha( objPoloha, objRozmer1, farbaKapsaPlocha, farbaObvod );
end;
end;
/////////////////// drazka rovna
ftGrooveLin: begin
if isOnBackSide then begin
Ciara( objPoloha, MyPoint(objPoloha.X+objRozmer1, objPoloha.Y+objRozmer2), farbaOtherSideContours, MM(1), psDash);
end else begin
Ciara( objPoloha, MyPoint(objPoloha.X+objRozmer1, objPoloha.Y+objRozmer2), farbaKapsaPlocha, objRozmer3 );
end;
end;
/////////////////// drazka obluk
ftGrooveArc: begin
if isOnBackSide then begin
// pri kresleni obluka na opacnej strane ho musim ozrkadlit
Obluk( objPoloha, objRozmer1, objRozmer2, objRozmer3, farbaOtherSideContours, 1, (objParam1 = 'S'), psDash );
end else begin
Obluk( objPoloha, objRozmer1, objRozmer2, objRozmer3, farbaKapsaPlocha, PX(objRozmer4), (objParam1 = 'S') );
end;
end;
end; // case
end;
{
Zabezpecuje vykreslenie samotneho objektu - cosmetic prvky ale take, co budu prekryte inymi prvkami (zrazenia hran napr.)
}
procedure TFeatureObject.Draw_CosmeticLowPriority;
var
farVypln, farOkolo: TColor;
isOnBackSide: boolean;
QPFont: TMyFont;
begin
BackPlane.Canvas.Brush.Style := bsSolid;
BackPlane.Canvas.Pen.Style := psSolid;
isOnBackSide := objStrana <> _PNL.StranaVisible;
// ak je prvok na zadnej strane, musi sa vykreslovat podla zadneho nul.bodu
_PNL.CurrentSide := objStrana;
case objTyp of
///////////////////// kruhova diera
ftHoleCirc: begin
if objRozmer5 > 0 then
if isOnBackSide then
KruzObvod(objPoloha, objRozmer1+(2*objRozmer5), clGreen, 1, psDash)
else
KruzObvod(objPoloha, objRozmer1+(2*objRozmer5), farbaObvodZrazenaHrana)
else ;
end;
/////////////////// obdlznikova diera
ftHoleRect: begin
if objRozmer5 > 0 then
if isOnBackSide then
ObdlzObvod(objPoloha, objRozmer1+(2*objRozmer5), objRozmer2+(2*objRozmer5), objRozmer3+objRozmer5, clGreen, 1, psDash)
else
ObdlzObvod(objPoloha, objRozmer1+(2*objRozmer5), objRozmer2+(2*objRozmer5), objRozmer3+objRozmer5, farbaObvodZrazenaHrana)
else
end;
////////////////// kruhova kapsa
ftPocketCirc: begin
if isOnBackSide then begin
if objRozmer5 > 0 then
KruzObvod(objPoloha, objRozmer1+(2*objRozmer5), clGreen, 1, psDash);
end else begin
if objRozmer5 > 0 then
KruzObvod(objPoloha, objRozmer1+(2*objRozmer5), farbaObvodZrazenaHrana);
end;
end;
/////////////////// obdlznikova kapsa
ftPocketRect: begin
if isOnBackSide then begin
if objRozmer5 > 0 then
ObdlzObvod(objPoloha, objRozmer1+(2*objRozmer5), objRozmer2+(2*objRozmer5), objRozmer3+objRozmer5, clGreen, 1, psDash)
end else begin
if objRozmer5 > 0 then
ObdlzObvod(objPoloha, objRozmer1+(2*objRozmer5), objRozmer2+(2*objRozmer5), objRozmer3+objRozmer5, farbaObvodZrazenaHrana);
end;
end;
end; // case
end;
{
Zabezpecuje vykreslenie samotneho objektu - konkretne tych casti objektov, ktore idu durch cez cely panel
}
procedure TFeatureObject.Draw_Through;
var
farVypln, farOkolo: TColor;
isOnBackSide: boolean;
QPFont: TMyFont;
begin
if objHlbka1 < 9999 then Exit;
BackPlane.Canvas.Brush.Style := bsSolid;
BackPlane.Canvas.Pen.Style := psSolid;
isOnBackSide := objStrana <> _PNL.StranaVisible;
// ak je prvok na zadnej strane, musi sa vykreslovat podla zadneho nul.bodu
_PNL.CurrentSide := objStrana;
case objTyp of
///////////////////// kruhova diera
ftHoleCirc: begin
KruzPlocha(objPoloha, objRozmer1, _PNL.BgndCol, _PNL.BgndCol);
end;
/////////////////// obdlznikova diera
ftHoleRect: begin
ObdlzPlocha(objPoloha, objRozmer1, objRozmer2, objRozmer3, objRozmer4, _PNL.BgndCol, _PNL.BgndCol);
end;
/////////////////// zavit
ftThread: begin
KruzPlocha(objPoloha, objRozmer1*0.83, _PNL.BgndCol, _PNL.BgndCol);
Obluk(objPoloha, objRozmer1, 80, 10, farbaZavity);
end;
/////////////////// zahlbenie kuzelove
ftSink: begin
KruzPlocha( objPoloha, objRozmer2, _PNL.BgndCol, _PNL.BgndCol );
end;
/////////////////// zahlbenie kuzelove specialne
ftSinkSpecial: begin
end;
/////////////////// zahlbenie valcove
ftSinkCyl: begin
KruzPlocha( objPoloha, objRozmer2, _PNL.BgndCol, _PNL.BgndCol );
end;
/////////////////// drazka rovna
ftGrooveLin: begin
Ciara( objPoloha, MyPoint(objPoloha.X+objRozmer1, objPoloha.Y+objRozmer2), _PNL.BgndCol, objRozmer3 );
end;
/////////////////// drazka obluk
ftGrooveArc: begin
Obluk( objPoloha, objRozmer1, objRozmer2, objRozmer3, _PNL.BgndCol, PX(objRozmer4), (objParam1 = 'S') );
end;
end; // case
end;
{
Zabezpecuje vykreslenie samotneho objektu - konkretne tych casti objektov, ktore su len kozmeticke a maju byt stale viditelne - napr. 3/4 kruh okolo zavitu
}
procedure TFeatureObject.Draw_Cosmetic;
var
farVypln, farOkolo: TColor;
isOnBackSide: boolean;
QPFont: TMyFont;
begin
BackPlane.Canvas.Brush.Style := bsSolid;
BackPlane.Canvas.Pen.Style := psSolid;
isOnBackSide := objStrana <> _PNL.StranaVisible;
// ak je prvok na zadnej strane, musi sa vykreslovat podla zadneho nul.bodu
_PNL.CurrentSide := objStrana;
case objTyp of
/////////////////// zavit
ftThread: begin
if objHlbka1 < 9999 then // ak je zavit skrz, tak aj jeho cosmetic sa kresli s priechodzou dierou, lebo ho vidno z obidvoch stran
if (isOnBackSide) then begin
KruzObvod(objPoloha, objRozmer1*0.83, farbaOtherSideContours, 1, psDash);
Obluk(objPoloha, objRozmer1, 80, 10, farbaOtherSideContours, 1, false, psDash);
end else
Obluk(objPoloha, objRozmer1, 80, 10, farbaZavity);
end;
end; // case
end;
procedure TFeatureObject.Draw_CosmeticHighPriority;
var
farVypln, farOkolo: TColor;
isOnBackSide: boolean;
QPFont: TMyFont;
begin
BackPlane.Canvas.Brush.Style := bsSolid;
BackPlane.Canvas.Pen.Style := psSolid;
isOnBackSide := objStrana <> _PNL.StranaVisible;
// ak je prvok na zadnej strane, musi sa vykreslovat podla zadneho nul.bodu
_PNL.CurrentSide := objStrana;
case objTyp of
/////////////////// cosmetic kruznica
ftCosmeticCircle: begin
KruzObvod(objPoloha, objRozmer1, objFarba, 2);
with BackPlane.Canvas do begin
Font.Size := 11;
Font.Color := objFarba;
TextOut(PX(objPoloha.X, 'x') - Round((TextWidth(objNazov)/2)), PX(objPoloha.Y, 'y'), objNazov);
end;
end;
/////////////////// cosmetic obdlznik
ftCosmeticRect: begin
ObdlzObvod(objPoloha, objRozmer1, objRozmer2, objRozmer3, objFarba, 2);
with BackPlane.Canvas do begin
Font.Size := 11;
Font.Color := objFarba;
TextOut(PX(objPoloha.X, 'x') - Round((TextWidth(objNazov)/2)), PX(objPoloha.Y, 'y'), objNazov);
end;
end;
end;
end;
{
Najprv vykresli konturu vybrateho objektu
a nasledne vykresli ciarkovane oramikovanie vybraneho objektu
}
procedure TFeatureObject.DrawSelected;
var
comboBoundingRectMM: TMyRect;
comboBoundingRectPX: TRect;
begin
if not objSelected then Exit;
_PNL.CurrentSide := objStrana;
// vykreslime konturu objektu
BackPlane.Canvas.Brush.Style := bsClear;
BackPlane.Canvas.Pen.Style := psSolid;
BackPlane.Canvas.Pen.Width := 1;
case objTyp of
///////////////////// kruhova diera
ftHoleCirc: begin
KruzObvod(objPoloha, objRozmer1, farbaSelectedObvod)
end;
/////////////////// obdlznikova diera
ftHoleRect: begin
ObdlzObvod(objPoloha, objRozmer1, objRozmer2, objRozmer3, farbaSelectedObvod);
end;
////////////////// kruhova kapsa
ftPocketCirc: begin
KruzObvod(objPoloha, objRozmer1, farbaSelectedObvod);
end;
/////////////////// obdlznikova kapsa
ftPocketRect: begin
ObdlzObvod(objPoloha, objRozmer1, objRozmer2, objRozmer3, farbaSelectedObvod);
end;
/////////////////// zavit
ftThread: begin
KruzObvod(objPoloha, objRozmer1*0.83, farbaSelectedObvod);
end;
/////////////////// text
ftTxtGrav: begin
end;
/////////////////// gravirovana ciara
ftLine2Grav: begin
Ciara( objPoloha, MyPoint(objPoloha.X+objRozmer1, objPoloha.Y+objRozmer2), farbaSelectedObvod, 0.02 );
end;
/////////////////// gravirovany obdlznik
ftRectGrav: begin
ObdlzObvod( objPoloha, objRozmer1, objRozmer2, 0, farbaSelectedObvod );
end;
/////////////////// gravirovana kruznica
ftCircleGrav: begin // engraved shapes
KruzObvod( objPoloha, objRozmer1, farbaSelectedObvod );
end;
/////////////////// zahlbenie kuzelove
ftSink: begin
// najprv kruh zahlbenia a nasledne kruh priechodzej diery
KruzObvod( objPoloha, objRozmer1, farbaSelectedObvod );
KruzObvod( objPoloha, objRozmer2, farbaSelectedObvod );
end;
/////////////////// zahlbenie kuzelove specialne
ftSinkSpecial: begin
end;
/////////////////// zahlbenie valcove
ftSinkCyl: begin
// najprv kruh zahlbenia a nasledne kruh priechodzej diery
KruzObvod( objPoloha, objRozmer1, farbaSelectedObvod );
KruzObvod( objPoloha, objRozmer2, farbaSelectedObvod );
end;
/////////////////// drazka rovna
ftGrooveLin: begin
Ciara( objPoloha, MyPoint(objPoloha.X+objRozmer1, objPoloha.Y+objRozmer2), farbaSelectedObvod, 0.02 );
end;
/////////////////// drazka obluk
ftGrooveArc: begin
Obluk( objPoloha, objRozmer1, objRozmer2, objRozmer3, farbaSelectedObvod, 1, (objParam1 = 'S') );
end;
end; // case
// vykreslenie indikacie vyselectovania - cerveny obdlznik okolo
with BackPlane.Canvas do begin
Brush.Style := bsClear;
Pen.Style := psDash;
Pen.Width := 1;
// ina farba vyselectovania pri obyc.otvoroch a ina pri combo otvoroch
if objComboID > -1 then begin
Pen.Color := farbaSelectedBoundingBoxCombo;
if Pos(','+IntToStr(objComboID)+',', _PNL.SelCombosDrawn) = 0 then begin
comboBoundingRectMM := _PNL.GetComboBoundingBox(objComboID);
comboBoundingRectPX.Left := PX(comboBoundingRectMM.TopL.X, 'x')-2;
comboBoundingRectPX.Right := PX(comboBoundingRectMM.BtmR.X, 'x')+3;
comboBoundingRectPX.Top := PX(comboBoundingRectMM.TopL.Y, 'y')-2;
comboBoundingRectPX.Bottom := PX(comboBoundingRectMM.BtmR.Y, 'y')+3;
Rectangle( comboBoundingRectPX );
// mnohonasobne vykreslenie obdlznika celeho comba (pri kazdom jeho komponente) je velmi zdlhave, takze:
_PNL.SelCombosDrawn := _PNL.SelCombosDrawn + ','+IntToStr(objComboID)+','; //(vysvetlenie - vid deklaracia)
end;
end else begin
Pen.Color := farbaSelectedBoundingBox;
Rectangle(
Px(objBoundingRect.TopL.X, 'x')-2,
Px(objBoundingRect.TopL.Y, 'y')-2,
Px(objBoundingRect.BtmR.X, 'x')+3,
Px(objBoundingRect.BtmR.Y, 'y')+3
);
end;
end; // with
end;
{
Vykresli objekt vo zvyraznenej farbe.
Nesluzi na oznacenie objektu, ked je vybraty, ale na zvyraznovanie napr. pocas multiselect prechadzania mysou po buttonoch
}
procedure TFeatureObject.DrawHighlighted;
var
isOnBackSide: boolean;
QPFont: TMyFont;
begin
BackPlane.Canvas.Brush.Style := bsSolid;
BackPlane.Canvas.Pen.Style := psSolid;
isOnBackSide := objStrana <> _PNL.StranaVisible;
// ak je prvok na zadnej strane, musi sa vykreslovat podla zadneho nul.bodu
_PNL.CurrentSide := objStrana;
case objTyp of
///////////////////// kruhova diera, kapsa
ftHoleCirc, ftPocketCirc, ftCosmeticCircle: begin
KruzObvod(objPoloha, objRozmer1, farbaHighlightObvod, 3);
end;
/////////////////// obdlznikova diera, kapsa
ftHoleRect, ftPocketRect, ftCosmeticRect: begin
ObdlzObvod(objPoloha, objRozmer1, objRozmer2, objRozmer3, farbaHighlightObvod, 3);
end;
/////////////////// zavit
ftThread: begin
KruzObvod(objPoloha, objRozmer1*0.83, farbaHighlightObvod, 3);
Obluk(objPoloha, objRozmer1, 80, 10, farbaHighlightObvod, 3);
end;
/////////////////// text
ftTxtGrav: begin
QPFont := TMyFont(TPanelObject(objRodic).Fonty.Objects[ TPanelObject(objRodic).Fonty.IndexOf( objParam5 ) ]); // param5 = font name
if objParam2 = 'HEIGHT' then begin
Text(objParam1, objPoloha, objRozmer1, objRozmer4, objParam2, objParam3, farbaHighlightObvod, objRozmer3 + rozsirenieGraviraHighlight, QPFont, objRozmer2)
end else if objParam2 = 'WIDTHALL' then begin
Text(objParam1, objPoloha, objRozmer4, objRozmer1, objParam2, objParam3, farbaHighlightObvod, objRozmer3 + rozsirenieGraviraHighlight, QPFont, objRozmer2)
end;
end;
/////////////////// gravirovana ciara
ftLine2Grav: begin
Ciara( objPoloha, MyPoint(objPoloha.X+objRozmer1, objPoloha.Y+objRozmer2), farbaHighlightObvod, objRozmer3 + rozsirenieGraviraHighlight )
end;
/////////////////// gravirovany obdlznik
ftRectGrav: begin
ObdlzObvod( objPoloha, objRozmer1, objRozmer2, objRozmer4, farbaHighlightObvod, PX(objRozmer3 + rozsirenieGraviraHighlight) )
end;
/////////////////// gravirovana kruznica
ftCircleGrav: begin // engraved shapes
KruzObvod( objPoloha, objRozmer1, farbaHighlightObvod, PX(objRozmer3 + rozsirenieGraviraHighlight) )
end;
/////////////////// zahlbenie kuzelove
ftSink: begin
// najprv kruh zahlbenia a nasledne kruh priechodzej diery
KruzObvod( objPoloha, objRozmer1, farbaHighlightObvod, 3);
end;
/////////////////// zahlbenie kuzelove specialne
ftSinkSpecial: begin
end;
/////////////////// zahlbenie valcove
ftSinkCyl: begin
// najprv kruh zahlbenia a nasledne kruh priechodzej diery
KruzObvod( objPoloha, objRozmer1, farbaHighlightObvod, 3 );
end;
/////////////////// drazka rovna
ftGrooveLin: begin
Ciara( objPoloha, MyPoint(objPoloha.X+objRozmer1, objPoloha.Y+objRozmer2), farbaHighlightObvod, objRozmer3 );
end;
/////////////////// drazka obluk
ftGrooveArc: begin
Obluk( objPoloha, objRozmer1, objRozmer2, objRozmer3, farbaHighlightObvod, PX(objRozmer4), (objParam1 = 'S') );
end;
end; // case
end;
{
Vrati string so vsetkymi moznymi info o objekte
}
function TFeatureObject.GetFeatureInfo(withID: boolean = false; withPosition: boolean = false; exploded: boolean = false): string;
var
jeToCombo: boolean;
strID, strName, strPosition: string;
begin
jeToCombo := (objComboID > -1);
// prinutime zobrazovat ID
if (jeToCombo) OR (objTyp=ftPolyLineGrav) then withID := true;
// zakaz zobrazovat polohu
if (objTyp = ftPolyLineGrav) then withPosition := false;
if withID then begin
if (jeToCombo) AND (exploded = false) then
strID := ' (id:'+IntToStr(objComboID)+')'
else
strID := ' (id:'+IntToStr(objID)+')';
end;
if (jeToCombo) AND (exploded = false) then
strName := TransTxt('Combo feature')
else
case objTyp of
ftHoleCirc: strName := TransTxt('Circular hole') + ' ' + FormatFloat('0.##', objRozmer1)+'mm';
ftHoleRect: strName := TransTxt('Rectangular hole') + ' ' + FormatFloat('0.##', objRozmer1)+ 'x' + FormatFloat('0.##', objRozmer2)+'mm, R='+ FormatFloat('0.##', objRozmer3);
ftPocketCirc: strName := TransTxt('Circular pocket') + ' ' + FormatFloat('0.##', objRozmer1)+'mm, H='+ FormatFloat('0.##', objHlbka1);
ftPocketRect: strName := TransTxt('Rectangular pocket') + ' ' + FormatFloat('0.##', objRozmer1)+ 'x' + FormatFloat('0.##', objRozmer2)+'mm, H='+FormatFloat('0.##', objHlbka1)+', R='+ FormatFloat('0.##', objRozmer3);
ftTxtGrav: strName := TransTxt('Engr.text') + ' ' + FormatFloat('0.##', objRozmer1)+'mm' + ' (' + FormatFloat('0.##', objRozmer3)+'mm)';
ftLine2Grav: strName := TransTxt('Engr.line') + ' (' + FormatFloat('0.##', objRozmer3)+'mm)';
ftRectGrav: strName := TransTxt('Engr.rectangle') + ' ' + FormatFloat('0.##', objRozmer1)+ 'x' + FormatFloat('0.##', objRozmer2)+'mm' + ' (' + FormatFloat('0.##', objRozmer3)+'mm)';
ftCircleGrav: strName := TransTxt('Engr.circle') + ' ' + FormatFloat('0.##', objRozmer1)+'mm' + ' (' + FormatFloat('0.##', objRozmer3)+'mm)';
ftPolyLineGrav: strName := TransTxt('Engr.polyline');
ftThread:
if (objHlbka1 = 9999) then
strName := TransTxt('Thread')+' ' + objParam1 + FloatToStr(objRozmer1)
else
strName := TransTxt('Thread')+' ' + objParam1 + FloatToStr(objRozmer1) + ', H=' + FormatFloat('0.##', objHlbka1);
ftSink: strName := TransTxt('Conical countersink') + ' M' + FormatFloat('0.##', objRozmer3);
ftSinkSpecial: strName := TransTxt('Conical countersink special');
ftSinkCyl: strName := TransTxt('Cylindrical countersink') + ' ' + FormatFloat('0.##', objRozmer1)+'/'+FormatFloat('0.##', objRozmer2)+', H='+FormatFloat('0.##', objRozmer3);
ftGrooveLin:
if (objHlbka1 = 9999) then
strName := TransTxt('Linear groove') + ' ' + FormatFloat('0.##', objRozmer3)+'mm'
else
strName := TransTxt('Linear groove') + ' ' + FormatFloat('0.##', objRozmer3)+'mm' + ', H=' + FormatFloat('0.##', objHlbka1);
ftGrooveArc:
if (objHlbka1 = 9999) then
strName := TransTxt('Arc groove') + ' ' + FormatFloat('0.##', objRozmer4)+'mm, D=' + FormatFloat('0.##', objRozmer1)
else
strName := TransTxt('Arc groove') + ' ' + FormatFloat('0.##', objRozmer4)+'mm, D=' + FormatFloat('0.##', objRozmer1) + ', H=' + FormatFloat('0.##', objHlbka1);
ftCosmeticCircle:
if objNazov = '' then strName := TransTxt('Cosmetic circle') + ' D=' + FormatFloat('0.##', objRozmer1)
else strName := objNazov;
ftCosmeticRect:
if objNazov = '' then strName := TransTxt('Cosmetic rectangle') + ' ' + FormatFloat('0.##', objRozmer1) + 'x' + FormatFloat('0.##', objRozmer2)
else strName := objNazov;
end; // case
if withPosition then begin
if (jeToCombo) AND (exploded = false) then
// ak je combo polohovane na svoj stred, polohu zober zo samotneho objektu combo
if (_PNL.GetComboByID(objComboID).PolohaObject = -1) then
strPosition := ' ['+
FormatFloat('0.00#', _PNL.getComboByID(objComboID).Poloha.X )+';'+
FormatFloat('0.00#', _PNL.getComboByID(objComboID).Poloha.Y )+
']'
// ak je polohovane na nejaky svoj prvok, zober polohu z neho
else
strPosition := ' ['+
FormatFloat('0.00#', _PNL.GetFeatureByID( _PNL.getComboByID(objComboID).PolohaObject ).X )+';'+
FormatFloat('0.00#', _PNL.GetFeatureByID( _PNL.getComboByID(objComboID).PolohaObject ).Y )+
']'
else
strPosition := ' ['+
FormatFloat('0.00#',objPoloha.X)+';'+
FormatFloat('0.00#',objPoloha.Y)+
']';
end;
result := strName + strID + strPosition;
end;
function TFeatureObject.IsOnPoint(bod_MM: TMyPoint): boolean;
begin
result := ( bod_MM.X > objBoundingRect.TopL.X ) AND
( bod_MM.X < objBoundingRect.BtmR.X ) AND
( bod_MM.Y < objBoundingRect.TopL.Y ) AND
( bod_MM.Y > objBoundingRect.BtmR.Y );
end;
procedure TFeatureObject.MirrorFeature(var parentPanel: TObject; smer: char = 'x');
var
dist: double;
tmp: double;
begin
// "smer" znamena v akom smere zrkadlit (nie okolo ktorej osi)
if (smer = 'x') then begin
(parentPanel as TPanelObject).CurrentSide := objStrana;
case (parentPanel as TPanelObject).CenterPos of
cpCEN:
objPoloha.X := -objPoloha.X;
cpLB,
cpLT : begin
dist := ((parentPanel as TPanelObject).Sirka/2) - objPoloha.X;
objPoloha.X := objPoloha.X + (2*dist);
end;
cpRB,
cpRT : begin
dist := -((parentPanel as TPanelObject).Sirka/2) - objPoloha.X;
objPoloha.X := objPoloha.X + (2*dist);
end;
end; // case
case objTyp of
ftGrooveLin: objRozmer1 := -objRozmer1;
ftGrooveArc: begin
if (objRozmer2 >= 0) AND (objRozmer2 < 180) then
objRozmer2 := objRozmer2 + 2*(90-objRozmer2)
else if (objRozmer2 >= 180) AND (objRozmer2 < 360) then
objRozmer2 := objRozmer2 + 2*(270-objRozmer2);
if objRozmer2 >= 360 then
objRozmer2 := objRozmer2 - 360;
if (objRozmer3 >= 0) AND (objRozmer3 < 180) then
objRozmer3 := objRozmer3 + 2*(90-objRozmer3)
else if (objRozmer3 >= 180) AND (objRozmer3 < 360) then
objRozmer3 := objRozmer3 + 2*(270-objRozmer3);
if objRozmer3 >= 360 then
objRozmer3 := objRozmer3 - 360;
// este vymenime medzi sebou tieto dva udaje, lebo obluk sa kresli vzdy CCW
tmp := objRozmer2;
objRozmer2 := objRozmer3;
objRozmer3 := tmp;
end;
end; // case
end; // if (smer = 'x')
AdjustBoundingBox;
end;
procedure TFeatureObject.StartEditing;
begin
// ak boli zobrazene "multiselect" tlacitka, ktorymi som vybral objekt na editovanie,
// tu ich skryjeme (znicime)
if MultiselectTlacitka.DoubleClickWaiting then begin
MultiselectTlacitka.Clear;
end;
case objTyp of
// podla typu objektu sa otvori okno na editovanie
ftHoleCirc, ftHoleRect: begin
fFeaHole.EditFeature( objID );
fFeaHole.ShowModal;
end;
ftPocketCirc, ftPocketRect: begin
fFeaPocket.EditFeature( objID );
fFeaPocket.ShowModal;
end;
ftThread: begin
fFeaThread.EditFeature( objID );
fFeaThread.ShowModal;
end;
ftTxtGrav, ftLine2Grav, ftRectGrav, ftCircleGrav: begin
fFeaEngraving.EditFeature( objID );
fFeaEngraving.ShowModal;
end;
ftSink, ftSinkSpecial, ftSinkCyl: begin
fFeaConus.EditFeature( objID );
fFeaConus.ShowModal;
end;
ftGrooveLin, ftGrooveArc: begin
fFeaGroove.EditFeature( objID );
fFeaGroove.ShowModal;
end;
ftCosmeticCircle, ftCosmeticRect: begin
fFeaCosmetic.EditFeature( objID );
fFeaCosmetic.ShowModal;
end;
end; // case
end;
end.
|
unit formLogo;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, RzLabel, dxGDIPlusClasses,
Vcl.ExtCtrls, cxGraphics, cxControls, cxLookAndFeels, cxLookAndFeelPainters,
cxContainer, cxEdit, cxProgressBar, IdComponent, Vcl.XPMan;
type
TfrmLogo = class(TForm)
img1: TImage;
Info: TRzLabel;
Shape1: TShape;
ProgressBar: TcxProgressBar;
XPManifest1: TXPManifest;
private
procedure SetInfo(AValue: string);
function GetInfo: string;
public
property InfoText: string read GetInfo write SetInfo;
procedure RefreshForm;
procedure HTTPWork(ASender: TObject; AWorkMode: TWorkMode; AWorkCount: Int64);
procedure HTTPWorkBegin(ASender: TObject; AWorkMode: TWorkMode; AWorkCountMax: Int64);
procedure HTTPWorkEnd(ASender: TObject; AWorkMode: TWorkMode);
end;
var
frmLogo: TfrmLogo;
implementation
{$R *.dfm}
{ TfrmLogo }
function TfrmLogo.GetInfo: string;
begin
Result := Info.Caption;
end;
procedure TfrmLogo.RefreshForm;
begin
BringWindowToTop(self.Handle);
self.Repaint;
end;
procedure TfrmLogo.SetInfo(AValue: string);
begin
Self.info.Caption := AValue;
Info.Alignment := taCenter;
RefreshForm;
end;
procedure TfrmLogo.HTTPWork(ASender: TObject; AWorkMode: TWorkMode;
AWorkCount: Int64);
begin
self.ProgressBar.Position := AWorkCount;
self.RefreshForm;
end;
procedure TfrmLogo.HTTPWorkBegin(ASender: TObject; AWorkMode: TWorkMode;
AWorkCountMax: Int64);
begin
Self.Info.Caption := 'Загрузка новой версии';
Self.ProgressBar.Properties.Max:= AWorkCountMax;
end;
procedure TfrmLogo.HTTPWorkEnd(ASender: TObject; AWorkMode: TWorkMode);
begin
Self.ProgressBar.Visible := False;
InfoText := 'Загрузка завершена';
end;
end.
|
{ *************************************************************************** }
{ }
{ Delphi and Kylix Cross-Platform Visual Component Library }
{ Internet Application Runtime }
{ }
{ Copyright (C) 1997, 2002 Borland Software Corporation }
{ }
{ Licensees holding a valid Borland No-Nonsense License for this Software may }
{ use this file in accordance with such license, which appears in the file }
{ license.txt that came with this Software. }
{ }
{ *************************************************************************** }
unit HTTPApp;
interface
uses SysUtils, Classes, Masks, Contnrs;
const
sDateFormat = '"%s", dd "%s" yyyy hh:mm:ss';
MAX_STRINGS = 12;
MAX_INTEGERS = 1;
MAX_DATETIMES = 3;
type
TWebExceptionEvent = procedure (Sender: TObject; E: Exception; var Handled: Boolean) of object;
TMethodType = (mtAny, mtGet, mtPut, mtPost, mtHead);
{ Forward declaration }
TWebResponse = class;
{ TWebRequest }
TAbstractContentParser = class;
TAbstractWebRequestFiles = class;
TWebRequest = class(TObject)
private
FContentParser: TAbstractContentParser;
FMethodType: TMethodType;
FContentFields,
FCookieFields,
FQueryFields: TStrings;
function GetContentParser: TAbstractContentParser;
function GetContentFields: TStrings;
function GetCookieFields: TStrings;
function GetQueryFields: TStrings;
function GetFiles: TAbstractWebRequestFiles;
protected
function GetStringVariable(Index: Integer): string; virtual; abstract;
function GetDateVariable(Index: Integer): TDateTime; virtual; abstract;
function GetIntegerVariable(Index: Integer): Integer; virtual; abstract;
function GetInternalPathInfo: string; virtual;
function GetInternalScriptName: string; virtual;
procedure UpdateMethodType;
public
constructor Create;
destructor Destroy; override;
// Read count bytes from client
function ReadClient(var Buffer; Count: Integer): Integer; virtual; abstract;
// Read count characters as a string from client
function ReadString(Count: Integer): string; virtual; abstract;
// Translate a relative URI to a local absolute path
function TranslateURI(const URI: string): string; virtual; abstract;
// Write count bytes back to client
function WriteClient(var Buffer; Count: Integer): Integer; virtual; abstract;
// Write string contents back to client
function WriteString(const AString: string): Boolean; virtual; abstract;
// Write HTTP header string
function WriteHeaders(StatusCode: Integer; const ReasonString, Headers: string): Boolean; virtual; abstract;
// Utility to extract fields from a given string buffer
procedure ExtractFields(Separators, WhiteSpace: TSysCharSet;
Content: PChar; Strings: TStrings);
// Fills the given string list with the content fields as the result
// of a POST method
procedure ExtractContentFields(Strings: TStrings);
// Fills the given string list with values from the cookie header field
procedure ExtractCookieFields(Strings: TStrings);
// Fills the given TStrings with the values from the Query data
// (ie: data following the "?" in the URL)
procedure ExtractQueryFields(Strings: TStrings);
// Read an arbitrary HTTP/Server Field not lists here
function GetFieldByName(const Name: string): string; virtual; abstract;
// The request method as an enumeration
property MethodType: TMethodType read FMethodType;
// Content parser
property ContentParser: TAbstractContentParser read GetContentParser;
// Field lists
property ContentFields: TStrings read GetContentFields;
property CookieFields: TStrings read GetCookieFields;
property QueryFields: TStrings read GetQueryFields;
// HTTP header Fields
property Method: string index 0 read GetStringVariable;
property ProtocolVersion: string index 1 read GetStringVariable;
property URL: string index 2 read GetStringVariable;
property Query: string index 3 read GetStringVariable;
property PathInfo: string index 4 read GetStringVariable;
property PathTranslated: string index 5 read GetStringVariable;
property Authorization: string index 28 read GetStringVariable;
property CacheControl: string index 6 read GetStringVariable;
property Cookie: string index 27 read GetStringVariable;
property Date: TDateTime index 7 read GetDateVariable;
property Accept: string index 8 read GetStringVariable;
property From: string index 9 read GetStringVariable;
property Host: string index 10 read GetStringVariable;
property IfModifiedSince: TDateTime index 11 read GetDateVariable;
property Referer: string index 12 read GetStringVariable;
property UserAgent: string index 13 read GetStringVariable;
property ContentEncoding: string index 14 read GetStringVariable;
property ContentType: string index 15 read GetStringVariable;
property ContentLength: Integer index 16 read GetIntegerVariable;
property ContentVersion: string index 17 read GetStringVariable;
property Content: string index 25 read GetStringVariable;
property Connection: string index 26 read GetStringVariable;
property DerivedFrom: string index 18 read GetStringVariable;
property Expires: TDateTime index 19 read GetDateVariable;
property Title: string index 20 read GetStringVariable;
property RemoteAddr: string index 21 read GetStringVariable;
property RemoteHost: string index 22 read GetStringVariable;
property ScriptName: string index 23 read GetStringVariable;
property ServerPort: Integer index 24 read GetIntegerVariable;
property InternalPathInfo: string read GetInternalPathInfo;
property InternalScriptName: string read GetInternalScriptName;
property Files: TAbstractWebRequestFiles read GetFiles;
end;
TAbstractContentParser = class(TObject)
private
FWebRequest: TWebRequest;
protected
property WebRequest: TWebRequest read FWebRequest;
function GetContentFields: TStrings; virtual; abstract;
function GetFiles: TAbstractWebRequestFiles; virtual; abstract;
public
constructor Create(AWebRequest: TWebRequest); virtual;
class function CanParse(AWebRequest: TWebRequest): Boolean; virtual;
end;
TContentParser = class(TAbstractContentParser)
private
FContentFields: TStrings;
FFiles: TAbstractWebRequestFiles;
public
destructor Destroy; override;
function GetContentFields: TStrings; override;
function GetFiles: TAbstractWebRequestFiles; override;
class function CanParse(AWebRequest: TWebRequest): Boolean; override;
end;
TContentParserClass = class of TAbstractContentParser;
TAbstractWebRequestFile = class;
TAbstractWebRequestFiles = class(TObject)
protected
function GetCount: Integer; virtual; abstract;
function GetItem(I: Integer): TAbstractWebRequestFile; virtual; abstract;
public
property Items[I: Integer]: TAbstractWebRequestFile read GetItem; default;
property Count: Integer read GetCount;
end;
TAbstractWebRequestFile = class(TObject)
protected
function GetFieldName: string; virtual; abstract;
function GetFileName: string; virtual; abstract;
function GetStream: TStream; virtual; abstract;
function GetContentType: string; virtual; abstract;
public
property FieldName: string read GetFieldName;
property FileName: string read GetFileName;
property Stream: TStream read GetStream;
property ContentType: string read GetContentType;
end;
{ TCookie }
TCookie = class(TCollectionItem)
private
FName: string;
FValue: string;
FPath: string;
FDomain: string;
FExpires: TDateTime;
FSecure: Boolean;
protected
function GetHeaderValue: string;
public
constructor Create(Collection: TCollection); override;
procedure AssignTo(Dest: TPersistent); override;
property Name: string read FName write FName;
property Value: string read FValue write FValue;
property Domain: string read FDomain write FDomain;
property Path: string read FPath write FPath;
property Expires: TDateTime read FExpires write FExpires;
property Secure: Boolean read FSecure write FSecure;
property HeaderValue: string read GetHeaderValue;
end;
{ TCookieCollection }
TCookieCollection = class(TCollection)
private
FWebResponse: TWebResponse;
protected
function GetCookie(Index: Integer): TCookie;
procedure SetCookie(Index: Integer; Cookie: TCookie);
public
constructor Create(WebResponse: TWebResponse; ItemClass: TCollectionItemClass);
function Add: TCookie;
property WebResponse: TWebResponse read FWebResponse;
property Items[Index: Integer]: TCookie read GetCookie write SetCookie; default;
end;
{ TWebResponse }
TWebResponse = class(TObject)
private
FContentStream: TStream;
FCookies: TCookieCollection;
procedure SetCustomHeaders(Value: TStrings);
protected
FHTTPRequest: TWebRequest;
FCustomHeaders: TStrings;
procedure AddCustomHeaders(var Headers: string);
function GetStringVariable(Index: Integer): string; virtual; abstract;
procedure SetStringVariable(Index: Integer; const Value: string); virtual; abstract;
function GetDateVariable(Index: Integer): TDateTime; virtual; abstract;
procedure SetDateVariable(Index: Integer; const Value: TDateTime); virtual; abstract;
function GetIntegerVariable(Index: Integer): Integer; virtual; abstract;
procedure SetIntegerVariable(Index: Integer; Value: Integer); virtual; abstract;
function GetContent: string; virtual; abstract;
procedure SetContent(const Value: string); virtual; abstract;
procedure SetContentStream(Value: TStream); virtual;
function GetStatusCode: Integer; virtual; abstract;
procedure SetStatusCode(Value: Integer); virtual; abstract;
function GetLogMessage: string; virtual; abstract;
procedure SetLogMessage(const Value: string); virtual; abstract;
function FormatAuthenticate: string;
public
constructor Create(HTTPRequest: TWebRequest);
destructor Destroy; override;
function GetCustomHeader(const Name: string): String;
procedure SendResponse; virtual; abstract;
procedure SendRedirect(const URI: string); virtual; abstract;
procedure SendStream(AStream: TStream); virtual; abstract;
function Sent: Boolean; virtual;
procedure SetCookieField(Values: TStrings; const ADomain, APath: string;
AExpires: TDateTime; ASecure: Boolean);
procedure SetCustomHeader(const Name, Value: string);
property Cookies: TCookieCollection read FCookies;
property HTTPRequest: TWebRequest read FHTTPRequest;
property Version: string index 0 read GetStringVariable write SetStringVariable;
property ReasonString: string index 1 read GetStringVariable write SetStringVariable;
property Server: string index 2 read GetStringVariable write SetStringVariable;
property WWWAuthenticate: string index 3 read GetStringVariable write SetStringVariable;
property Realm: string index 4 read GetStringVariable write SetStringVariable;
property Allow: string index 5 read GetStringVariable write SetStringVariable;
property Location: string index 6 read GetStringVariable write SetStringVariable;
property ContentEncoding: string index 7 read GetStringVariable write SetStringVariable;
property ContentType: string index 8 read GetStringVariable write SetStringVariable;
property ContentVersion: string index 9 read GetStringVariable write SetStringVariable;
property DerivedFrom: string index 10 read GetStringVariable write SetStringVariable;
property Title: string index 11 read GetStringVariable write SetStringVariable;
property StatusCode: Integer read GetStatusCode write SetStatusCode;
property ContentLength: Integer index 0 read GetIntegerVariable write SetIntegerVariable;
property Date: TDateTime index 0 read GetDateVariable write SetDateVariable;
property Expires: TDateTime index 1 read GetDateVariable write SetDateVariable;
property LastModified: TDateTime index 2 read GetDateVariable write SetDateVariable;
property Content: string read GetContent write SetContent;
property ContentStream: TStream read FContentStream write SetContentStream;
property LogMessage: string read GetLogMessage write SetLogMessage;
property CustomHeaders: TStrings read FCustomHeaders write SetCustomHeaders;
end;
TAbstractWebSession = class(TObject)
protected
function GetValue(const AName: string): Variant; virtual; abstract;
procedure SetValue(const AName: string; const AValue: Variant); virtual; abstract;
function GetTimeoutMinutes: Integer; virtual; abstract;
procedure SetTimeoutMinutes(AValue: Integer); virtual; abstract;
function GetSessionID: string; virtual; abstract;
public
procedure UpdateResponse(AResponse: TWebResponse); virtual; abstract;
procedure Terminate; virtual; abstract;
property TimeoutMinutes: Integer read GetTimeoutMinutes write SetTimeoutMinutes;
property Values[const AName: string]: Variant read GetValue write SetValue;
property SessionID: string read GetSessionID;
end;
{ TWebDispatcherEditor }
TCustomWebDispatcher = class;
TCustomContentProducer = class;
ISetAppDispatcher = interface
['{2F5E959E-DA65-11D3-A411-00C04F6BB853}']
procedure SetAppDispatcher(const ADispatcher: TComponent);
end;
IGetAppDispatcher = interface
['{2BF38474-E821-11D4-A54A-00C04F6BB853}']
function GetAppDispatcher: TComponent;
end;
IProduceContent = interface
['{AAFA17B7-E814-11D4-A54A-00C04F6BB853}']
function ProduceContent: string;
end;
IProduceContentFrom = interface
['{AA0CC875-E81B-11D4-A54A-00C04F6BB853}']
function ProduceContentFromStream(Stream: TStream): string;
function ProduceContentFromString(const S: string): string;
end;
TAbstractWebModuleList = class;
IMultiModuleSupport = interface
['{06F13260-8FF8-11D4-A4E5-00C04F6BB853}']
procedure InitContext(Request: TWebRequest; Response: TWebResponse);
procedure InitModule(AModule: TComponent);
procedure FinishContext;
end;
IWebAppServices = interface
['{D62F1586-E307-11D3-A418-00C04F6BB853}']
procedure InitContext(WebModuleList: TAbstractWebModuleList; Request: TWebRequest;
Response: TWebResponse);
function HandleRequest: Boolean;
procedure FinishContext;
function GetExceptionHandler: TObject;
property ExceptionHandler: TObject read GetExceptionHandler;
end;
IWebExceptionHandler = interface
['{7664268F-9629-11D4-A4EC-00C04F6BB853}']
procedure HandleException(E: Exception; var Handled: Boolean);
end;
IGetWebAppServices = interface
['{5CF7B3BD-DAB0-D511-99A8-0050568E0E44}']
function GetWebAppServices: IWebAppServices;
end;
IWebRequestHandler = interface
['{6FCCB05F-8FE0-11D4-A4E5-00C04F6BB853}']
function HandleRequest(Request: TWebRequest; Response: TWebResponse): Boolean;
end;
// Indicates dispatch actions container
IWebDispatchActions = interface
['{E4444CD8-9FAE-D511-8D38-0050568E0E44}']
end;
IGetWebRequestHandler = interface
['{6FCCB060-8FE0-11D4-A4E5-00C04F6BB853}']
function GetWebRequestHandler: IWebRequestHandler;
end;
IWebDispatcherAccess = interface
['{144CD1DF-9FAE-D511-8D38-0050568E0E44}']
function Request: TWebRequest;
function Response: TWebResponse;
end;
{ TCustomContentProducer }
TCustomContentProducer = class(TComponent, ISetAppDispatcher, IGetAppDispatcher, IProduceContent, IProduceContentFrom)
private
FDispatcher: TComponent;
function GetDispatcher: IWebDispatcherAccess;
procedure SetDispatcher(Value: TComponent);
protected
{ IProduceContent }
function ProduceContent: string;
{ IProduceContentFrom }
function ProduceContentFromStream(Stream: TStream): string;
function ProduceContentFromString(const S: string): string;
{ ISetAppDispatcher }
procedure SetAppDispatcher(const ADispatcher: TComponent);
{ IGetAppDispatcher }
function GetAppDispatcher: TComponent;
procedure Notification(AComponent: TComponent; Operation: TOperation); override;
public
function Content: string; virtual;
function ContentFromStream(Stream: TStream): string; virtual;
function ContentFromString(const S: string): string; virtual;
property Dispatcher: IWebDispatcherAccess read GetDispatcher;
property DispatcherComponent: TComponent read FDispatcher;
end;
{ TWebActionItem }
THTTPMethodEvent = procedure (Sender: TObject; Request: TWebRequest;
Response: TWebResponse; var Handled: Boolean) of object;
TWebActionItem = class(TCollectionItem)
private
FOnAction: THTTPMethodEvent;
FPathInfo: string;
FMethodType: TMethodType;
FDefault: Boolean;
FEnabled: Boolean;
FMaskPathInfo: string;
FMask: TMask;
FName: string;
FProducer: TCustomContentProducer;
FProducerContent: TComponent;
function DispatchAction(Request: TWebRequest; Response: TWebResponse;
DoDefault: Boolean): Boolean;
procedure SetDefault(Value: Boolean);
procedure SetEnabled(Value: Boolean);
procedure SetMethodType(Value: TMethodType);
procedure SetOnAction(Value: THTTPMethodEvent);
procedure SetPathInfo(const Value: string);
procedure SetProducer(const Value: TCustomContentProducer);
function GetMask: TMask;
function ProducerPathInfo: string;
procedure SetProducerContent(const Value: TComponent);
protected
function GetDisplayName: string; override;
procedure SetDisplayName(const Value: string); override;
function GetPathInfo: string;
public
constructor Create(Collection: TCollection); override;
destructor Destroy; override;
procedure AssignTo(Dest: TPersistent); override;
published
property Default: Boolean read FDefault write SetDefault default False;
property Enabled: Boolean read FEnabled write SetEnabled default True;
property MethodType: TMethodType read FMethodType write SetMethodType default mtAny;
property Name: string read GetDisplayName write SetDisplayName;
property PathInfo: string read GetPathInfo write SetPathInfo;
property Producer: TCustomContentProducer read FProducer write SetProducer;
property ProducerContent: TComponent read FProducerContent write SetProducerContent;
property OnAction: THTTPMethodEvent read FOnAction write SetOnAction;
end;
{ TWebActionItems }
TWebActionItems = class(TCollection)
private
FWebDispatcher: TCustomWebDispatcher;
function GetActionItem(Index: Integer): TWebActionItem;
procedure SetActionItem(Index: Integer; Value: TWebActionItem);
protected
function GetAttrCount: Integer; override;
function GetAttr(Index: Integer): string; override;
function GetItemAttr(Index, ItemIndex: Integer): string; override;
function GetOwner: TPersistent; override;
procedure SetItemName(Item: TCollectionItem); override;
procedure Update(Item: TCollectionItem); override;
public
constructor Create(WebDispatcher: TCustomWebDispatcher;
ItemClass: TCollectionItemClass);
function Add: TWebActionItem;
property WebDispatcher: TCustomWebDispatcher read FWebDispatcher;
property Items[Index: Integer]: TWebActionItem read GetActionItem
write SetActionItem; default;
end;
{ IWebDispatch }
IWebDispatch = interface
['{E6D33BE4-9FAE-D511-8D38-0050568E0E44}']
function DispatchEnabled: Boolean;
function DispatchMethodType: TMethodType;
function DispatchRequest(Sender: TObject; Request: TWebRequest; Response: TWebResponse): Boolean;
function DispatchMask: TMask;
property Enabled: Boolean read DispatchEnabled;
property MethodType: TMethodType read DispatchMethodType;
property Mask: TMask read DispatchMask;
end;
{ TCustomWebDispatcher }
TCustomWebDispatcher = class(TDataModule, IWebRequestHandler, IWebDispatchActions, IWebDispatcherAccess,
IMultiModuleSupport, IWebExceptionHandler)
private
FRequest: TWebRequest;
FResponse: TWebResponse;
FActions: TWebActionItems;
FBeforeDispatch: THTTPMethodEvent;
FAfterDispatch: THTTPMethodEvent;
FDispatchList: TComponentList;
FOnException: TWebExceptionEvent;
function GetAction(Index: Integer): TWebActionItem;
procedure SetActions(Value: TWebActionItems);
function GetRequest: TWebRequest;
function GetResponse: TWebResponse;
protected
{ IWebRequestHandler }
function HandleRequest(Request: TWebRequest; Response: TWebResponse): Boolean;
{ IMultiModuleSupport }
procedure InitContext(Request: TWebRequest; Response: TWebResponse);
procedure InitModule(AModule: TComponent);
procedure FinishContext;
{ IWebDispatcherAccess }
function Access_Request: TWebRequest;
function Access_Response: TWebResponse;
function IWebDispatcherAccess.Request = Access_Request;
function IWebDispatcherAccess.Response = Access_Response;
{ IWebExceptionHandler }
procedure HandleException(E: Exception; var Handled: Boolean);
function DoAfterDispatch(Request: TWebRequest; Response: TWebResponse): Boolean;
function DoBeforeDispatch(Request: TWebRequest; Response: TWebResponse): Boolean;
function DispatchAction(Request: TWebRequest;
Response: TWebResponse): Boolean;
procedure Notification(AComponent: TComponent; Operation: TOperation); override;
property BeforeDispatch: THTTPMethodEvent read FBeforeDispatch write FBeforeDispatch;
property AfterDispatch: THTTPMethodEvent read FAfterDispatch write FAfterDispatch;
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
function ActionByName(const AName: string): TWebActionItem;
property Actions: TWebActionItems read FActions write SetActions;
property Action[Index: Integer]: TWebActionItem read GetAction;
property Request: TWebRequest read GetRequest;
property Response: TWebResponse read GetResponse;
property OnException: TWebExceptionEvent read FOnException write FOnException;
end;
{ TWebDispatcher }
TWebDispatcher = class(TCustomWebDispatcher)
published
property Actions;
property BeforeDispatch;
property AfterDispatch;
property OnException;
end;
{ TWebModuleContext }
TWebModuleContext = TObject;
{ TWebModule }
TWebModule = class(TCustomWebDispatcher)
public
constructor Create(AOwner: TComponent); override;
published
property Actions;
property BeforeDispatch;
property AfterDispatch;
property OnException;
end;
TAbstractWebPageInfo = class;
TWebModuleCreateMode = (crOnDemand, crAlways);
TWebModuleCacheMode = (caCache, caDestroy);
TAbstractWebModuleFactory = class
protected
function GetModuleName: string; virtual; abstract;
function GetIsAppModule: Boolean; virtual; abstract;
function GetCreateMode: TWebModuleCreateMode; virtual; abstract;
function GetCacheMode: TWebModuleCacheMode; virtual; abstract;
function GetComponentClass: TComponentClass; virtual; abstract;
function GetWebPageInfo: TAbstractWebPageInfo; virtual;
public
function GetModule: TComponent; virtual; abstract;
procedure PreventDestruction; virtual; abstract;
property ModuleName: string read GetModuleName;
property IsAppModule: Boolean read GetIsAppModule;
property ComponentClass: TComponentClass read GetComponentClass;
property CreateMode: TWebModuleCreateMode read GetCreateMode;
property CacheMode: TWebModuleCacheMode read GetCacheMode;
property WebPageInfo: TAbstractWebPageInfo read GetWebPageInfo;
end;
TAbstractWebPageModuleFactory = class(TAbstractWebModuleFactory)
private
FWebPageInfo: TAbstractWebPageInfo;
protected
function GetWebPageInfo: TAbstractWebPageInfo; override;
public
constructor Create(AWebPageInfo: TAbstractWebPageInfo);
destructor Destroy; override;
end;
TAbstractWebPageInfo = class
private
FFactory: TAbstractWebPageModuleFactory;
protected
function GetPageFile: string; virtual; abstract;
function GetPageHREF: string; virtual;
function GetPageName: string; virtual; abstract;
function GetPageDescription: string; virtual;
function GetPageTitle: string; virtual;
function GetIsPublished: Boolean; virtual;
function GetIsLoginRequired: Boolean; virtual;
function GetViewAccess: string; virtual;
function GetFactory: TAbstractWebPageModuleFactory;
procedure SetFactory(AFactory: TAbstractWebPageModuleFactory); virtual;
public
property PageHREF: string read GetPageHREF;
property PageDescription: string read GetPageDescription;
property PageTitle: string read GetPageTitle;
property PageName: string read GetPageName;
property IsPublished: Boolean read GetIsPublished;
property IsLoginRequired: Boolean read GetIsLoginRequired;
property PageFile: string read GetPageFile;
property ViewAccess: string read GetViewAccess;
property Factory: TAbstractWebPageModuleFactory read GetFactory write SetFactory;
end;
TModuleAddedProc = procedure(AWebModule: TComponent) of object;
TAbstractWebModuleList = class(TObject)
protected
function GetItem(I: Integer): TComponent; virtual; abstract;
function GetItemCount: Integer; virtual; abstract;
function GetOnModuleAdded: TModuleAddedProc; virtual; abstract;
procedure SetOnModuleAdded(AProc: TModuleAddedProc); virtual; abstract;
function GetFactoryCount: Integer; virtual; abstract;
function GetFactory(I: Integer): TAbstractWebModuleFactory; virtual; abstract;
public
function FindModuleClass(AClass: TComponentClass): TComponent; virtual; abstract;
function FindModuleName(const AClass: string): TComponent; virtual; abstract;
function AddModuleClass(AClass: TComponentClass): TComponent; virtual; abstract;
function AddModuleName(const AClass: string): TComponent; virtual; abstract;
property Items[I: Integer]: TComponent read GetItem; default;
property ItemCount: Integer read GetItemCount;
property FactoryCount: Integer read GetFactoryCount;
property Factory[I: Integer]: TAbstractWebModuleFactory read GetFactory;
property OnModuleAdded: TModuleAddedProc read GetOnModuleAdded write SetOnModuleAdded;
end;
TDefaultWebAppServices = class(TInterfacedObject, IWebAppServices)
private
FRequestHandler: IWebRequestHandler;
FRequest: TWebRequest;
FWebModules: TAbstractWebModuleList;
FResponse: TWebResponse;
function FindWebDispatcher: TComponent;
protected
{ IWebAppServices }
procedure InitContext(WebModuleList: TAbstractWebModuleList; Request: TWebRequest;
Response: TWebResponse);
procedure FinishContext;
function HandleRequest: Boolean;
function GetExceptionHandler: TObject;
function InvokeDispatcher: Boolean;
function FindRequestHandler: IWebRequestHandler; virtual;
function GetRequestHandler: IWebRequestHandler;
property Request: TWebRequest read FRequest;
property Response: TWebResponse read FResponse;
property WebModules: TAbstractWebModuleList read FWebModules;
property RequestHandler: IWebRequestHandler read GetRequestHandler;
end;
EWebBrokerException = class(Exception)
end;
function DosPathToUnixPath(const Path: string): string;
function HTTPDecode(const AStr: String): string;
function HTTPEncode(const AStr: String): string;
function HTMLEncode(const AStr: String): String;
function HTMLDecode(const AStr: String): String;
function ParseDate(const DateStr: string): TDateTime;
procedure ExtractHTTPFields(Separators, WhiteSpace: TSysCharSet; Content: PChar;
Strings: TStrings; StripQuotes: Boolean = False);
procedure ExtractHeaderFields(Separators, WhiteSpace: TSysCharSet; Content: PChar;
Strings: TStrings; Decode: Boolean; StripQuotes: Boolean = False);
function StatusString(StatusCode: Integer): string;
function UnixPathToDosPath(const Path: string): string;
function MonthStr(DateTime: TDateTime): string;
function DayOfWeekStr(DateTime: TDateTime): string;
procedure RegisterContentParser(AClass: TContentParserClass);
implementation
uses WebConst, BrkrConst;
var
FContentParsers: TList;
function ContentParsers: TList;
begin
if FContentParsers = nil then
FContentParsers := TClassList.Create;
Result := FContentParsers;
end;
procedure RegisterContentParser(AClass: TContentParserClass);
begin
ContentParsers.Add(AClass);
end;
{ TWebRequest }
constructor TWebRequest.Create;
begin
inherited Create;
UpdateMethodType;
end;
procedure TWebRequest.UpdateMethodType;
begin
if CompareText(Method, 'GET') = 0 then { do not localize }
FMethodType := mtGet
else if CompareText(Method, 'PUT') = 0 then { do not localize }
FMethodType := mtPut
else if CompareText(Method, 'POST') = 0 then { do not localize }
FMethodType := mtPost
else if CompareText(Method, 'HEAD') = 0 then { do not localize }
FMethodType := mtHead;
end;
destructor TWebRequest.Destroy;
begin
FContentFields.Free;
FCookieFields.Free;
FQueryFields.Free;
FContentParser.Free;
inherited Destroy;
end;
procedure TWebRequest.ExtractFields(Separators, WhiteSpace: TSysCharSet;
Content: PChar; Strings: TStrings);
begin
ExtractHTTPFields(Separators, WhiteSpace, Content, Strings);
end;
procedure TWebRequest.ExtractContentFields(Strings: TStrings);
var
ContentStr: string;
begin
if ContentLength > 0 then
begin
ContentStr := Content;
if Length(ContentStr) < ContentLength then
ContentStr := ContentStr + ReadString(ContentLength - Length(ContentStr));
ExtractFields(['&'], [], PChar(ContentStr), Strings);
end;
end;
procedure TWebRequest.ExtractCookieFields(Strings: TStrings);
var
CookieStr: string;
begin
CookieStr := Cookie;
ExtractHeaderFields([';'], [' '], PChar(CookieStr), Strings, True);
end;
procedure TWebRequest.ExtractQueryFields(Strings: TStrings);
var
ContentStr: string;
begin
ContentStr := Query;
ExtractFields(['&'], [], PChar(ContentStr), Strings);
end;
function TWebRequest.GetContentFields: TStrings;
begin
Result := ContentParser.GetContentFields;
end;
function TWebRequest.GetCookieFields: TStrings;
begin
if FCookieFields = nil then
begin
FCookieFields := TStringList.Create;
ExtractCookieFields(FCookieFields);
end;
Result := FCookieFields;
end;
function TWebRequest.GetQueryFields: TStrings;
begin
if FQueryFields = nil then
begin
FQueryFields := TStringList.Create;
ExtractQueryFields(FQueryFields);
end;
Result := FQueryFields;
end;
function TWebRequest.GetInternalPathInfo: string;
begin
Result := PathInfo;
end;
function TWebRequest.GetInternalScriptName: string;
begin
Result := ScriptName;
end;
function TWebRequest.GetFiles: TAbstractWebRequestFiles;
begin
Result := ContentParser.GetFiles;
end;
function TWebRequest.GetContentParser: TAbstractContentParser;
var
I: Integer;
C: TContentParserClass;
begin
if FContentParser = nil then
begin
for I := ContentParsers.Count - 1 downto 0 do
begin
C := TContentParserClass(ContentParsers[I]);
if C.CanParse(Self) then
begin
FContentParser := C.Create(Self);
Break;
end;
end;
end;
if FContentParser = nil then
FContentParser := TContentParser.Create(Self);
Result := FContentParser;
end;
{ TCookie }
constructor TCookie.Create(Collection: TCollection);
begin
inherited Create(Collection);
FExpires := -1;
end;
procedure TCookie.AssignTo(Dest: TPersistent);
begin
if Dest is TCookie then
with TCookie(Dest) do
begin
Name := Self.FName;
Value := Self.FValue;
Domain := Self.FDomain;
Path := Self.FPath;
Expires := Self.FExpires;
Secure := Self.FSecure;
end else inherited AssignTo(Dest);
end;
function TCookie.GetHeaderValue: string;
begin
Result := Format('%s=%s; ', [HTTPEncode(FName), HTTPEncode(FValue)]);
if Domain <> '' then
Result := Result + Format('domain=%s; ', [Domain]); { do not localize }
if Path <> '' then
Result := Result + Format('path=%s; ', [Path]); { do not localize }
if Expires > -1 then
Result := Result +
Format(FormatDateTime('"expires="' + sDateFormat + ' "GMT; "', Expires), { do not localize }
[DayOfWeekStr(Expires), MonthStr(Expires)]);
if Secure then Result := Result + 'secure'; { do not localize }
if Copy(Result, Length(Result) - 1, MaxInt) = '; ' then
SetLength(Result, Length(Result) - 2);
end;
{ TCookieCollection }
constructor TCookieCollection.Create(WebResponse: TWebResponse; ItemClass: TCollectionItemClass);
begin
inherited Create(ItemClass);
FWebResponse := WebResponse;
end;
function TCookieCollection.Add: TCookie;
begin
Result := TCookie(inherited Add);
end;
function TCookieCollection.GetCookie(Index: Integer): TCookie;
begin
Result := TCookie(inherited Items[Index]);
end;
procedure TCookieCollection.SetCookie(Index: Integer; Cookie: TCookie);
begin
Items[Index].Assign(Cookie);
end;
{ TWebResponse }
constructor TWebResponse.Create(HTTPRequest: TWebRequest);
begin
inherited Create;
FHTTPRequest := HTTPRequest;
FCustomHeaders := TStringList.Create;
FCookies := TCookieCollection.Create(Self, TCookie);
end;
destructor TWebResponse.Destroy;
begin
FContentStream.Free;
FCustomHeaders.Free;
FCookies.Free;
inherited Destroy;
end;
procedure TWebResponse.AddCustomHeaders(var Headers: string);
var
I: Integer;
Name, Value: string;
begin
for I := 0 to FCustomHeaders.Count - 1 do
begin
Name := FCustomHeaders.Names[I];
Value := FCustomHeaders.values[Name];
Headers := Headers + Name + ': ' + Value + #13#10;
end;
end;
function TWebResponse.GetCustomHeader(const Name: string): string;
begin
Result := FCustomHeaders.Values[Name];
end;
function TWebResponse.Sent: Boolean;
begin
Result := False;
end;
procedure TWebResponse.SetContentStream(Value: TStream);
begin
if Value <> FContentStream then
begin
FContentStream.Free;
FContentStream := Value;
if FContentStream <> nil then
ContentLength := FContentStream.Size
else ContentLength := Length(Content);
end;
end;
procedure TWebResponse.SetCookieField(Values: TStrings; const ADomain,
APath: string; AExpires: TDateTime; ASecure: Boolean);
var
I: Integer;
begin
for I := 0 to Values.Count - 1 do
with Cookies.Add do
begin
Name := Values.Names[I];
Value := Values.Values[Values.Names[I]];
Domain := ADomain;
Path := APath;
Expires := AExpires;
Secure := ASecure;
end;
end;
procedure TWebResponse.SetCustomHeader(const Name, Value: string);
begin
FCustomHeaders.Values[Name] := Value;
end;
procedure TWebResponse.SetCustomHeaders(Value: TStrings);
begin
FCustomHeaders.Assign(Value);
end;
function TWebResponse.FormatAuthenticate: string;
begin
if Realm <> '' then
Result := Format('%s Realm=%s', [WWWAuthenticate, Realm])
else
Result := WWWAuthenticate;
end;
{ TCustomContentProducer }
procedure TCustomContentProducer.Notification(AComponent: TComponent;
Operation: TOperation);
begin
inherited Notification(AComponent, Operation);
if (Operation = opRemove) and (AComponent = FDispatcher) then
FDispatcher := nil;
end;
procedure TCustomContentProducer.SetDispatcher(Value: TComponent);
begin
if FDispatcher <> Value then
begin
if Value <> nil then Value.FreeNotification(Self);
FDispatcher := Value;
end;
end;
function TCustomContentProducer.Content: string;
begin
Result := '';
end;
function TCustomContentProducer.ContentFromStream(Stream: TStream): string;
begin
Result := Content;
end;
function TCustomContentProducer.ContentFromString(const S: string): string;
begin
Result := Content;
end;
procedure TCustomContentProducer.SetAppDispatcher(
const ADispatcher: TComponent);
begin
SetDispatcher(ADispatcher);
end;
function TCustomContentProducer.GetDispatcher: IWebDispatcherAccess;
begin
if Assigned(FDispatcher) then
Supports(IInterface(FDispatcher), IWebDispatcherAccess, Result)
else
Result := nil;
end;
function TCustomContentProducer.ProduceContent: string;
begin
Result := Content;
end;
function TCustomContentProducer.ProduceContentFromStream(
Stream: TStream): string;
begin
Result := ContentFromStream(Stream);
end;
function TCustomContentProducer.ProduceContentFromString(
const S: string): string;
begin
Result := ContentFromString(S);
end;
function TCustomContentProducer.GetAppDispatcher: TComponent;
begin
Result := FDispatcher;
end;
{ TWebActionItem }
constructor TWebActionItem.Create(Collection: TCollection);
begin
inherited Create(Collection);
FEnabled := True;
end;
destructor TWebActionItem.Destroy;
begin
FMask.Free;
inherited Destroy;
end;
procedure TWebActionItem.AssignTo(Dest: TPersistent);
begin
if Dest is TWebActionItem then
begin
if Assigned(Collection) then Collection.BeginUpdate;
try
with TWebActionItem(Dest) do
begin
Default := Self.Default;
PathInfo := Self.PathInfo;
Enabled := Self.Enabled;
MethodType := Self.MethodType;
end;
finally
if Assigned(Collection) then Collection.EndUpdate;
end;
end else inherited AssignTo(Dest);
end;
function TWebActionItem.DispatchAction(Request: TWebRequest; Response: TWebResponse;
DoDefault: Boolean): Boolean;
var
Intf: IProduceContent;
begin
Result := False;
if (FDefault and DoDefault) or (FEnabled and ((FMethodType = mtAny) or
(FMethodType = Request.MethodType)) and
GetMask.Matches(Request.InternalPathInfo)) then
begin
if Assigned(FProducer) then
begin
Result := True;
Response.Content := FProducer.Content;
end
else if Assigned(FProducerContent) then
begin
Result := Supports(IUnknown(FProducerContent), IProduceContent, Intf);
if Result then
Response.Content := Intf.ProduceContent;
end;
if Assigned(FOnAction) then
begin
Result := True;
FOnAction(Self, Request, Response, Result);
end
end;
end;
function TWebActionItem.GetDisplayName: string;
begin
Result := FName;
end;
procedure TWebActionItem.SetDefault(Value: Boolean);
var
I: Integer;
Action: TWebActionItem;
begin
if Value <> FDefault then
begin
if Value and (Collection <> nil) then
for I := 0 to Collection.Count - 1 do
begin
Action := TWebActionItems(Collection).Items[I];
if (Action <> Self) and (Action is TWebActionItem) then
Action.Default := False;
end;
FDefault := Value;
Changed(False);
end;
end;
procedure TWebActionItem.SetEnabled(Value: Boolean);
begin
if Value <> FEnabled then
begin
FEnabled := Value;
Changed(False);
end;
end;
procedure TWebActionItem.SetMethodType(Value: TMethodType);
begin
if Value <> FMethodType then
begin
FMethodType := Value;
Changed(False);
end;
end;
procedure TWebActionItem.SetDisplayName(const Value: string);
var
I: Integer;
Action: TWebActionItem;
begin
if AnsiCompareText(Value, FName) <> 0 then
begin
if Collection <> nil then
for I := 0 to Collection.Count - 1 do
begin
Action := TWebActionItems(Collection).Items[I];
if (Action <> Self) and (Action is TWebActionItem) and
(AnsiCompareText(Value, Action.Name) = 0) then
raise EWebBrokerException.Create(sDuplicateActionName);
end;
FName := Value;
Changed(False);
end;
end;
procedure TWebActionItem.SetOnAction(Value: THTTPMethodEvent);
begin
FOnAction := Value;
Changed(False);
end;
procedure TWebActionItem.SetPathInfo(const Value: string);
var
NewValue: string;
begin
if Value <> '' then NewValue := DosPathToUnixPath(Value);
if (NewValue <> '') and (NewValue[1] <> '/') then Insert('/', NewValue, 1);
if Assigned(FProducer) and (NewValue = ProducerPathInfo) then
NewValue := '';
if AnsiCompareText(FPathInfo, NewValue) <> 0 then
begin
FPathInfo := NewValue;
Changed(False);
end;
end;
procedure TWebActionItem.SetProducer(const Value: TCustomContentProducer);
begin
if Assigned(Value) then
begin
Value.FreeNotification(TWebActionItems(Collection).WebDispatcher);
FProducerContent := nil;
end;
FProducer := Value;
end;
function TWebActionItem.ProducerPathInfo: string;
begin
Assert(Assigned(FProducer));
Result := '/' + FProducer.Name
end;
function TWebActionItem.GetPathInfo: string;
begin
if (FPathInfo = '') and Assigned(FProducer) then
Result := ProducerPathInfo
else
Result := FPathInfo;
end;
function TWebActionItem.GetMask: TMask;
var
Mask: TMask;
MaskPathInfo: string;
begin
MaskPathInfo := GetPathInfo;
if (not Assigned(FMask)) or
(AnsiCompareText(FMaskPathInfo, MaskPathInfo) <> 0) then
begin
Mask := TMask.Create(MaskPathInfo);
try
FMaskPathInfo := MaskPathInfo;
if Assigned(FMask) then
begin
FMask.Free;
FMask := nil;
end;
except
Mask.Free;
raise;
end;
FMask := Mask;
end;
Result := FMask;
end;
procedure TWebActionItem.SetProducerContent(const Value: TComponent);
begin
if Assigned(Value) then
begin
Value.FreeNotification(TWebActionItems(Collection).WebDispatcher);
FProducer := nil;
end;
FProducerContent := Value;
end;
{ TWebActionItems }
constructor TWebActionItems.Create(WebDispatcher: TCustomWebDispatcher;
ItemClass: TCollectionItemClass);
begin
inherited Create(ItemClass);
FWebDispatcher := WebDispatcher;
end;
function TWebActionItems.Add: TWebActionItem;
begin
Result := TWebActionItem(inherited Add);
end;
function TWebActionItems.GetActionItem(Index: Integer): TWebActionItem;
begin
Result := TWebActionItem(inherited Items[Index]);
end;
function TWebActionItems.GetAttrCount: Integer;
begin
Result := 5;
end;
function TWebActionItems.GetAttr(Index: Integer): string;
begin
case Index of
0: Result := sHTTPItemName;
1: Result := sHTTPItemURI;
2: Result := sHTTPItemEnabled;
3: Result := sHTTPItemDefault;
4: Result := sHTTPItemProducer;
else
Result := '';
end;
end;
function TWebActionItems.GetItemAttr(Index, ItemIndex: Integer): string;
begin
case Index of
0: Result := Items[ItemIndex].Name;
1: Result := Items[ItemIndex].PathInfo;
2: if Items[ItemIndex].Enabled then
Result := 'True' else Result := 'False'; // do not localize
3: if Items[ItemIndex].Default then
Result := '*' else Result := ''; //do not localize
4: if Items[ItemIndex].Producer <> nil then
Result := Items[ItemIndex].Producer.Name
else if Items[ItemIndex].ProducerContent <> nil then
Result := Items[ItemIndex].ProducerContent.Name
else
Result := '' //do not localize
else
Result := '';
end;
end;
function TWebActionItems.GetOwner: TPersistent;
begin
Result := FWebDispatcher;
end;
procedure TWebActionItems.SetActionItem(Index: Integer; Value: TWebActionItem);
begin
Items[Index].Assign(Value);
end;
procedure TWebActionItems.SetItemName(Item: TCollectionItem);
var
I, J: Integer;
ItemName: string;
CurItem: TWebActionItem;
begin
J := 1;
while True do
begin
ItemName := Format('WebActionItem%d', [J]); { do not localize }
I := 0;
while I < Count do
begin
CurItem := Items[I] as TWebActionItem;
if (CurItem <> Item) and (CompareText(CurItem.Name, ItemName) = 0) then
begin
Inc(J);
Break;
end;
Inc(I);
end;
if I >= Count then
begin
(Item as TWebActionItem).Name := ItemName;
Break;
end;
end;
end;
procedure TWebActionItems.Update(Item: TCollectionItem);
begin
{!!! if (FWebDispatcher <> nil) and
not (csLoading in FWebDispatcher.ComponentState) then }
end;
{ TCustomWebDispatcher }
constructor TCustomWebDispatcher.Create(AOwner: TComponent);
var
I: Integer;
Component: TComponent;
DispatchIntf: IWebDispatch;
SetAppDispatcher: ISetAppDispatcher;
begin
{$IFDEF MSWINDOWS}
RPR;
{$ENDIF}
{$IFDEF LINUX}
{ TODO -oJMT -cMUSTFIX : Uncomment when RCS no longer causes crash }
// RCS;
{$ENDIF}
FDispatchList := TComponentList.Create;
FDispatchList.OwnsObjects := False;
FOnException := nil;
if AOwner <> nil then
if AOwner is TCustomWebDispatcher then
raise EWebBrokerException.Create(sOnlyOneDispatcher)
else
for I := 0 to AOwner.ComponentCount - 1 do
if AOwner.Components[I] is TCustomWebDispatcher then
raise EWebBrokerException.Create(sOnlyOneDispatcher);
inherited CreateNew(AOwner, -1);
FActions := TWebActionItems.Create(Self, TWebActionItem);
if Owner <> nil then
for I := 0 to Owner.ComponentCount - 1 do
begin
Component := Owner.Components[I];
if Supports(IInterface(Component), ISetAppDispatcher, SetAppDispatcher) then
SetAppDispatcher.SetAppDispatcher(Self)
else if Supports(IInterface(Component), IWebDispatch, DispatchIntf) then
FDispatchList.Add(Component);
end;
end;
destructor TCustomWebDispatcher.Destroy;
begin
inherited Destroy;
FActions.Free;
FDispatchList.Free;
end;
procedure TCustomWebDispatcher.HandleException(E: Exception; var Handled: Boolean);
begin
Handled := False;
if Assigned(FOnException) then
begin
Handled := True;
if Response <> nil then
Response.StatusCode := 500; { Allow the user to override the StatusCode }
FOnException(Self, E, Handled);
if Handled and (Response <> nil) then
Response.SendResponse;
end;
if not Handled then
if Response <> nil then
begin
Response.Content := Format(sInternalApplicationError, [E.Message, Request.PathInfo]);
if not Response.Sent then
begin
Response.StatusCode := 500;
Response.SendResponse;
end;
Handled := True;
end;
end;
function TCustomWebDispatcher.ActionByName(const AName: string): TWebActionItem;
var
I: Integer;
begin
for I := 0 to FActions.Count - 1 do
begin
Result := FActions[I];
if AnsiCompareText(AName, Result.Name) = 0 then Exit;
end;
Result := nil;
end;
function TCustomWebDispatcher.DoAfterDispatch(Request: TWebRequest; Response: TWebResponse): Boolean;
begin
Result := True;
if Assigned(FAfterDispatch) then
FAfterDispatch(Self, Request, Response, Result);
end;
function TCustomWebDispatcher.DoBeforeDispatch(Request: TWebRequest; Response: TWebResponse): Boolean;
begin
Result := False;
if Assigned(FBeforeDispatch) then
FBeforeDispatch(Self, Request, Response, Result);
end;
function DispatchHandler(Sender: TObject; Dispatch: IWebDispatch; Request: TWebRequest; Response: TWebResponse;
DoDefault: Boolean): Boolean;
begin
Result := False;
if (Dispatch.Enabled and ((Dispatch.MethodType = mtAny) or
(Dispatch.MethodType = Dispatch.MethodType)) and
Dispatch.Mask.Matches(Request.InternalPathInfo)) then
begin
Result := Dispatch.DispatchRequest(Sender, Request, Response);
end;
end;
function TCustomWebDispatcher.DispatchAction(Request: TWebRequest;
Response: TWebResponse): Boolean;
var
I: Integer;
Action, Default: TWebActionItem;
Dispatch: IWebDispatch;
begin
FRequest := Request;
FResponse := Response;
I := 0;
Default := nil;
if Response.Sent then
begin
Result := True;
{ Note that WebSnapSvr enabled apps have no way to mark response as sent }
Exit;
end;
Result := DoBeforeDispatch(Request, Response) or Response.Sent;
while not Result and (I < FActions.Count) do
begin
Action := FActions[I];
Result := Action.DispatchAction(Request, Response, False);
if Action.Default then Default := Action;
Inc(I);
end;
// Dispatch to self registering components
I := 0;
while not Result and (I < FDispatchList.Count) do
begin
if Supports(IInterface(FDispatchList.Items[I]), IWebDispatch, Dispatch) then
begin
Result := DispatchHandler(Self, Dispatch,
Request, Response, False);
end;
Inc(I);
end;
if not Result and Assigned(Default) then
Result := Default.DispatchAction(Request, Response, True);
if Result and not Response.Sent then
Result := DoAfterDispatch(Request, Response);
end;
function TCustomWebDispatcher.GetAction(Index: Integer): TWebActionItem;
begin
Result := FActions[Index];
end;
procedure TCustomWebDispatcher.Notification(AComponent: TComponent;
Operation: TOperation);
var
I: Integer;
DispatchIntf: IWebDispatch;
SetAppDispatcher: ISetAppDispatcher;
begin
{ For classic style WebBroker apps we assume a single data module that owns all producers. }
inherited Notification(AComponent, Operation);
if (Operation = opInsert) then
begin
if Supports(IInterface(AComponent), ISetAppDispatcher, SetAppDispatcher) then
SetAppDispatcher.SetAppDispatcher(Self)
else if Supports(IInterface(AComponent), IWebDispatch, DispatchIntf) then
FDispatchList.Add(AComponent);
end;
if (Operation = opRemove) and (AComponent is TCustomContentProducer) then
for I := 0 to FActions.Count - 1 do
if FActions.Items[I].Producer = AComponent then
FActions.Items[I].Producer := nil
else if FActions.Items[I].ProducerContent = AComponent then
FActions.Items[I].ProducerContent := nil;
end;
function TCustomWebDispatcher.HandleRequest(
Request: TWebRequest; Response: TWebResponse): Boolean;
begin
FRequest := Request;
FResponse := Response;
Result := DispatchAction(Request, Response);
end;
procedure TCustomWebDispatcher.SetActions(Value: TWebActionItems);
begin
FActions.Assign(Value);
end;
function TCustomWebDispatcher.GetRequest: TWebRequest;
begin
Result := FRequest;
end;
function TCustomWebDispatcher.GetResponse: TWebResponse;
begin
Result := FResponse;
end;
function TCustomWebDispatcher.Access_Request: TWebRequest;
begin
Result := GetRequest;
end;
function TCustomWebDispatcher.Access_Response: TWebResponse;
begin
Result := GetResponse;
end;
procedure TCustomWebDispatcher.FinishContext;
begin
//
end;
procedure TCustomWebDispatcher.InitContext(Request: TWebRequest;
Response: TWebResponse);
begin
FRequest := Request;
FResponse := Response;
FDispatchList.Clear;
end;
procedure TCustomWebDispatcher.InitModule(AModule: TComponent);
var
I: Integer;
Component: TComponent;
DispatchIntf: IWebDispatch;
begin
if AModule <> nil then
for I := 0 to AModule.ComponentCount - 1 do
begin
Component := AModule.Components[I];
if Supports(IInterface(Component), IWebDispatch, DispatchIntf) then
FDispatchList.Add(Component);
end;
end;
{ TWebModule }
constructor TWebModule.Create(AOwner: TComponent);
begin
// Code to load a resource associated with this module. If the class
// is TCustomWebDispatcher, assume that there is no resource. This
// allows an app to dynamically instantiate a TCustomWebDispatcher as
// run time.
inherited Create(AOwner);
if (ClassType <> TCustomWebDispatcher) and not (csDesigning in ComponentState) then
try
if not InitInheritedComponent(Self, TCustomWebDispatcher) then
raise EResNotFound.CreateFmt(SResNotFound, [ClassName]);
{$IFDEF MSWINDOWS}
if Assigned(OnCreate) and OldCreateOrder then OnCreate(Self);
{$ENDIF}
{$IFDEF LINUX}
if Assigned(OnCreate) then OnCreate(Self);
{$ENDIF}
except
if Assigned(ApplicationHandleException) then
ApplicationHandleException(nil);
end;
end;
function HTTPDecode(const AStr: String): String;
var
Sp, Rp, Cp: PChar;
S: String;
begin
SetLength(Result, Length(AStr));
Sp := PChar(AStr);
Rp := PChar(Result);
Cp := Sp;
try
while Sp^ <> #0 do
begin
case Sp^ of
'+': Rp^ := ' ';
'%': begin
// Look for an escaped % (%%) or %<hex> encoded character
Inc(Sp);
if Sp^ = '%' then
Rp^ := '%'
else
begin
Cp := Sp;
Inc(Sp);
if (Cp^ <> #0) and (Sp^ <> #0) then
begin
S := '$' + Cp^ + Sp^;
Rp^ := Chr(StrToInt(S));
end
else
raise EWebBrokerException.CreateFmt(sErrorDecodingURLText, [Cp - PChar(AStr)]);
end;
end;
else
Rp^ := Sp^;
end;
Inc(Rp);
Inc(Sp);
end;
except
on E:EConvertError do
raise EConvertError.CreateFmt(sInvalidURLEncodedChar,
['%' + Cp^ + Sp^, Cp - PChar(AStr)])
end;
SetLength(Result, Rp - PChar(Result));
end;
function HTTPEncode(const AStr: String): String;
// The NoConversion set contains characters as specificed in RFC 1738 and
// should not be modified unless the standard changes.
const
NoConversion = ['A'..'Z','a'..'z','*','@','.','_','-',
'0'..'9','$','!','''','(',')'];
var
Sp, Rp: PChar;
begin
SetLength(Result, Length(AStr) * 3);
Sp := PChar(AStr);
Rp := PChar(Result);
while Sp^ <> #0 do
begin
if Sp^ in NoConversion then
Rp^ := Sp^
else
if Sp^ = ' ' then
Rp^ := '+'
else
begin
FormatBuf(Rp^, 3, '%%%.2x', 6, [Ord(Sp^)]);
Inc(Rp,2);
end;
Inc(Rp);
Inc(Sp);
end;
SetLength(Result, Rp - PChar(Result));
end;
function HTMLEncode(const AStr: String): String;
const
Convert = ['&','<','>','"'];
var
Sp, Rp: PChar;
begin
SetLength(Result, Length(AStr) * 10);
Sp := PChar(AStr);
Rp := PChar(Result);
while Sp^ <> #0 do
begin
case Sp^ of
'&': begin
FormatBuf(Rp^, 5, '&', 5, []);
Inc(Rp,4);
end;
'<',
'>': begin
if Sp^ = '<' then
FormatBuf(Rp^, 4, '<', 4, [])
else
FormatBuf(Rp^, 4, '>', 4, []);
Inc(Rp,3);
end;
'"': begin
FormatBuf(Rp^, 6, '"', 6, []);
Inc(Rp,5);
end;
else
Rp^ := Sp^
end;
Inc(Rp);
Inc(Sp);
end;
SetLength(Result, Rp - PChar(Result));
end;
function HTMLDecode(const AStr: String): String;
var
Sp, Rp, Cp, Tp: PChar;
S: String;
I, Code: Integer;
begin
SetLength(Result, Length(AStr));
Sp := PChar(AStr);
Rp := PChar(Result);
Cp := Sp;
try
while Sp^ <> #0 do
begin
case Sp^ of
'&': begin
Cp := Sp;
Inc(Sp);
case Sp^ of
'a': if AnsiStrPos(Sp, 'amp;') = Sp then { do not localize }
begin
Inc(Sp, 3);
Rp^ := '&';
end;
'l',
'g': if (AnsiStrPos(Sp, 'lt;') = Sp) or (AnsiStrPos(Sp, 'gt;') = Sp) then { do not localize }
begin
Cp := Sp;
Inc(Sp, 2);
while (Sp^ <> ';') and (Sp^ <> #0) do
Inc(Sp);
if Cp^ = 'l' then
Rp^ := '<'
else
Rp^ := '>';
end;
'q': if AnsiStrPos(Sp, 'quot;') = Sp then { do not localize }
begin
Inc(Sp,4);
Rp^ := '"';
end;
'#': begin
Tp := Sp;
Inc(Tp);
while (Sp^ <> ';') and (Sp^ <> #0) do
Inc(Sp);
SetString(S, Tp, Sp - Tp);
Val(S, I, Code);
Rp^ := Chr((I));
end;
else
raise EConvertError.CreateFmt(sInvalidHTMLEncodedChar,
[Cp^ + Sp^, Cp - PChar(AStr)])
end;
end
else
Rp^ := Sp^;
end;
Inc(Rp);
Inc(Sp);
end;
except
on E:EConvertError do
raise EConvertError.CreateFmt(sInvalidHTMLEncodedChar,
[Cp^ + Sp^, Cp - PChar(AStr)])
end;
SetLength(Result, Rp - PChar(Result));
end;
const
// These strings are NOT to be resourced
Months: array[1..12] of string = (
'Jan', 'Feb', 'Mar', 'Apr',
'May', 'Jun', 'Jul', 'Aug',
'Sep', 'Oct', 'Nov', 'Dec');
DaysOfWeek: array[1..7] of string = (
'Sun', 'Mon', 'Tue', 'Wed',
'Thu', 'Fri', 'Sat');
function ParseDate(const DateStr: string): TDateTime;
var
Month, Day, Year, Hour, Minute, Sec: Integer;
Parser: TParser;
StringStream: TStringStream;
function GetMonth: Boolean;
begin
if Month < 13 then
begin
Result := False;
Exit;
end;
Month := 1;
while not Parser.TokenSymbolIs(Months[Month]) and (Month < 13) do Inc(Month);
Result := Month < 13;
end;
procedure GetTime;
begin
with Parser do
begin
Hour := TokenInt;
NextToken;
if Token = ':' then NextToken;
Minute := TokenInt;
NextToken;
if Token = ':' then NextToken;
Sec := TokenInt;
NextToken;
end;
end;
begin
Month := 13;
StringStream := TStringStream.Create(DateStr);
try
Parser := TParser.Create(StringStream);
with Parser do
try
Month := TokenInt;
NextToken;
if Token = ':' then NextToken;
NextToken;
if Token = ',' then NextToken;
if GetMonth then
begin
NextToken;
Day := TokenInt;
NextToken;
GetTime;
Year := TokenInt;
end else
begin
Day := TokenInt;
NextToken;
if Token = '-' then NextToken;
GetMonth;
NextToken;
if Token = '-' then NextToken;
Year := TokenInt;
if Year < 100 then Inc(Year, 1900);
NextToken;
GetTime;
end;
Result := EncodeDate(Year, Month, Day) + EncodeTime(Hour, Minute, Sec, 0);
finally
Free;
end;
finally
StringStream.Free;
end;
end;
procedure ExtractHeaderFields(Separators, WhiteSpace: TSysCharSet; Content: PChar;
Strings: TStrings; Decode: Boolean; StripQuotes: Boolean = False);
var
Head, Tail: PChar;
EOS, InQuote, LeadQuote: Boolean;
QuoteChar: Char;
ExtractedField: string;
WhiteSpaceWithCRLF: TSysCharSet;
SeparatorsWithCRLF: TSysCharSet;
function DoStripQuotes(const S: string): string;
var
I: Integer;
InStripQuote: Boolean;
StripQuoteChar: Char;
begin
Result := S;
InStripQuote := False;
StripQuoteChar := #0;
if StripQuotes then
for I := Length(Result) downto 1 do
if Result[I] in ['''', '"'] then
if InStripQuote and (StripQuoteChar = Result[I]) then
begin
Delete(Result, I, 1);
InStripQuote := False;
end
else if not InStripQuote then
begin
StripQuoteChar := Result[I];
InStripQuote := True;
Delete(Result, I, 1);
end
end;
begin
if (Content = nil) or (Content^ = #0) then Exit;
WhiteSpaceWithCRLF := WhiteSpace + [#13, #10];
SeparatorsWithCRLF := Separators + [#0, #13, #10, '"'];
Tail := Content;
QuoteChar := #0;
repeat
while Tail^ in WhiteSpaceWithCRLF do Inc(Tail);
Head := Tail;
InQuote := False;
LeadQuote := False;
while True do
begin
while (InQuote and not (Tail^ in [#0, '"'])) or
not (Tail^ in SeparatorsWithCRLF) do Inc(Tail);
if Tail^ = '"' then
begin
if (QuoteChar <> #0) and (QuoteChar = Tail^) then
QuoteChar := #0
else
begin
LeadQuote := Head = Tail;
QuoteChar := Tail^;
if LeadQuote then Inc(Head);
end;
InQuote := QuoteChar <> #0;
if InQuote then
Inc(Tail)
else Break;
end else Break;
end;
if not LeadQuote and (Tail^ <> #0) and (Tail^ = '"') then
Inc(Tail);
EOS := Tail^ = #0;
if Head^ <> #0 then
begin
SetString(ExtractedField, Head, Tail-Head);
if Decode then
Strings.Add(HTTPDecode(DoStripQuotes(ExtractedField)))
else Strings.Add(DoStripQuotes(ExtractedField));
end;
Inc(Tail);
until EOS;
end;
procedure ExtractHTTPFields(Separators, WhiteSpace: TSysCharSet; Content: PChar;
Strings: TStrings; StripQuotes: Boolean = False);
begin
ExtractHeaderFields(Separators, WhiteSpace, Content, Strings, True, StripQuotes);
end;
function StatusString(StatusCode: Integer): string;
begin
case StatusCode of
100: Result := 'Continue'; {do not localize}
101: Result := 'Switching Protocols'; {do not localize}
200: Result := 'OK'; {do not localize}
201: Result := 'Created'; {do not localize}
202: Result := 'Accepted'; {do not localize}
203: Result := 'Non-Authoritative Information'; {do not localize}
204: Result := 'No Content'; {do not localize}
205: Result := 'Reset Content'; {do not localize}
206: Result := 'Partial Content'; {do not localize}
300: Result := 'Multiple Choices'; {do not localize}
301: Result := 'Moved Permanently'; {do not localize}
302: Result := 'Moved Temporarily'; {do not localize}
303: Result := 'See Other'; {do not localize}
304: Result := 'Not Modified'; {do not localize}
305: Result := 'Use Proxy'; {do not localize}
400: Result := 'Bad Request'; {do not localize}
401: Result := 'Unauthorized'; {do not localize}
402: Result := 'Payment Required'; {do not localize}
403: Result := 'Forbidden'; {do not localize}
404: Result := 'Not Found'; {do not localize}
405: Result := 'Method Not Allowed'; {do not localize}
406: Result := 'None Acceptable'; {do not localize}
407: Result := 'Proxy Authentication Required'; {do not localize}
408: Result := 'Request Timeout'; {do not localize}
409: Result := 'Conflict'; {do not localize}
410: Result := 'Gone'; {do not localize}
411: Result := 'Length Required'; {do not localize}
412: Result := 'Unless True'; {do not localize}
500: Result := 'Internal Server Error'; {do not localize}
501: Result := 'Not Implemented'; {do not localize}
502: Result := 'Bad Gateway'; {do not localize}
503: Result := 'Service Unavailable'; {do not localize}
504: Result := 'Gateway Timeout'; {do not localize}
else
Result := '';
end
end;
function TranslateChar(const Str: string; FromChar, ToChar: Char): string;
var
I: Integer;
begin
Result := Str;
for I := 1 to Length(Result) do
if Result[I] = FromChar then
Result[I] := ToChar;
end;
function UnixPathToDosPath(const Path: string): string;
begin
Result := TranslateChar(Path, '/', '\');
end;
function DosPathToUnixPath(const Path: string): string;
begin
Result := TranslateChar(Path, '\', '/');
end;
function MonthStr(DateTime: TDateTime): string;
var
Year, Month, Day: Word;
begin
DecodeDate(DateTime, Year, Month, Day);
Result := Months[Month];
end;
function DayOfWeekStr(DateTime: TDateTime): string;
begin
Result := DaysOfWeek[DayOfWeek(DateTime)];
end;
{ TAbstractWebPageInfo }
function TAbstractWebPageInfo.GetIsPublished: Boolean;
begin
Result := False;
end;
function TAbstractWebPageInfo.GetPageDescription: string;
begin
Result := GetPageName;
end;
function TAbstractWebPageInfo.GetPageHREF: string;
begin
Result := GetPageName;
end;
function TAbstractWebPageInfo.GetPageTitle: string;
begin
Result := GetPageName;
end;
function TAbstractWebPageInfo.GetFactory: TAbstractWebPageModuleFactory;
begin
Result := FFactory;
end;
procedure TAbstractWebPageInfo.SetFactory(
AFactory: TAbstractWebPageModuleFactory);
begin
FFactory := AFactory;
end;
function TAbstractWebPageInfo.GetIsLoginRequired: Boolean;
begin
Result := False;
end;
function TAbstractWebPageInfo.GetViewAccess: string;
begin
Result := '';
end;
{ TAbstractWebModuleFactory }
function TAbstractWebModuleFactory.GetWebPageInfo: TAbstractWebPageInfo;
begin
Result := nil;
end;
{ TAbstractWebPageModuleFactory }
constructor TAbstractWebPageModuleFactory.Create(
AWebPageInfo: TAbstractWebPageInfo);
begin
inherited Create;
FWebPageInfo := AWebPageInfo;
FWebPageInfo.Factory := Self;
end;
destructor TAbstractWebPageModuleFactory.Destroy;
begin
inherited;
FWebPageInfo.Free;
end;
function TAbstractWebPageModuleFactory.GetWebPageInfo: TAbstractWebPageInfo;
begin
Result := FWebPageInfo;
end;
{ TDefaultWebAppServices }
function TDefaultWebAppServices.FindRequestHandler: IWebRequestHandler;
var
Component: TComponent;
begin
Result := nil;
Component := FindWebDispatcher;
if Component <> nil then
if not Supports(Component, IWebRequestHandler, Result) then
Assert(False, 'Expect support for IWebRequestHandler'); { do not localize }
end;
function TDefaultWebAppServices.GetRequestHandler: IWebRequestHandler;
begin
if FRequestHandler = nil then
FRequestHandler := FindRequestHandler;
Result := FRequestHandler;
end;
function TDefaultWebAppServices.HandleRequest: Boolean;
begin
Result := InvokeDispatcher;
end;
procedure TDefaultWebAppServices.InitContext(
WebModuleList: TAbstractWebModuleList; Request: TWebRequest;
Response: TWebResponse);
begin
FRequest := Request;
FResponse := Response;
FWebModules := WebModuleList;
end;
procedure TDefaultWebAppServices.FinishContext;
begin
end;
function TDefaultWebAppServices.InvokeDispatcher: Boolean;
begin
if RequestHandler <> nil then
begin
Result := RequestHandler.HandleRequest(Request, Response);
end
else
raise EWebBrokerException.CreateRes(@sNoDispatcherComponent);
end;
function TDefaultWebAppServices.FindWebDispatcher: TComponent;
var
WebModule: TComponent;
I, J: Integer;
begin
Result := nil;
for I := 0 to WebModules.ItemCount - 1 do
begin
WebModule := WebModules[I];
if WebModule is TCustomWebDispatcher then
Result := WebModule
else
for J := 0 to WebModule.ComponentCount - 1 do
if WebModule.Components[J] is TCustomWebDispatcher then
begin
Result := WebModule.Components[J];
break;
end;
if Result <> nil then break;
end;
end;
function TDefaultWebAppServices.GetExceptionHandler: TObject;
var
Intf: IUnknown;
begin
Result := FindWebDispatcher;
if Result <> nil then
if not Supports(Result, IWebExceptionHandler, Intf) then
Assert(False, 'Expect support for IWebExceptionHandler'); { do not localize }
end;
{ TAbstractContentParser }
class function TAbstractContentParser.CanParse(
AWebRequest: TWebRequest): Boolean;
begin
Result := False;
end;
constructor TAbstractContentParser.Create(AWebRequest: TWebRequest);
begin
FWebRequest := AWebRequest;
inherited Create;
end;
{ TContentParser }
class function TContentParser.CanParse(AWebRequest: TWebRequest): Boolean;
begin
Result := True;
end;
destructor TContentParser.Destroy;
begin
FContentFields.Free;
FFiles.Free;
inherited;
end;
function TContentParser.GetContentFields: TStrings;
begin
if FContentFields = nil then
begin
FContentFields := TStringList.Create;
WebRequest.ExtractContentFields(FContentFields);
end;
Result := FContentFields;
end;
type
TEmptyRequestFiles = class(TAbstractWebRequestFiles)
protected
function GetCount: Integer; override;
function GetItem(I: Integer): TAbstractWebRequestFile; override;
end;
function TEmptyRequestFiles.GetCount: Integer;
begin
Result := 0;
end;
function TEmptyRequestFiles.GetItem(I: Integer): TAbstractWebRequestFile;
begin
Result := nil;
end;
function TContentParser.GetFiles: TAbstractWebRequestFiles;
begin
if FFiles = nil then
FFiles := TEmptyRequestFiles.Create;
Result := FFiles;
end;
initialization
finalization
FreeAndNil(FContentParsers);
end.
|
unit DescriptionsGroupUnit2;
interface
uses
QueryGroupUnit2, System.Classes, DescriptionsQuery, DescriptionTypesQuery,
ProducersQuery, DescriptionsExcelDataModule, System.Generics.Collections,
NotifyEvents;
type
TDescriptionsGroup2 = class(TQueryGroup2)
private
FqDescriptions: TQueryDescriptions;
FqDescriptions2: TQueryDescriptions;
FqDescriptionTypes: TQueryDescriptionTypes;
FqProducers: TQueryProducers;
procedure DoAfterDelete(Sender: TObject);
function GetqDescriptions: TQueryDescriptions;
function GetqDescriptions2: TQueryDescriptions;
function GetqDescriptionTypes: TQueryDescriptionTypes;
function GetqProducers: TQueryProducers;
protected
property qDescriptions2: TQueryDescriptions read GetqDescriptions2;
public
constructor Create(AOwner: TComponent); override;
function Find(const AFieldName, S: string): TList<String>;
procedure LoadDataFromExcelTable(ADescriptionsExcelTable
: TDescriptionsExcelTable);
procedure LocateDescription(AIDDescription: Integer);
function Re_Open(AShowDuplicate: Boolean;
const AComponentName: string): Boolean;
property qDescriptions: TQueryDescriptions read GetqDescriptions;
property qDescriptionTypes: TQueryDescriptionTypes
read GetqDescriptionTypes;
property qProducers: TQueryProducers read GetqProducers;
end;
implementation
uses
System.SysUtils, Data.DB, FireDAC.Comp.DataSet;
constructor TDescriptionsGroup2.Create(AOwner: TComponent);
begin
inherited;
QList.Add(qDescriptionTypes);
QList.Add(qDescriptions);
QList.Add(qProducers);
// Для каскадного удаления
TNotifyEventWrap.Create(qDescriptionTypes.W.AfterDelete, DoAfterDelete,
EventList);
end;
procedure TDescriptionsGroup2.DoAfterDelete(Sender: TObject);
begin
Assert(qDescriptionTypes.W.DeletedPKValue > 0);
// На сервере краткие описания уже каскадно удалились
// Каскадно удаляем краткие описания с клиента
qDescriptions.W.CascadeDelete(qDescriptionTypes.W.DeletedPKValue,
qDescriptions.W.IDComponentType.FieldName, True);
end;
function TDescriptionsGroup2.Find(const AFieldName, S: string): TList<String>;
begin
Assert(not AFieldName.IsEmpty);
Result := TList<String>.Create();
// Пытаемся искать среди кратких описаний по какому-то полю
if qDescriptions.W.LocateByF(AFieldName, S,
[lxoCaseInsensitive, lxoPartialKey]) then
begin
qDescriptionTypes.W.LocateByPK
(qDescriptions.W.IDComponentType.F.Value, True);
// запоминаем что надо искать на первом уровне
Result.Add(qDescriptionTypes.W.ComponentType.F.AsString);
// запоминаем что надо искать на втором уровне
Result.Add(S);
end
else
// Пытаемся искать среди типов кратких описаний
if qDescriptionTypes.W.LocateByF
(qDescriptionTypes.W.ComponentType.FieldName, S,
[lxoCaseInsensitive, lxoPartialKey]) then
begin
Result.Add(S);
end;
end;
function TDescriptionsGroup2.GetqDescriptions: TQueryDescriptions;
begin
if FqDescriptions = nil then
begin
FqDescriptions := TQueryDescriptions.Create(Self);
FqDescriptions.Name := 'qDescriptions';
end;
Result := FqDescriptions;
end;
function TDescriptionsGroup2.GetqDescriptions2: TQueryDescriptions;
begin
if FqDescriptions2 = nil then
FqDescriptions2 := TQueryDescriptions.Create(Self);
Result := FqDescriptions2;
end;
function TDescriptionsGroup2.GetqDescriptionTypes: TQueryDescriptionTypes;
begin
if FqDescriptionTypes = nil then
FqDescriptionTypes := TQueryDescriptionTypes.Create(Self);
Result := FqDescriptionTypes;
end;
function TDescriptionsGroup2.GetqProducers: TQueryProducers;
begin
if FqProducers = nil then
begin
FqProducers := TQueryProducers.Create(Self);
FqProducers.FDQuery.Open;
end;
Result := FqProducers;
end;
procedure TDescriptionsGroup2.LoadDataFromExcelTable(ADescriptionsExcelTable
: TDescriptionsExcelTable);
var
AField: TField;
I: Integer;
begin
qDescriptions.FDQuery.DisableControls;
qDescriptionTypes.FDQuery.DisableControls;
try
// Цикл по всем записям, которые будем добавлять
ADescriptionsExcelTable.First;
ADescriptionsExcelTable.CallOnProcessEvent;
while not ADescriptionsExcelTable.Eof do
begin
qDescriptionTypes.W.LocateOrAppend
(ADescriptionsExcelTable.ComponentType.AsString);
qDescriptions.FDQuery.Append;
for I := 0 to ADescriptionsExcelTable.FieldCount - 1 do
begin
AField := qDescriptions.FDQuery.FindField
(ADescriptionsExcelTable.Fields[I].FieldName);
if AField <> nil then
AField.Value := ADescriptionsExcelTable.Fields[I].Value;
end;
qDescriptions.W.IDComponentType.F.Value := qDescriptionTypes.W.PK.Value;
qDescriptions.W.IDProducer.F.Value :=
ADescriptionsExcelTable.IDProducer.Value;
qDescriptions.FDQuery.Post;
ADescriptionsExcelTable.Next;
ADescriptionsExcelTable.CallOnProcessEvent;
end;
finally
qDescriptions.FDQuery.EnableControls;
qDescriptionTypes.FDQuery.EnableControls;
end;
end;
procedure TDescriptionsGroup2.LocateDescription(AIDDescription: Integer);
begin
Assert(AIDDescription > 0);
qDescriptions.FDQuery.DisableControls;
qDescriptionTypes.FDQuery.DisableControls;
try
qDescriptions.W.LocateByPK(AIDDescription);
qDescriptionTypes.W.LocateByPK(qDescriptions.W.IDComponentType.F.AsInteger);
finally
qDescriptionTypes.FDQuery.EnableControls;
qDescriptions.FDQuery.EnableControls;
end;
end;
function TDescriptionsGroup2.Re_Open(AShowDuplicate: Boolean;
const AComponentName: string): Boolean;
begin
qDescriptions.W.TryPost;
qDescriptionTypes.W.TryPost;
// Сначала попытаемся применить фильтр на "запасном" запросе
Result := qDescriptions2.TryApplyFilter(AShowDuplicate, AComponentName);
if not Result then
Exit;
SaveBookmark;
qDescriptions.TryApplyFilter(AShowDuplicate, AComponentName);
qDescriptionTypes.TryApplyFilter(AShowDuplicate, AComponentName);
RestoreBookmark;
end;
end.
|
unit Threads.NIUpdater;
interface
uses Windows, SysUtils, Classes, Threads.Base, GMGlobals, GMConst, GeomerLastValue, GMSqlQuery, ProgramLogFile;
type
TNIUpdateThread = class(TGMThread)
private
FglvBuffer: TGeomerLastValuesBuffer;
function LoadNI(glv: TGeomerLastValue): bool;
procedure ProcessDBMTR(q: TGMSqlQuery; obj: pointer);
protected
procedure SafeExecute(); override;
public
constructor Create(AglvBuffer: TGeomerLastValuesBuffer);
end;
implementation
{ NIUpdateThread }
constructor TNIUpdateThread.Create(AglvBuffer: TGeomerLastValuesBuffer);
begin
inherited Create();
FglvBuffer := AglvBuffer;
end;
function TNIUpdateThread.LoadNI(glv: TGeomerLastValue): bool;
var qNI: TGMSqlQuery;
begin
Result := false;
qNI := TGMSqlQuery.Create();
try
qNI.Close();
qNI.SQL.Text := 'select * from CalcNI (' + IntToStr(glv.ID_Prm) + ', null)';
qNI.Open();
if Terminated then Exit;
if not qNI.Eof then
begin
Result := qNI.FieldByName('UTime').AsInteger > int64(glv.utNI);
if Result then
begin
glv.utNI := qNI.FieldByName('UTime').AsInteger;
glv.ValNI := qNI.FieldByName('Val').AsFloat;
end;
end
else
glv.utNI := 0;
except
on e: Exception do ProgramLog().AddException('LoadNI - ' + e.Message);
end;
qNI.Free();
end;
procedure TNIUpdateThread.ProcessDBMTR(q: TGMSqlQuery; obj: pointer);
begin
if Terminated then Exit;
if FglvBuffer.ValByID[q.FieldByName('ID_Prm').AsInteger] = nil then
FglvBuffer.AddSimpleValue(q.FieldByName('ID_Prm').AsInteger, 0, 0, q);
end;
procedure TNIUpdateThread.SafeExecute;
var i: int;
res, bWasAction: bool;
begin
while not Terminated do
begin
bWasAction := false;
ReadFromQuery('select * from DeviceSystem where ID_Src = ' + IntToStr(SRC_CNT_MTR), ProcessDBMTR);
for i := 0 to FglvBuffer.Count - 1 do
begin
if FglvBuffer[i].bNI then
begin
res := LoadNI(FglvBuffer[i]);
bWasAction := res or bWasAction;
end;
if Terminated then Exit;
end;
SleepThread(2000);
end;
end;
end.
|
unit VA2006Utils;
interface
uses
Windows, Messages, SysUtils, Classes, Controls, ComCtrls, CommCtrl,
Forms;
type
//This class exists to workaround TFrame tabstop set to True
//Known defect with Delphi 2006: http://qc.embarcadero.com/wc/qcmain.aspx?d=12257
TfraTabStopFalse = class(TFrame)
private
function GetTabStop: Boolean;
procedure SetTabStop(const Value: Boolean);
published
property TabStop: Boolean read GetTabStop write SetTabStop stored False;
end;
// Fixes bug in Delphi 2006, where clicking on a header control section after
// any other section have been added or deleted could cause access violations
procedure FixHeaderControlDelphi2006Bug(HeaderControl: THeaderControl);
implementation
uses
VAUtils;
type
THeaderControl2006BugFixer = class(TComponent)
private
FHeaderControl: THeaderControl;
procedure HeaderControlMessageHandler(var Msg: TMessage; var Handled: Boolean);
protected
procedure Notification(AComponent: TComponent; Operation: TOperation); override;
public
constructor CreateWrapper(HeaderControl: THeaderControl);
end;
procedure THeaderControl2006BugFixer.HeaderControlMessageHandler
(var Msg: TMessage; var Handled: Boolean);
var
OnSectionClick: TSectionNotifyEvent;
begin
// BLJ 19 Dec 2016: For some reason, Delphi's short circuit boolean evaluation
// wasn't short circuiting in the case where Msg.Msg <> CN_NOTIFY. Changed
// to a nested IF to force the issue.
if (Msg.Msg = CN_NOTIFY) then
if(PHDNotify(Msg.LParam)^.Hdr.code = HDN_ITEMCLICK) then
begin
Handled := TRUE;
Msg.Result := 0;
OnSectionClick := FHeaderControl.OnSectionClick;
if assigned(OnSectionClick) then
OnSectionClick(FHeaderControl, FHeaderControl.Sections[PHDNotify(Msg.lParam)^.Item]);
end;
end;
procedure THeaderControl2006BugFixer.Notification(AComponent: TComponent;
Operation: TOperation);
begin
inherited;
if (Operation = opRemove) and (AComponent = FHeaderControl) then
begin
RemoveMessageHandler(FHeaderControl, HeaderControlMessageHandler);
Self.Free;
end;
end;
constructor THeaderControl2006BugFixer.CreateWrapper(HeaderControl: THeaderControl);
begin
inherited Create(nil);
FHeaderControl := HeaderControl;
FHeaderControl.FreeNotification(self);
AddMessageHandler(HeaderControl, HeaderControlMessageHandler);
end;
procedure FixHeaderControlDelphi2006Bug(HeaderControl: THeaderControl);
begin
THeaderControl2006BugFixer.CreateWrapper(HeaderControl);
end;
{ TfraTabStopFalse }
function TfraTabStopFalse.GetTabStop: Boolean;
begin
Result := False;
end;
procedure TfraTabStopFalse.SetTabStop(const Value: Boolean);
begin
//Do nothing here, just ignore the Value
end;
end.
|
unit Character;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils, CustomTypes, Entities, Voxel, Goods, Schedule;
type
eGoalKind = (gDrink, gEat, gSleep, gBuy, gSell, gOwn, gEarn, gWork, gGetToPos);
rGoal = record
Kind: eGoalKind;
Priority: longword;
end;
eCharProf = (Beggar, Oddjob, Farmer, Lumberjack, Miner,
Blacksmith, WoodCrafter, Trader, Mercenary);
{ tSkillSet }
tSkillSet = class
Skills: array [0..integer(high(eCharProf))] of word;
procedure Rust;
end;
{ tCondition }
tCondition = class
Blood, Energy: quantative;
procedure Consume(Food: quantative); //make universal for dif types
end;
tBaseCharacter = class(tMovableEntity)
Profession: eCharProf;
Wealth: monetary;
end;
{ tCharacter }
tCharacter = class(tMovableEntity)
//Profession: eCharProf; managed by skills?
SkillSet: tSkillSet;
Condition: tCondition;
MajorGoals, MinorGoals: array of rGoal; //long-term/short-term
Assets: array of rAsset;
Home: tStructure;
private
//HomeHub: tEconomicHub;
procedure ManageGoals;
end;
tCharContainer = class
Characters: array of tCharacter;
Schedule: tSchedule;
end;
{ tCharIDContainer }
tCharIDContainer = class
IDs: array of tEntityID;
function LoadExplicit: tCharContainer; //uses major goals to figure out wha happened
end;
implementation
const
EnergyThreshold = 10000;
{ tCondition }
procedure tCondition.Consume(Food: quantative);
begin
Energy+= Food;
end;
{ tCharIDContainer }
function tCharIDContainer.LoadExplicit: tCharContainer;
begin
Result:= nil;
end;
{ tSkillSet }
procedure tSkillSet.Rust;
begin
end;
{ tCharacter }
procedure tCharacter.ManageGoals;
begin
if Condition.Energy < EnergyThreshold then
begin
end;
end;
end.
|
{*******************************************************}
{ }
{ CodeGear Delphi Runtime Library }
{ }
{ Description of interface for notificatione center }
{ }
{ Local notifications are ways for an application }
{ that isnít running in the foreground to let its }
{ users know it has information for them. }
{ The information could be a message, an impending }
{ calendar event. When presented by the operating }
{ system, local notifications look and sound }
{ the same. They can display an alert message or }
{ they can badge the application icon. They can }
{ also play a sound when the alert or badge number }
{ is shown. }
{ }
{ Copyright(c) 2014-2018 Embarcadero Technologies, Inc. }
{ All rights reserved }
{ }
{*******************************************************}
unit System.Notification;
interface
{$SCOPEDENUMS ON}
uses
System.Classes, System.SysUtils, System.Generics.Collections, System.Messaging;
type
{ TNotification }
/// <summary>Specifies interval for repeating notification in case, when we use scheduled notification</summary>
TRepeatInterval = (None, Second, Minute, Hour, Day, Week, Weekday, Month, Quarter, Year, Era);
/// <summary>Discription of notification for Notification Center </summary>
TNotification = class(TPersistent)
protected
/// <summary>Make a copy of data and save to Dest object</summary>
procedure AssignTo(Dest: TPersistent); override;
public
/// <summary>Unique identificator for determenation notification in Notification Center. Specify id, if you would
/// like to cancel or change this notification in future. The identifier shall be unique only within your
/// application</summary>
/// <remarks>if you identificator will not unique, and you will use it in TNotificationCenter, NotificationCenter
/// will replace information of existing notification by this</remarks>
Name: string;
/// <summary>Title of notification. </summary>
/// <remarks>Working of this property depends of target platform. It's supported only on OSX platform</remarks>
Title: string;
/// <summary>Text of notification message</summary>
AlertBody: string;
/// <summary>Caption of action button. Also see a value of <c>HasAction</c>.</summary>
/// <remarks>Working of this property depends of target platform.</remarks>
AlertAction: string;
/// <summary>Number on label of application icon or notification in Notification Center.</summary>
Number: Integer;
/// <summary>Date and Time, when notification shall appears. Used only in Scheduled notifications.</summary>
FireDate: TDateTime;
/// <summary>Turns Off or Turns On a playing sound, when notification is appeared.</summary>
/// <remarks>Playing sound depends on behavior of target platform.</remarks>
EnableSound: Boolean;
/// <summary>Sound's file name</summary>
SoundName: string;
/// <summary>True if notification should have action buttons. Returns False otherwise. </summary>
/// <remarks>Working of this property depends of target platform. For example, on iOS user need to allow application
/// to use it in General settings of devices.</remarks>
HasAction: Boolean;
/// <summary>Specifies interval for repeating notification in case, when we use scheduled notification</summary>
/// <remarks>If you would like to specify custom interval (30 minutes, 4 hours and etc. For example, if you would
/// like to show notification every 30 minutes, you need to create two notification, which will be shown every hour,
/// but will have difference in <c>fireDate</c> in 30 minutes.</remarks>
RepeatInterval: TRepeatInterval;
/// <summary>The id of the channel this notification posts to.</summary>
ChannelId: string;
/// <summary>Initializes of notification</summary>
constructor Create;
end;
TLockscreenVisibility = (Public, Private, Secret);
TImportance = (Unspecified, None, Default, Min, Low, High);
/// <summary>A representation of settings that apply to a collection of similarly themed notifications.</summary>
TChannel = class(TPersistent)
protected
/// <summary>Make a copy of data and save to Dest object</summary>
procedure AssignTo(Dest: TPersistent); override;
public
/// <summary>The id of this channel.</summary>
Id: string;
/// <summary>Visible name of this channel for user.</summary>
Title: string;
/// <summary>The user visible description of this channel.</summary>
Description: string;
/// <summary>Defines whether notifications posted to this channel appear on the lockscreen or not, and if so,
/// whether they appear in a redacted form.</summary>
LockscreenVisibility: TLockscreenVisibility;
/// <summary>Importance of notification in this channel.</summary>
Importance: TImportance;
/// <summary>Whether notifications posted to this channel trigger notification lights.</summary>
ShouldShowLights: Boolean;
/// <summary>Whether notifications posted to this channel always vibrate.</summary>
ShouldVibrate: Boolean;
/// <summary>Whether notifications posted to this channel can appear as application icon badges in a Launcher.</summary>
ShouldShowBadge: Boolean;
constructor Create;
end;
{ TBaseNotificationCenter }
/// <summary>Array holding Notifications.</summary>
TNotifications = array of TNotification;
/// <summary>Signature of ReceiveLocalNotification Event</summary>
TOnReceiveLocalNotification = procedure (Sender: TObject; ANotification: TNotification) of object;
/// <summary>List holding Notification Channels.</summary>
TChannels = TList<TChannel>;
/// <summary>Class to use the Notification Center as framework</summary>
TBaseNotificationCenter = class
private
FOnReceiveLocalNotification: TOnReceiveLocalNotification;
class function InternalGetInstance: TBaseNotificationCenter; static;
protected
/// <summary>Platform getter.</summary>
class function GetInstance: TBaseNotificationCenter; virtual; abstract;
/// <summary>Schedules a local notification for delivery at its encapsulated date and time.</summary>
procedure DoScheduleNotification(const ANotification: TNotification); virtual; abstract;
/// <summary>Presents a local notification immediately.</summary>
procedure DoPresentNotification(const ANotification: TNotification); virtual; abstract;
/// <summary>Cancels the delivery of the specified scheduled local notification. |AName| - Unique identificator of
/// notification</summary>
procedure DoCancelNotification(const AName: string); overload; virtual; abstract;
/// <summary>Cancels the delivery of the specified scheduled local notification.</summary>
procedure DoCancelNotification(const ANotification: TNotification); overload; virtual; abstract;
/// <summary>Cancels the delivery of all scheduled local notifications.</summary>
procedure DoCancelAllNotifications; virtual; abstract;
/// <summary>Creates or update system notification channel. If NotificationCenter has channel with the specified
/// channel id <c>AChannel.Id</c>, it updates it, otherwise - updates existed.</summary>
procedure DoCreateOrUpdateChannel(const AChannel: TChannel); virtual; abstract;
/// <summary>Removes existed notification channel by channel's Id.</summary>
procedure DoDeleteChannel(const AChannelId: string); virtual; abstract;
/// <summary>Returns list of all Notification channels in this application.</summary>
procedure DoGetAllChannels(const AChannels: TChannels); virtual; abstract;
/// <summary>The number currently set as the badge of the application icon.</summary>
procedure DoSetIconBadgeNumber(const ACount: Integer); virtual; abstract;
/// <summary>Getting The number currently set as the badge of the application icon.</summary>
function DoGetIconBadgeNumber: Integer; virtual; abstract;
/// <summary>Reset the number of the application icon.</summary>
procedure DoResetIconBadgeNumber; virtual; abstract;
/// <summary>Allows the user to write a response when the user clicks the notification message in the notification center.</summary>
procedure DoReceiveLocalNotification(const Sender: TObject; const M: TMessage); virtual;
/// <summary>Notify when the component is loaded in the form, so we can process a pending local notification.</summary>
procedure DoLoaded; virtual;
public
constructor Create;
destructor Destroy; override;
{ Notifications }
/// <summary>Create an empty Notification.</summary>
function CreateNotification: TNotification; overload;
/// <summary>Create a Notification with defined values.</summary>
function CreateNotification(const AName, AAlertBody: string; const AFireDate: TDateTime): TNotification; overload;
{ Presentation }
/// <summary>Fire a Notification.</summary>
procedure PresentNotification(const ANotification: TNotification);
/// <summary>Fire a Notification by its FireDate property.</summary>
procedure ScheduleNotification(const ANotification: TNotification);
/// <summary>Cancel all Notification.</summary>
procedure CancelAll;
/// <summary>Cancel a Notification by its name.</summary>
procedure CancelNotification(const AName: string);
{ Channels }
/// <summary>Creates or update system notification channel. If NotificationCenter has channel with the specified
/// channel id <c>AChannel.Id</c>, it updates it, otherwise - updates existed.</summary>
procedure CreateOrUpdateChannel(const AChannel: TChannel);
/// <summary>Removes existed notification channel by channel's Id.</summary>
/// <remarks>Only for the Android.</remarks>
procedure DeleteChannel(const AChannelId: string);
/// <summary>Fill passed list with all Notification channels in this application.</summary>
/// <remarks>Only for the Android. User should remove instances of channels himself.</remarks>
procedure GetAllChannels(const AChannels: TChannels);
{ Properties }
/// <summary>Property to access to the Icon Badge Number.</summary>
property ApplicationIconBadgeNumber: Integer read DoGetIconBadgeNumber write DoSetIconBadgeNumber;
/// <summary>Event to notify that we have received a local notification.</summary>
property OnReceiveLocalNotification: TOnReceiveLocalNotification read FOnReceiveLocalNotification
write FOnReceiveLocalNotification;
end;
{ TNotificationCenter }
/// <summary>Class to use the Notification Center as a component</summary>
TCustomNotificationCenter = class(TComponent)
private
FPlatformNotificationCenter: TBaseNotificationCenter;
FOnReceiveLocalNotification: TOnReceiveLocalNotification;
class constructor Create;
protected
/// <summary>Schedules a local notification for delivery at its encapsulated date and time.</summary>
procedure DoScheduleNotification(const ANotification: TNotification); virtual;
/// <summary>Presents a local notification immediately.</summary>
procedure DoPresentNotification(const ANotification: TNotification); virtual;
/// <summary>Cancels the delivery of the specified scheduled local notification. |AName| - Unique identificator of
/// notification</summary>
procedure DoCancelNotification(const AName: string); overload; virtual;
/// <summary>Cancels the delivery of the specified scheduled local notification.</summary>
procedure DoCancelNotification(const ANotification: TNotification); overload; virtual;
/// <summary>Cancels the delivery of all scheduled local notifications.</summary>
procedure DoCancelAllNotifications; virtual;
/// <summary>Creates or update system notification channel. If NotificationCenter has channel with the specified
/// channel id <c>AChannel.Id</c>, it updates it, otherwise - updates existed.</summary>
procedure DoCreateOrUpdateChannel(const AChannel: TChannel); virtual;
/// <summary>Removes existed notification channel by channel's Id.</summary>
procedure DoDeleteChannel(const AChannelId: string); virtual;
/// <summary>Returns list of all Notification channels in this application.</summary>
procedure DoGetAllChannels(const AChannels: TChannels); virtual;
/// <summary>The number currently set as the badge of the application icon.</summary>
procedure DoSetIconBadgeNumber(const ACount: Integer); virtual;
/// <summary>Getting The number currently set as the badge of the application icon.</summary>
function DoGetIconBadgeNumber: Integer; virtual;
/// <summary>Reset the number of the application icon.</summary>
procedure DoResetIconBadgeNumber; virtual;
/// <summary>Allows the user to write a response when the user clicks the notification message in the notification center.</summary>
procedure DoReceiveLocalNotification(const Sender: TObject; const M: TMessage); virtual;
/// <summary>Event fired when the component is fully loaded, so we can check if we have a notification.</summary>
procedure DoLoaded; virtual;
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
procedure Loaded; override;
/// <summary>Is notification center supported on current platform or not?</summary>
function Supported: Boolean; inline;
{ Building }
/// <summary>Create an empty Notification.</summary>
function CreateNotification: TNotification; overload;
/// <summary>Create a Notification with defined values.</summary>
function CreateNotification(const AName, AAlertBody: string; const AFireDate: TDateTime): TNotification; overload;
/// <summary>Create an empty Notification.</summary>
function CreateChannel: TChannel; overload;
/// <summary>Create a Notification channel with defined values.</summary>
function CreateChannel(const AId: string; const ATitle: string; const ADescription: string = ''): TChannel; overload;
{ Presentation }
/// <summary>Fire a Notification.</summary>
procedure PresentNotification(const ANotification: TNotification);
/// <summary>Fire a Notification by its FireDate property.</summary>
procedure ScheduleNotification(const ANotification: TNotification);
/// <summary>Cancel all Notification.</summary>
procedure CancelAll;
/// <summary>Cancel a Notification by its name.</summary>
procedure CancelNotification(const AName: string);
{ Channels }
/// <summary>Creates or update system notification channel. If NotificationCenter has channel with the specified
/// channel id <c>AChannel.Id</c>, it updates it, otherwise - updates existed.</summary>
procedure CreateOrUpdateChannel(const AChannel: TChannel);
/// <summary>Removes existed notification channel by channel's Id.</summary>
/// <remarks>Only for the Android.</remarks>
procedure DeleteChannel(const AChannelId: string);
/// <summary>Fill passed list with all Notification channels in this application.</summary>
/// <remarks>Only for the Android. User should remove instances of channels himself.</remarks>
procedure GetAllChannels(const AChannels: TChannels);
{ Properties }
/// <summary>Property to access to the Icon Badge Number.</summary>
property ApplicationIconBadgeNumber: Integer read DoGetIconBadgeNumber write DoSetIconBadgeNumber default 0;
/// <summary>Event to notify that we have received a local notification.</summary>
property OnReceiveLocalNotification: TOnReceiveLocalNotification read FOnReceiveLocalNotification
write FOnReceiveLocalNotification;
end;
[ComponentPlatformsAttribute(pfidOSX or pfidiOS or pfidAndroid or pfidWindows)]
TNotificationCenter = class(TCustomNotificationCenter)
published
property ApplicationIconBadgeNumber;
property OnReceiveLocalNotification;
end;
implementation
uses
System.SysConst,
{$IFDEF IOS}
System.iOS.Notification;
{$ENDIF IOS}
{$IFDEF OSX}
System.Mac.Notification;
{$ENDIF OSX}
{$IFDEF ANDROID}
System.Android.Notification;
{$ENDIF ANDROID}
{$IFDEF MSWINDOWS}
System.Win.Notification;
{$ENDIF MSWINDOWS}
{ TNotificationCenter }
procedure TCustomNotificationCenter.CancelAll;
begin
DoCancelAllNotifications;
end;
procedure TCustomNotificationCenter.CancelNotification(const AName: string);
begin
DoCancelNotification(AName);
end;
constructor TCustomNotificationCenter.Create(AOwner: TComponent);
begin
inherited;
FPlatformNotificationCenter := TBaseNotificationCenter.InternalGetInstance;
TMessageManager.DefaultManager.SubscribeToMessage(TMessage<TNotification>, DoReceiveLocalNotification);
end;
function TCustomNotificationCenter.CreateChannel(const AId, ATitle, ADescription: string): TChannel;
begin
if Supported then
begin
Result := TChannel.Create;
Result.Id := AId;
Result.Title := ATitle;
Result.Description := ADescription;
end
else
Result := nil;
end;
function TCustomNotificationCenter.CreateChannel: TChannel;
begin
if Supported then
Result := TChannel.Create
else
Result := nil;
end;
function TCustomNotificationCenter.CreateNotification: TNotification;
begin
if Supported then
Result := FPlatformNotificationCenter.CreateNotification
else
Result := nil;
end;
class constructor TCustomNotificationCenter.Create;
begin
{$IF defined(IOS) or defined(ANDROID)}
// We need to create the NotificationCenter to register the external notification messages from the system in the app initialization
TBaseNotificationCenter.InternalGetInstance;
{$ENDIF}
end;
function TCustomNotificationCenter.CreateNotification(const AName, AAlertBody: string; const AFireDate: TDateTime): TNotification;
begin
if Supported then
Result := FPlatformNotificationCenter.CreateNotification(AName, AAlertBody, AFireDate)
else
Result := nil;
end;
procedure TCustomNotificationCenter.CreateOrUpdateChannel(const AChannel: TChannel);
begin
if AChannel <> nil then
DoCreateOrUpdateChannel(AChannel)
else
raise Exception.CreateRes(@SVarInvalid);
end;
procedure TCustomNotificationCenter.DeleteChannel(const AChannelId: string);
begin
DoDeleteChannel(AChannelId);
end;
destructor TCustomNotificationCenter.Destroy;
begin
TMessageManager.DefaultManager.Unsubscribe(TMessage<TNotification>, DoReceiveLocalNotification);
inherited;
end;
procedure TCustomNotificationCenter.DoCancelAllNotifications;
begin
if Supported then
FPlatformNotificationCenter.DoCancelAllNotifications;
end;
procedure TCustomNotificationCenter.DoCancelNotification(const AName: string);
begin
if Supported then
FPlatformNotificationCenter.DoCancelNotification(AName);
end;
procedure TCustomNotificationCenter.DoCancelNotification(const ANotification: TNotification);
begin
if Supported then
FPlatformNotificationCenter.DoCancelNotification(ANotification);
end;
procedure TCustomNotificationCenter.DoCreateOrUpdateChannel(const AChannel: TChannel);
begin
if Supported then
FPlatformNotificationCenter.DoCreateOrUpdateChannel(AChannel);
end;
procedure TCustomNotificationCenter.DoDeleteChannel(const AChannelId: string);
begin
if Supported then
FPlatformNotificationCenter.DoDeleteChannel(AChannelId);
end;
procedure TCustomNotificationCenter.DoGetAllChannels(const AChannels: TChannels);
begin
if Supported then
FPlatformNotificationCenter.DoGetAllChannels(AChannels);
end;
function TCustomNotificationCenter.DoGetIconBadgeNumber: Integer;
begin
if Supported then
Result := FPlatformNotificationCenter.DoGetIconBadgeNumber
else
Result := 0;
end;
procedure TCustomNotificationCenter.DoLoaded;
begin
if Supported then
FPlatformNotificationCenter.DoLoaded;
end;
procedure TCustomNotificationCenter.DoPresentNotification(const ANotification: TNotification);
begin
if Supported then
FPlatformNotificationCenter.DoPresentNotification(ANotification);
end;
procedure TCustomNotificationCenter.DoReceiveLocalNotification(const Sender: TObject; const M: TMessage);
begin
if Assigned(FOnReceiveLocalNotification) and (M is TMessage<TNotification>) then
FOnReceiveLocalNotification(Self, TMessage<TNotification>(M).Value);
end;
procedure TCustomNotificationCenter.DoResetIconBadgeNumber;
begin
if Supported then
FPlatformNotificationCenter.DoResetIconBadgeNumber;
end;
procedure TCustomNotificationCenter.DoScheduleNotification(const ANotification: TNotification);
begin
if Supported then
FPlatformNotificationCenter.DoScheduleNotification(ANotification);
end;
procedure TCustomNotificationCenter.DoSetIconBadgeNumber(const ACount: Integer);
begin
if Supported then
FPlatformNotificationCenter.DoSetIconBadgeNumber(ACount);
end;
procedure TCustomNotificationCenter.GetAllChannels(const AChannels: TChannels);
begin
if AChannels <> nil then
DoGetAllChannels(AChannels)
else
raise Exception.CreateRes(@SVarInvalid);
end;
procedure TCustomNotificationCenter.Loaded;
begin
inherited;
DoLoaded;
end;
procedure TCustomNotificationCenter.PresentNotification(const ANotification: TNotification);
begin
DoPresentNotification(ANotification);
end;
procedure TCustomNotificationCenter.ScheduleNotification(const ANotification: TNotification);
begin
DoScheduleNotification(ANotification);
end;
function TCustomNotificationCenter.Supported: Boolean;
begin
Result := FPlatformNotificationCenter <> nil;
end;
{ TNotification }
procedure TNotification.AssignTo(Dest: TPersistent);
var
DestNotification: TNotification;
begin
if Dest is TNotification then
begin
DestNotification := Dest as TNotification;
DestNotification.Name := Name;
DestNotification.Title := Title;
DestNotification.AlertBody := AlertBody;
DestNotification.AlertAction := AlertAction;
DestNotification.Number := Number;
DestNotification.FireDate := FireDate;
DestNotification.EnableSound := EnableSound;
DestNotification.SoundName := SoundName;
DestNotification.HasAction := HasAction;
DestNotification.RepeatInterval := RepeatInterval;
DestNotification.ChannelId := ChannelId;
end
else
inherited;
end;
constructor TNotification.Create;
begin
inherited;
EnableSound := True;
HasAction := False;
FireDate := Now;
RepeatInterval := TRepeatInterval.None;
Number := 0;
end;
{ TBaseNotificationCenter }
procedure TBaseNotificationCenter.CancelAll;
begin
DoCancelAllNotifications;
end;
procedure TBaseNotificationCenter.CancelNotification(const AName: string);
begin
DoCancelNotification(AName);
end;
constructor TBaseNotificationCenter.Create;
begin
inherited;
TMessageManager.DefaultManager.SubscribeToMessage(TMessage<TNotification>, DoReceiveLocalNotification);
end;
function TBaseNotificationCenter.CreateNotification: TNotification;
begin
Result := TNotification.Create;
end;
function TBaseNotificationCenter.CreateNotification(const AName, AAlertBody: string;
const AFireDate: TDateTime): TNotification;
begin
Result := CreateNotification;
Result.Name := AName;
Result.AlertBody := AAlertBody;
Result.FireDate := AFireDate;
end;
procedure TBaseNotificationCenter.CreateOrUpdateChannel(const AChannel: TChannel);
begin
DoCreateOrUpdateChannel(AChannel);
end;
procedure TBaseNotificationCenter.DeleteChannel(const AChannelId: string);
begin
DoDeleteChannel(AChannelId);
end;
destructor TBaseNotificationCenter.Destroy;
begin
TMessageManager.DefaultManager.Unsubscribe(TMessage<TNotification>, DoReceiveLocalNotification);
inherited;
end;
procedure TBaseNotificationCenter.DoLoaded;
begin
//
end;
procedure TBaseNotificationCenter.DoReceiveLocalNotification(const Sender: TObject; const M: TMessage);
begin
if Assigned(FOnReceiveLocalNotification) and (M is TMessage<TNotification>) then
FOnReceiveLocalNotification(Self, TMessage<TNotification>(M).Value);
end;
procedure TBaseNotificationCenter.GetAllChannels(const AChannels: TChannels);
begin
DoGetAllChannels(AChannels);
end;
class function TBaseNotificationCenter.InternalGetInstance: TBaseNotificationCenter;
type
TBaseNotificationCenterClass = class of TBaseNotificationCenter;
var
LBaseNotificationCenterClass: TBaseNotificationCenterClass;
begin
LBaseNotificationCenterClass := TPlatformNotificationCenter;
Result := LBaseNotificationCenterClass.GetInstance;
end;
procedure TBaseNotificationCenter.PresentNotification(const ANotification: TNotification);
begin
DoPresentNotification(ANotification);
end;
procedure TBaseNotificationCenter.ScheduleNotification(const ANotification: TNotification);
begin
DoScheduleNotification(ANotification);
end;
{ TChannel }
procedure TChannel.AssignTo(Dest: TPersistent);
var
DestChannel: TChannel;
begin
if Dest is TChannel then
begin
DestChannel := Dest as TChannel;
DestChannel.Id := Id;
DestChannel.Title := Title;
DestChannel.Description := Description;
DestChannel.LockscreenVisibility := LockscreenVisibility;
DestChannel.Importance := Importance;
DestChannel.ShouldShowLights := ShouldShowLights;
DestChannel.ShouldVibrate := ShouldVibrate;
DestChannel.ShouldShowBadge := ShouldShowBadge;
end
else
inherited;
end;
constructor TChannel.Create;
begin
Importance := TImportance.Unspecified;
LockscreenVisibility := TLockscreenVisibility.Public;
end;
end.
|
unit customxml;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils, StrUtils, Utility, Variants,
laz2_DOM, laz2_XMLRead, laz2_XMLWrite, laz2_XMLCfg, laz2_XMLUtils{, laz2_XMLStreaming};
type
tNewFileProc = procedure of object;
rStackNode = specialize rNode<TDOMNode>;
pStackNode = ^rStackNode;
eNodeLocation = (lAll, lChildNodes, lThisNode);
{ tXMLFile }
tXMLFile = class
//OnNewFile: tNewFileProc;
Doc: TXMLDocument;
RootNode: TDOMElement;
Stack: pStackNode;
{function GetIntValue(Criteria: string): longint;
function GetRealValue(Criteria: string): longint;
function GetStringValue(Criteria: string): longint;}
//property OnCreateNew: tNewFileProc read fNew write fNew;
private
FCurrentNode: TDOMNode;
Modified: boolean;
FileName: string;
procedure Push(n: TDomNode);
function Pop: TDomNode;
function GetCurrentNode: TDOMNode;
public
constructor CreateNew(fn: string; Overwrite: boolean = false; RootNodeName: string = '');
constructor Open(fn: string);
property CurrentNode: TDOMNode read GetCurrentNode;
procedure AddNode(Name: string);
function GetValue(Name: string): variant;
procedure SetValue(Name: string; Value: variant);
function FindNode(Name: string; Location: eNodeLocation = lThisNode): boolean;
function Next: boolean;
function Prev: boolean;
function Back: boolean;
procedure BackToRoot;
function IterateNodesWithName(Name: string): boolean;
function Save: integer;
destructor Destroy; override;
end;
implementation
{ tXMLFile }
function tXMLFile.GetValue(Name: string): variant;
var
PassNode: TDOMNode;
e, a: longint;
d: double;
s: string;
begin
s:= TDOMElement(Stack^.Value).GetAttribute(Name);
val(s, a, e);
if e = 0 then
Result:= a
else
begin
val(s, d, e);
if e = 0 then
Result:= d
else
Result:= s;
end;
end;
procedure tXMLFile.SetValue(Name: string; Value: variant);
begin
try
TDOMElement(Stack^.Value).SetAttribute(Name, VarToStr(Value));
Modified:= true;
except
on E: Exception do
begin
WriteLog(E.Message);
//Result:= -1;
end;
end;
end;
procedure tXMLFile.AddNode(Name: string);
var
DNode: TDOMNode;
begin
DNode := Doc.CreateElement(Name);
Stack^.Value.AppendChild(DNode);
Push(DNode);
Modified:= true;
end;
function tXMLFile.FindNode(Name: string; Location: eNodeLocation): boolean;
var
p: pStackNode;
DNode: TDOMNode;
begin
case Location of
lAll: DNode:= nil;
lChildNodes:
begin
{
s:= Copy2SymbDel(Name, '.');
PassNode:= RootNode.FindNode(s);
if PassNode = nil then
begin
PassNode:= Doc.CreateElement(s);
s:= VarToStr(Value);
TDOMElement(PassNode).SetAttribute(Name, s); //wrong
Node.AppendChild(PassNode);
end
else
begin
// PassNode.
end;
PassNode:= Doc.DocumentElement;
while pos('.', Name) <> 0 do
begin
s:= Copy2SymbDel(Name, '.');
// Retrieve the specified node
Node:= PassNode;
PassNode:= PassNode.FindNode(s);
if PassNode = nil then
begin
PassNode:= Doc.CreateElement(s);
Node.AppendChild(PassNode);
end;
end; }
DNode:= nil;
end;
lThisNode: DNode:= Stack^.Value.FindNode(Name);
end;
//writeln(Doc.TextContent);
if DNode <> nil then
begin
Push(DNode);
writeln(Stack^.Value.TextContent);
Result:= true;
end
else
Result:= false;
end;
function tXMLFile.Next: boolean;
var
NNode: TDOMNode;
begin
NNode:= CurrentNode.NextSibling;
if NNode <> nil then
begin
Result:= true;
Pop;
Push(NNode);
end
else
Result:= false;
end;
function tXMLFile.Prev: boolean;
var
NNode: TDOMNode;
begin
NNode:= CurrentNode.PreviousSibling;
if NNode <> nil then
begin
Result:= true;
Pop;
Push(NNode);
end
else
Result:= false;
end;
function tXMLFile.Back: boolean;
begin
if Stack^.Next <> nil then
begin
Result:= true;
Pop
end
else
Result:= false;
end;
procedure tXMLFile.BackToRoot;
begin
while Stack^.Next <> nil do
Pop // to free memory
end;
function tXMLFile.IterateNodesWithName(Name: string): boolean;
begin
{while IterateNodesWithName('Name') do
begin
...
end;
Back;
while IterateNodesWithName('NextName') do
begin
...
end;
}
if CurrentNode.NodeName = Name then
begin
Result:= Next;
if CurrentNode.NodeName <> Name then
begin
Result:= false;
Prev;
end
end
else
Result:= FindNode(Name);
//writeln(CurrentNode.NodeName);
end;
procedure tXMLFile.Push(n: TDomNode);
var
p: pStackNode;
begin
new(p);
with p^ do
begin
Value:= n;
Next:= Stack;
end;
Stack:= p;
end;
function tXMLFile.Pop: TDomNode;
var
p: pStackNode;
begin
Result:= Stack^.Value;
p:= Stack;
Stack:= Stack^.Next;
dispose(p);
end;
function tXMLFile.GetCurrentNode: TDOMNode;
begin
Result:= Stack^.Value;
end;
constructor tXMLFile.CreateNew(fn: string; Overwrite: boolean = false; RootNodeName: string = '');
begin
FileName:= fn;
try
if not Overwrite then
if FileExists(fn) then
raise Exception.Create('File already exists, overwrite not permitted');
Modified:= true;
if RootNodeName = '' then
RootNodeName:= fn;
Doc:= tXMLDocument.Create;
RootNode:= Doc.CreateElement(RootNodeName);
new(Stack);
Stack^.Next:= nil;
Stack^.Value:= RootNode;
Doc.AppendChild(RootNode);
except
on E: Exception do
begin
WriteLog(E.Message);
//E.Free;
Free;
//Result:= -1;
end;
end;
end;
constructor tXMLFile.Open(fn: string);
begin
Modified:= false;
FileName:= fn;
try
if not FileExists(fn) then
raise Exception.Create('File does not exist');
ReadXMLFile(Doc, FileName);
RootNode:= Doc.DocumentElement;
new(Stack);
Stack^.Next:= nil;
Stack^.Value:= RootNode;
except
on E: Exception do
begin
WriteLog(E.Message);
//E.Free;
Free;
end;
end;
end;
function tXMLFile.Save: integer;
begin
WriteXMLFile(Doc, FileName);
Result:= 1;
end;
destructor tXMLFile.Destroy;
begin
if Modified then
Save;
freeandnil(Doc);
inherited Destroy;
end;
end.
|
unit uEngine2DModel;
{$ZEROBASEDSTRINGS OFF}
interface
uses
System.Classes,System.SysUtils,System.UITypes,
FMX.Graphics,FMX.Objects,FMX.Dialogs,
uEngine2DClasses,uEngine2DExtend,uEngine2DObject,uEngineResource,
uEngine2DSprite, System.JSON, uEngine2DInvade;
{TEngine2DModel 类负责管理场景（包括场景布局信息加载、分发，动画精灵创建、修改、清除）}
Type
TEngine2DModel = class
private
FSpriteList : T2DNameList<TEngine2DSprite>;
FStarSpriteList : T2DNameList<TEngine2DSprite>; //管理星星
FBackgroundName : String;
FImage : TBitmap; //画布 ...
FResourceManager : TEngineResManager;
FInvadeManager : T2DInvadeManager;
FOriW, FOriH : Single; // 画布的初始大小....
function GetSpriteCount:Integer;
function GetStarSpriteCount:Integer;
procedure BringToFrontHandler(Sender: TObject);
procedure SendToBackHandler(Sender: TObject);
public
Constructor Create;
Destructor Destroy;override;
procedure LoadConfig(AImage:TBitmap;AConfigPath : String; AResManager : TEngineResManager);
procedure LoadResource(var OutBmp : TBitmap;ABmpName:String);
procedure UpdateSpriteBackground;
Procedure BringToFront(Sender : TObject);
procedure LoadNextConfig(AConfigPath :String);
property BackgroundName : String read FBackgroundName;
property ResourceManager : TEngineResManager read FResourceManager;
Property InvadeManager : T2DInvadeManager Read FInvadeManager;
property SpriteList : T2DNameList<TEngine2DSprite> read FSpriteList;
property StarSpriteList : T2DNameList<TEngine2DSprite> read FStarSpriteList;
property SpriteCount : Integer read GetSpriteCount;
property StarSpriteCount : Integer read GetStarSpriteCount;
property OriW : Single Read FOriW Write FOriW;
property OriH : Single Read FOriH Write FOriH;
end;
implementation
{ TEngine2DModel }
procedure TEngine2DModel.BringToFrontHandler(Sender: TObject);
var
LIndex : Integer;
begin
//FILO
LIndex := FSpriteList.IndexOf(TEngine2DSprite(Sender));
FSpriteList.Exchange(LIndex,FSpriteList.ItemCount-1);
end;
constructor TEngine2DModel.Create;
begin
FSpriteList := T2DNameList<TEngine2DSprite>.Create;
FStarSpriteList := T2DNameList<TEngine2DSprite>.Create;
// FResourceManager := TEngineResManager.Create;
FInvadeManager := T2DInvadeManager.Create;
end;
destructor TEngine2DModel.Destroy;
begin
FSpriteList.DisposeOf;
FStarSpriteList.DisposeOf;
// FResourceManager.DisposeOf;
FInvadeManager.DisposeOf;
inherited;
end;
function TEngine2DModel.GetSpriteCount: Integer;
begin
result := FSpriteList.ItemCount;
end;
function TEngine2DModel.GetStarSpriteCount: Integer;
begin
result := FStarSpriteList.ItemCount;
end;
procedure TEngine2DModel.LoadConfig(AImage:TBitmap;AConfigPath: String ; AResManager : TEngineResManager);
var
LSprite : TEngine2DSprite;
i: Integer;
LDebugCount : Integer;
S : String;
tmpArray : TJSONArray;
tmpValue : TJSONObject;
tmpSprite : TEngine2DSprite;
SW, SH : String;
begin
try
FImage := AImage;
FResourceManager := AResManager;
LoadNextConfig(AConfigPath);
// 星星只加载一次
tmpArray := FResourceManager.GetJSONArray('Star');
if tmpArray <> nil then
begin
for i := 0 to tmpArray.Size-1 do
begin
tmpValue := TJSONObject(tmpArray.Get(I));
LSprite := TEngine2DSprite.Create(FImage);
LSprite.ResManager := Self.FResourceManager;
LSprite.SetParentSize(FOriW, FOriH);
LSprite.InvadeManager := Self.FInvadeManager;
LSprite.ReadFromJSON(tmpValue);
Self.FStarSpriteList.Add(LSprite.Name, LSprite);
end;
end;
except on e : Exception do
ShowMessage('Error @TEngine2DModel.LoadConfig:'+e.Message);
end;
LDebugCount := 0;
end;
procedure TEngine2DModel.LoadNextConfig (AConfigPath :String);
var
LSprite : TEngine2DSprite;
i: Integer;
S : String;
tmpArray : TJSONArray;
tmpValue : TJSONObject;
tmpSprite : TEngine2DSprite;
SW, SH : String;
begin
try
FSpriteList.Clear;
FInvadeManager.FConvexPolygon.Clear;
// FResourceManager.UpdateConfig(AConfigPath);
// FBackgroundName := FResourceManager.GetJSONValue('Background');
SW := FResourceManager.GetJSONValue('OriW');
SH := FResourceManager.GetJSONValue('OriH');
FOriW := StrToIntDef(SW,1024);
FOriH := StrToIntDef(SH,768);
tmpArray := FResourceManager.GetJSONArray('Resource');
if tmpArray <> nil then
begin
// 根据 JSONArray 来创建Sprite...
for i := 0 to tmpArray.Size - 1 do
begin
tmpValue := TJSONObject(tmpArray.Get(I));
LSprite := TEngine2DSprite.Create(FImage);
LSprite.ResManager := Self.FResourceManager;
LSprite.SetParentSize(FOriW, FOriH);
LSprite.InvadeManager := Self.FInvadeManager;
LSprite.ReadFromJSON(tmpValue);
Self.FSpriteList.Add(LSprite.Name, LSprite);
end;
end;
except on e : Exception do
ShowMessage('Error @TEngine2DModel.LoadNextConfig:'+e.Message);
end;
end;
procedure TEngine2DModel.LoadResource(var OutBmp: TBitmap; ABmpName: String);
var
LTmp : TBitmap;
begin
if Not Assigned(OutBmp) then
OutBmp := TBitmap.Create else
OutBmp.Clear($ff000000);
FResourceManager.LoadResource(OutBmp,ABmpName);
end;
procedure TEngine2DModel.SendToBackHandler(Sender: TObject);
var
LIndex : Integer;
begin
//FILO
LIndex:= FSpriteList.IndexOf(TEngine2DSprite(Sender));
FSpriteList.Exchange(LIndex,0);
end;
procedure TEngine2DModel.UpdateSpriteBackground;
var
i : Integer;
LObject : TEngine2DSprite;
begin
for i := 0 to FSpriteList.ItemCount-1 do
begin
LObject := FSpriteList.Items[i];
if LObject.Visible then
begin
LObject.UpdateSpriteBackground;
end;
end;
end;
Procedure TEngine2DModel.BringToFront(Sender: TObject);
Var
LIndex : Integer;
begin
LIndex := FSpriteList.IndexOf(TEngine2DSprite(Sender));
FSpriteList.Exchange(LIndex,FSpriteList.ItemCount-1);
end;
end.
|
unit triangle;
interface
function RedToDec (x:real):real;
function DecToRed (x:real):real;
function DecSin (x:real):real;
function DecCos (x:real):real;
function DecTan (x:real):real;
function DecCot (x:real):real;
function ArcSin (x:real):real;
function ArcCos (x:real):real;
function ArcCot (x:real):real;
function DecASin(x:real):real;
function DecACos(x:real):real;
function DecATan(x:real):real;
function DecACot(x:real):real;
implementation
function redtodec;
begin
redtodec:=x/pi*180
end;
function dectored;
begin
dectored:=x/180*pi
end;
function decsin;
begin
decsin:=sin(dectored(x))
end;
function deccos;
begin
deccos:=cos(dectored(x))
end;
function dectan;
begin
dectan:=decsin(x)/deccos(x)
end;
function deccot;
begin
deccot:=deccos(x)/decsin(x)
end;
function arcsin;
begin
arcsin:=ArcTan(x/sqrt(1-sqr(x)));
end;
function arccos;
begin
ArcCos:=ArcTan(sqrt(1-sqr(x))/x)
end;
function arccot;
begin
arccot:=arctan(1/x)
end;
function decasin;
begin
decasin:=redtodec(ArcSin(x));
end;
function decacos;
begin
DecACos:=redtodec(arccos(x));
end;
function decatan;
begin
decatan:=redtodec(arctan(x))
end;
function decacot;
begin
decacot:=redtodec(arccot(x))
end;
end.
|
{ Copyright (C) 1998-2018, written by Mike Shkolnik, Scalabium Software
E-Mail: mshkolnik@scalabium.com
mshkolnik@yahoo.com
WEB: http://www.scalabium.com
The TSMScript is a wrapper for MS Script Control which allow to
execute any script for VBScript, JavaScript languages (and any other registred language)
MS ScriptControl:
http://download.microsoft.com/download/winscript56/Install/1.0/W982KMeXP/EN-US/sct10en.exe
must be installed on Win 98, ME and NT 4.0 (in Win 2000 is installed by default)
}
unit SMScript;
interface
{$I SMVersion.inc}
uses Classes, ActiveX, Windows, SysUtils, TypInfo;
type
TSMScriptExecutor = class;
TSMSEError = class
private
{ Private declarations }
FScriptExecutor: TSMScriptExecutor;
FNumber: string;
FSource: string;
FDescription: string;
FText: string;
FLine: Integer;
FColumn: Integer;
protected
{ Protected declarations }
public
{ Public declarations }
constructor Create(AScriptExecutor: TSMScriptExecutor);
procedure Clear;
published
{ Published declarations }
property Number: string read FNumber write FNumber;
property Source: string read FSource write FSource;
property Description: string read FDescription write FDescription;
property Text: string read FText write FText;
property Line: Integer read FLine write FLine;
property Column: Integer read FColumn write FColumn;
end;
TSMSEModule = class;
{type of procedure: HasReturnValue?}
TSMSEProcedureType = (ptProcedure, ptFunction);
{procedure in module}
TSMSEProcedure = class(TCollectionItem)
private
{ Private declarations }
FProcName: string;
FNumArg: Integer;
FProcedureType: TSMSEProcedureType;
protected
{ Protected declarations }
public
{ Public declarations }
procedure Assign(Source: TPersistent); override;
published
{ Published declarations }
property ProcName: string read FProcName write FProcName;
property NumArg: Integer read FNumArg write FNumArg default 0;
property ProcedureType: TSMSEProcedureType read FProcedureType write FProcedureType default ptProcedure;
end;
{collection of procedures in module}
TSMSEProcedures = class(TCollection)
private
FModule: TSMSEModule;
function GetProcedure(Index: Integer): TSMSEProcedure;
procedure SetProcedure(Index: Integer; Value: TSMSEProcedure);
protected
function GetOwner: TPersistent; override;
public
constructor Create(AModule: TSMSEModule);
property Items[Index: Integer]: TSMSEProcedure read GetProcedure write SetProcedure; default;
end;
{module in script}
TSMSEModule = class(TCollectionItem)
private
{ Private declarations }
FModuleName: string;
FProcedures: TSMSEProcedures;
function GetProcedures: TSMSEProcedures;
procedure SetProcedures(Value: TSMSEProcedures);
protected
{ Protected declarations }
public
{ Public declarations }
constructor Create(Collection: TCollection); override;
destructor Destroy; override;
procedure Assign(Source: TPersistent); override;
procedure AddCode(const Code: string);
function Eval(const Expression: string): Variant;
procedure ExecuteStatement(const Statement: string);
function Run(const ProcedureName: string; Parameters: OLEVariant): OLEVariant;
published
{ Published declarations }
property ModuleName: string read FModuleName write FModuleName;
property Procedures: TSMSEProcedures read GetProcedures write SetProcedures;
end;
{module collection}
TSMSEModules = class(TCollection)
private
FScriptExecutor: TSMScriptExecutor;
function GetModule(Index: Integer): TSMSEModule;
procedure SetModule(Index: Integer; Value: TSMSEModule);
protected
function GetOwner: TPersistent; override;
public
constructor Create(AScriptExecutor: TSMScriptExecutor);
function GetModuleByName(const Value: string): TSMSEModule;
property Items[Index: Integer]: TSMSEModule read GetModule write SetModule; default;
end;
LongWord = dWORD;
PLongWord = PDWORD;
EInvalidParamCount = class(Exception)
end;
EInvalidParamType = class(Exception)
end;
IQueryPersistent = interface
['{26F5B6E1-9DA5-11D3-BCAD-00902759A497}']
function GetPersistent: TPersistent;
end;
IEnumVariant = interface(IUnknown)
['{00020404-0000-0000-C000-000000000046}']
function Next(celt: LongWord; var rgvar : OleVariant;
pceltFetched: PLongWord): HResult; stdcall;
function Skip(celt: LongWord): HResult; stdcall;
function Reset: HResult; stdcall;
function Clone(out Enum: IEnumVariant): HResult; stdcall;
end;
TVCLProvider = class(TInterfacedObject, IDispatch, IQueryPersistent)
private
FOwner: TPersistent;
FScriptControl: TSMScriptExecutor;
procedure DoCreateControl(AName, AClassName: WideString; WithEvents: Boolean);
function SetVCLProperty(PropInfo: PPropInfo; Argument: TVariantArg): HRESULT;
function GetVCLProperty(PropInfo: PPropInfo; dps: TDispParams;
PDispIds: PDispIdList; var Value: OleVariant): HRESULT;
{ IDispatch }
function GetTypeInfoCount(out Count: Integer): HResult; stdcall;
function GetTypeInfo(Index, LocaleID: Integer; out TypeInfo): HResult; stdcall;
function GetIDsOfNames(const IID: TGUID; Names: Pointer;
NameCount, LocaleID: Integer; DispIDs: Pointer): HResult; stdcall;
function Invoke(DispID: Integer; const IID: TGUID; LocaleID: Integer;
Flags: Word; var Params; VarResult, ExcepInfo, ArgErr: Pointer): HResult; stdcall;
{ IQueryPersistent }
function GetPersistent: TPersistent;
protected
function DoInvoke (DispID: Integer; const IID: TGUID; LocaleID: Integer;
Flags: Word; var dps : TDispParams; pDispIds : PDispIdList;
VarResult, ExcepInfo, ArgErr: Pointer): HResult; virtual;
public
constructor Create(AOwner: TPersistent; ScriptControl: TSMScriptExecutor);
destructor Destroy; override;
end;
TVCLEnumerator = class(TInterfacedObject, IEnumVariant)
private
FEnumPosition: Integer;
FOwner: TPersistent;
FScriptControl: TSMScriptExecutor;
{ IEnumVariant }
function Next(celt: LongWord; var rgvar : OleVariant;
pceltFetched: PLongWord): HResult; stdcall;
function Skip(celt: LongWord): HResult; stdcall;
function Reset: HResult; stdcall;
function Clone(out Enum: IEnumVariant): HResult; stdcall;
public
constructor Create(AOwner: TPersistent; AScriptControl: TSMScriptExecutor);
end;
TSMScriptLanguage = (slCustom, slVBScript, slJavaScript);
{$IFDEF SM_ADD_ComponentPlatformsAttribute}
[ComponentPlatformsAttribute(pidWin32 or pidWin64)]
{$ENDIF}
TSMScriptExecutor = class(TComponent)
private
FAllowUI: Boolean;
FLanguage: TSMScriptLanguage;
FLanguageStr: string;
FTimeOut: Integer;
FScriptPrepared: Boolean;
FScriptBody: TStrings;
FUseSafeSubset: Boolean;
FLastError: TSMSEError;
FModules: TSMSEModules;
{for VCL objects}
FProviderList: TList;
procedure SetLanguage(Value: TSMScriptLanguage);
procedure SetLanguageStr(Value: string);
procedure SetScriptBody(Value: TStrings);
function GetLastError: TSMSEError;
function GetModules: TSMSEModules;
procedure SetModules(Value: TSMSEModules);
protected
{for VCL objects}
function GetProvider(AOwner: TPersistent): IDispatch;
procedure ProviderDestroyed(Address: Pointer);
public
ScriptControl: Variant;
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
procedure LoadScriptFunctions(const ScriptLib: string; list: TStrings; ClearList: Boolean);
procedure LoadMacro(const FileName: string);
procedure Prepare;
procedure ParseModules;
procedure Reset;
procedure AddCode(const Code: string);
function Eval(const Expression: string): Variant;
procedure ExecuteStatement(const Statement: string);
function Run(const ProcedureName: string; Parameters: OLEVariant): OLEVariant;
procedure AddObject(const Name: WideString; const Obj: IDispatch; AddMembers: WordBool);
{for VCL objects}
procedure RegisterClass(const Name: String; AClass: TPersistent);
property LastError: TSMSEError read GetLastError;
published
{for VCL objects}
procedure OnChangeHandler(Sender: TObject);
procedure OnClickHandler(Sender: TObject);
procedure OnEnterHandler(Sender: TObject);
procedure OnExitHandler(Sender: TObject);
procedure OnTimerHandler(Sender: TObject);
property AllowUI: Boolean read FAllowUI write FAllowUI default True;
property Language: TSMScriptLanguage read FLanguage write SetLanguage default slVBScript;
property LanguageStr: string read FLanguageStr write SetLanguageStr;
property Modules: TSMSEModules read GetModules write SetModules;
property TimeOut: Integer read FTimeOut write FTimeOut default -1;
property UseSafeSubset: Boolean read FUseSafeSubset write FUseSafeSubset default True;
property ScriptBody: TStrings read FScriptBody write SetScriptBody;
end;
procedure Register;
implementation
uses ComObj, Controls, forms, Graphics
{$IFDEF SMForDelphi6} , Variants {$ENDIF}
;
{$R SMScript.DCR}
const
DefaultModule = 'Global';
procedure Register;
begin
RegisterComponents('SMComponents', [TSMScriptExecutor]);
end;
{ TSMSEError }
constructor TSMSEError.Create(AScriptExecutor: TSMScriptExecutor);
begin
inherited Create;
FScriptExecutor := AScriptExecutor
end;
procedure TSMSEError.Clear;
begin
FScriptExecutor.ScriptControl.Error.Clear
end;
{ TSMSEProcedure }
procedure TSMSEProcedure.Assign(Source: TPersistent);
begin
if Source is TSMSEProcedure then
begin
if Assigned(Collection) then
Collection.BeginUpdate;
try
NumArg := TSMSEProcedure(Source).NumArg;
ProcedureType := TSMSEProcedure(Source).ProcedureType;
finally
if Assigned(Collection) then
Collection.EndUpdate;
end;
end
else
inherited Assign(Source);
end;
{ TSMSEProcedures }
constructor TSMSEProcedures.Create(AModule: TSMSEModule);
begin
inherited Create(TSMSEProcedure);
FModule := AModule;
end;
function TSMSEProcedures.GetOwner: TPersistent;
begin
Result := FModule;
end;
function TSMSEProcedures.GetProcedure(Index: Integer): TSMSEProcedure;
begin
Result := TSMSEProcedure(inherited Items[Index]);
end;
procedure TSMSEProcedures.SetProcedure(Index: Integer; Value: TSMSEProcedure);
begin
Items[Index].Assign(Value);
end;
{ TSMSEModule }
constructor TSMSEModule.Create(Collection: TCollection);
begin
inherited Create(Collection);
FProcedures := TSMSEProcedures.Create(Self);
end;
destructor TSMSEModule.Destroy;
begin
FProcedures.Free;
inherited Destroy
end;
procedure TSMSEModule.Assign(Source: TPersistent);
begin
if Source is TSMSEModule then
begin
if Assigned(Collection) then
Collection.BeginUpdate;
try
Procedures := TSMSEModule(Source).Procedures;
finally
if Assigned(Collection) then
Collection.EndUpdate;
end;
end
else
inherited Assign(Source);
end;
function TSMSEModule.GetProcedures: TSMSEProcedures;
begin
Result := FProcedures;
end;
procedure TSMSEModule.SetProcedures(Value: TSMSEProcedures);
begin
FProcedures.Assign(Value);
end;
procedure TSMSEModule.AddCode(const Code: string);
begin
end;
function TSMSEModule.Eval(const Expression: string): Variant;
begin
end;
procedure TSMSEModule.ExecuteStatement(const Statement: string);
begin
end;
function TSMSEModule.Run(const ProcedureName: string; Parameters: OLEVariant): OLEVariant;
begin
end;
{ TSMSEModules }
constructor TSMSEModules.Create(AScriptExecutor: TSMScriptExecutor);
begin
inherited Create(TSMSEModule);
FScriptExecutor := AScriptExecutor
end;
function TSMSEModules.GetOwner: TPersistent;
begin
Result := FScriptExecutor
end;
function TSMSEModules.GetModule(Index: Integer): TSMSEModule;
begin
Result := TSMSEModule(inherited Items[Index]);
end;
procedure TSMSEModules.SetModule(Index: Integer; Value: TSMSEModule);
begin
Items[Index].Assign(Value);
end;
function TSMSEModules.GetModuleByName(const Value: string): TSMSEModule;
var
i: Integer;
begin
i := FScriptExecutor.ScriptControl.Modules[Value].Index;
Result := Items[i]
end;
{ TSMScriptExecutor }
constructor TSMScriptExecutor.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
FProviderList := TList.Create;
FModules := TSMSEModules.Create(Self);
FScriptBody := TStringList.Create;
FScriptPrepared := True;
Language := slVBScript;
AllowUI := True;
UseSafeSubset := True;
end;
destructor TSMScriptExecutor.Destroy;
begin
// ScriptControl.Reset;
ScriptControl := UnAssigned;
FScriptBody.Free;
FModules.Free;
if Assigned(FLastError) then
FLastError.Free;
FProviderList.Free;
FProviderList := nil;
inherited Destroy;
end;
const
arrScriptLanguage: array [TSMScriptLanguage] of string =
('', 'VBSCRIPT', 'JAVASCRIPT');
procedure TSMScriptExecutor.SetLanguage(Value: TSMScriptLanguage);
begin
if (FLanguage <> Value) then
begin
FLanguage := Value;
FLanguageStr := arrScriptLanguage[Value]
end;
end;
procedure TSMScriptExecutor.SetLanguageStr(Value: string);
var
strUpperValue: string;
begin
if (FLanguageStr <> Value) then
begin
FLanguageStr := Value;
strUpperValue := UpperCase(Value);
if (strUpperValue = arrScriptLanguage[slVBScript]) then
FLanguage := slVBScript
else
if (strUpperValue = arrScriptLanguage[slJavaScript]) then
FLanguage := slJavaScript
else
FLanguage := slCustom;
end;
end;
procedure TSMScriptExecutor.SetScriptBody(Value: TStrings);
begin
FScriptBody.Assign(Value);
FScriptPrepared := False;
end;
procedure TSMScriptExecutor.LoadMacro(const FileName: string);
begin
ScriptBody.LoadFromFile(FileName)
end;
function TSMScriptExecutor.GetModules: TSMSEModules;
begin
Result := FModules;
end;
procedure TSMScriptExecutor.SetModules(Value: TSMSEModules);
begin
FModules.Assign(Value);
end;
function TSMScriptExecutor.GetLastError: TSMSEError;
begin
if not Assigned(FLastError) then
FLastError := TSMSEError.Create(Self);
FLastError.Number := '';
FLastError.Source := '';
FLastError.Description := '';
FLastError.Text := '';
FLastError.Line := -1;
FLastError.Column := -1;
try
if not VarIsEmpty(ScriptControl) and not VarIsEmpty(ScriptControl.Error) then
begin
FLastError.Number := ScriptControl.Error.Number;
FLastError.Source := ScriptControl.Error.Source;
FLastError.Description := ScriptControl.Error.Description;
FLastError.Text := ScriptControl.Error.Text;
FLastError.Line := ScriptControl.Error.Line;
FLastError.Column := ScriptControl.Error.Column;
end;
except
end;
Result := FLastError;
end;
procedure TSMScriptExecutor.Prepare;
begin
if VarIsNull(ScriptControl) or
VarIsEmpty(ScriptControl) then
begin
ScriptControl := CreateOleObject('MSScriptControl.ScriptControl');
end;
if (FLanguage = slCustom) then
ScriptControl.Language := FLanguageStr
else
ScriptControl.Language := arrScriptLanguage[FLanguage];
ScriptControl.AllowUI := AllowUI;
ScriptControl.UseSafeSubset := UseSafeSubset;
{set the maximum run time allowed
PS: -1 stands for unlimited }
ScriptControl.TimeOut := FTimeOut;
Reset;
FScriptPrepared := True;
end;
procedure TSMScriptExecutor.ParseModules;
var
i, j: Integer;
begin
{build module and parameter lists}
// if (ScriptBody.Count > 0) then
// AddCode(ScriptBody.Text);
{clear current list of modules}
Modules.Clear;
{load a list of modules in current script}
for i := 1 to ScriptControl.Modules.Count do
begin
with (Modules.Add as TSMSEModule) do
begin
ModuleName := ScriptControl.Modules.Item[i].Name;
for j := 1 to ScriptControl.Modules.Item[i].Procedures.Count do
begin
with (Procedures.Add as TSMSEProcedure) do
begin
{ name of subroutine }
ProcName := ScriptControl.Modules.Item[i].Procedures.Item[j].Name;
{ total number of argument, if any }
NumArg := ScriptControl.Modules.Item[i].Procedures.Item[j].NumArgs;
{ type of routine }
if ScriptControl.Modules.Item[i].Procedures.Item[j].HasReturnValue then
ProcedureType := ptFunction
else
ProcedureType := ptProcedure
end;
end;
end;
end;
end;
{clear a cache from previos executed script}
procedure TSMScriptExecutor.Reset;
begin
ScriptControl.Reset;
end;
{load a script body}
procedure TSMScriptExecutor.AddCode(const Code: string);
begin
Prepare;
ScriptControl.Modules.Item[DefaultModule].AddCode(Code{ScriptBody.Text});
// ParseModules;
end;
{execute a statement within the context of the global module
Sample:
ScriptBody.Text := 'Sub HelloWorld(str)'+
' MsgBox str & " - , Hello from the large world of scripts"'+
'End Sub'
SMScriptExecutor.ExecuteStatement('Call Hello("Scalabium TSMScriptExecutor")');
or define a variable:
SMScriptExecutor.ExecuteStatement('str = "Scalabium TSMScriptExecutor"');
}
procedure TSMScriptExecutor.ExecuteStatement(const Statement: string);
begin
Prepare;
{Execute it as a direct statement}
ScriptControl.ExecuteStatement(Statement);
end;
{evaluate an expression within the context of the global module
Sample:
1. check a value of variable:
bool := SMScriptExecutor.Eval('x = 50');
2. return a variable value:
int := SMScriptExecutor.Eval('x');
}
function TSMScriptExecutor.Eval(const Expression: string): Variant;
begin
Prepare;
Result := ScriptControl.Eval(Expression);
end;
{run a procedure defined in the global module}
function TSMScriptExecutor.Run(const ProcedureName: string; Parameters: OLEVariant): OLEVariant;
begin
// if not FScriptPrepared then
// Prepare;
// ParseModules;
if VarIsEmpty(Parameters) {or VarIsNull(Parameters) }then
// ScriptControl.Run(ProcedureName)
ScriptControl.Modules.Item[DefaultModule].Run(ProcedureName)
else
ScriptControl.Modules.Item[DefaultModule].Run(ProcedureName, Parameters);
end;
{add to script engine some COM-object which will be "visible" from script}
procedure TSMScriptExecutor.AddObject(const Name: WideString; const Obj: IDispatch; AddMembers: WordBool);
begin
ScriptControl.AddObject(Name, Obj, AddMembers);
// ScriptControl.Modules.Item[DefaultModule].AddObject(Name, Obj, AddMembers);
end;
procedure TSMScriptExecutor.LoadScriptFunctions(const ScriptLib: string; list: TStrings; ClearList: Boolean);
procedure LoadInterface(TypeInfo: ITypeInfo; TypeAttr: PTypeAttr);
var
AName: WideString;
ADocString: WideString;
AHelpContext: LongInt;
FuncDesc: PFuncDesc;
i, j: Integer;
Names: PBStrList;
cNames: Integer;
strItem: string;
begin
TypeInfo.GetDocumentation(-1, @AName, @ADocString, @AHelpContext, nil);
New(Names);
try
// load functions
for i := 0 to TypeAttr.cFuncs - 1 do
begin
TypeInfo.GetFuncDesc(i, FuncDesc);
try
TypeInfo.GetDocumentation(FuncDesc.memid, @AName, @ADocString, @AHelpContext, nil);
strItem := AName;
if FuncDesc.cParams > 0 then
begin
strItem := strItem + '(';
// load parameters
TypeInfo.GetNames(FuncDesc.memid, Names, SizeOf(TBStrList), cNames);
// Skip Names[0] - it's the function name
for j := 1 to FuncDesc.cParams do
if j < 2 then
strItem := strItem + Names[j]
else
strItem := strItem + ', ' + Names[j];
strItem := strItem + ')';
end;
if (ADocString <> '') then
strItem := strItem + #9 + ADocString;
list.Add(strItem);
finally
TypeInfo.ReleaseFuncDesc(FuncDesc);
end;
end;
finally
Dispose(Names);
end;
end;
var
FLib: ITypeLib;
TypeInfo: ITypeInfo;
TypeAttr: PTypeAttr;
i: Integer;
begin
if ClearList then
list.Clear;
{load a library}
OleCheck(LoadTypeLib(PWideChar(WideString(ScriptLib)), FLib));
for i := 0 to FLib.GetTypeInfoCount - 1 do
begin
FLib.GetTypeInfo(i, TypeInfo);
OleCheck(TypeInfo.GetTypeAttr(TypeAttr));
try
if (TypeAttr.typeKind in [TKIND_DISPATCH, TKIND_INTERFACE]) then
LoadInterface(TypeInfo, TypeAttr);
finally
TypeInfo.ReleaseTypeAttr(TypeAttr);
end;
end;
end;
function ValidType(Argument: TVariantArg; TypeId: Integer;
RaiseException: Boolean): Boolean;
begin
Result := Argument.vt = TypeId;
if RaiseException and (not Result) then
raise EInvalidParamType.Create('');
end;
function CheckArgCount(Count: Integer; Accepted: array of Integer;
RaiseException: Boolean): Boolean;
var
I: Integer;
begin
Result := FALSE;
for I := Low(Accepted) to High(Accepted) do
begin
Result := Accepted[I] = Count;
if Result then
Break;
end;
if RaiseException and (not Result) then
raise EInvalidParamCount.Create('');
end;
function IntValue(Argument: TVariantArg): Integer;
var
VT: Word;
ByRef: Boolean;
begin
VT := Argument.vt;
ByRef := (VT and VT_BYREF) = VT_BYREF;
if ByRef then
begin
VT := VT and (not VT_BYREF);
case VT of
VT_I1: Result := Argument.pbVal^;
VT_I2: Result := Argument.piVal^;
VT_VARIANT: Result := Argument.pvarVal^;
else
Result := Argument.plVal^;
end;
end
else
case VT of
VT_I1: Result := Argument.bVal;
VT_I2: Result := Argument.iVal;
else
Result := Argument.lVal;
end;
end;
type
PNamesArray = ^TNamesArray;
TNamesArray = array[0..0] of PWideChar;
PDispIdsArray = ^TDispIdsArray;
TDispIdsArray = array[0..0] of Integer;
TVariantList = array [0..0] of OleVariant;
const
DISPID_CONTROLS = 1;
DISPID_COUNT = 2;
DISPID_ADD = 3;
DISPID_HASPROPERTY = 4;
{ TVCLProvider }
constructor TVCLProvider.Create(AOwner: TPersistent; ScriptControl: TSMScriptExecutor);
begin
inherited Create;
FOwner := AOwner;
FScriptControl := ScriptControl;
end;
function TVCLProvider.Invoke(DispID: Integer; const IID: TGUID; LocaleID: Integer;
Flags: Word; var Params; VarResult, ExcepInfo, ArgErr: Pointer): HResult;
var
dps : TDispParams absolute Params;
HasParams : boolean;
pDispIds : PDispIdList;
iDispIdsSize : integer;
WS: WideString;
I: Integer;
begin
pDispIds := nil;
iDispIdsSize := 0;
HasParams := (dps.cArgs > 0);
if HasParams then
begin
iDispIdsSize := dps.cArgs * SizeOf(TDispId);
GetMem(pDispIds, iDispIdsSize);
end;
try
if HasParams then
for I := 0 to dps.cArgs - 1 do
pDispIds^[I] := dps.cArgs - 1 - I;
try
Result := DoInvoke(DispId, IID, LocaleID, Flags, dps, pDispIds, VarResult, ExcepInfo, ArgErr);
except
on E: EInvalidParamCount do Result := DISP_E_BADPARAMCOUNT;
on E: EInvalidParamType do Result := DISP_E_BADVARTYPE;
on E: Exception do
begin
if Assigned(ExcepInfo) then
begin
FillChar(ExcepInfo^, SizeOf(TExcepInfo), 0);
TExcepInfo(ExcepInfo^).wCode := 1001;
TExcepInfo(ExcepInfo^).BStrSource := SysAllocString('TVCLProvider');
WS := E.Message;
TExcepInfo(ExcepInfo^).bstrDescription := SysAllocString(PWideChar(WS));
end;
Result := DISP_E_EXCEPTION;
end;
end;
finally
if HasParams then
FreeMem(pDispIds, iDispIdsSize);
end;
end;
function TVCLProvider.GetIDsOfNames(const IID: TGUID; Names: Pointer; NameCount,
LocaleID: Integer; DispIDs: Pointer): HResult;
var
S: string;
Info: PPropInfo;
begin
Result := S_OK;
{ get the method/property name }
S := PNamesArray(Names)[0];
{ check if such property exists }
Info := GetPropInfo(FOwner.ClassInfo, S);
if Assigned(Info) then
begin
{ if property exists, return the address for PropInfo as DispId }
PDispIdsArray(DispIds)[0] := Integer(Info);
end
else
{ if property not exists, check the predefined custom functions}
if CompareText(S, 'CONTROLS') = 0 then
begin
if (FOwner is TWinControl) then
PDispIdsArray(DispIds)[0] := DISPID_CONTROLS
else
Result := DISP_E_UNKNOWNNAME;
end
else
if CompareText(S, 'COUNT') = 0 then
begin
Result := S_OK;
{call for TCollection and TStrings only}
if (FOwner is TCollection) or (FOwner is TStrings)
or (FOwner is TWinControl) then
PDispIdsArray(DispIds)[0] := DISPID_COUNT
else
Result := DISP_E_UNKNOWNNAME;
end
else
if CompareText(S, 'ADD') = 0 then
begin
Result := S_OK;
{call for TCollection and TStrings only}
if (FOwner is TCollection) or (FOwner is TStrings) or
(FOwner is TWinControl) then
PDispIdsArray(DispIds)[0] := DISPID_ADD
else
Result := DISP_E_UNKNOWNNAME;
end
else
if CompareText(S, 'HASPROPERTY') = 0 then
PDispIdsArray(DispIds)[0] := DISPID_HASPROPERTY
else
Result := DISP_E_UNKNOWNNAME;
end;
function TVCLProvider.DoInvoke(DispID: Integer; const IID: TGUID;
LocaleID: Integer; Flags: Word; var dps: TDispParams;
pDispIds: PDispIdList; VarResult, ExcepInfo, ArgErr: Pointer): HResult;
{check if parameter with Index have a same type}
function _ValidType(Index, TypeId: Integer; RaiseException: Boolean): Boolean;
begin
Result := ValidType(dps.rgvarg^[pDispIds^[Index]], TypeId, RaiseException);
end;
{get the integer value for parameter by Index}
function _IntValue(Index: Integer): Integer;
begin
Result := IntValue(dps.rgvarg^[pDispIds^[Index]]);
end;
var
S: string;
Put: Boolean;
I: Integer;
P: TPersistent;
B: Boolean;
OutValue: OleVariant;
begin
Result := S_OK;
case DispId of
DISPID_NEWENUM: begin
{get the IEnumVariant interface for object (for ForEach)
and create the class with realization}
OleVariant(VarResult^) := TVCLEnumerator.Create(FOwner, FScriptControl) as IEnumVariant;
end;
DISPID_CONTROLS: begin
{Controls function called}
with FOwner as TWinControl do
begin
{check parameter}
CheckArgCount(dps.cArgs, [1], TRUE);
P := nil;
if _ValidType(0, VT_BSTR, FALSE) then
begin
{if this is string parameter, must find the child control with such name}
S := dps.rgvarg^[pDispIds^[0]].bstrVal;
for I := 0 to Pred(ControlCount) do
if CompareText(S, Controls[I].Name) = 0 then
begin
P := Controls[I];
Break;
end;
end
else
begin
{else find the child control by Index}
I := _IntValue(0);
P := Controls[I];
end;
{control not found}
if not Assigned(P) then
raise EInvalidParamType.Create('');
{return the IDispatch for component}
OleVariant(VarResult^) := FScriptControl.GetProvider(P);
end;
end;
DISPID_COUNT: begin
{check if Count function called without parameters}
CheckArgCount(dps.cArgs, [0], TRUE);
{return the count for child controls}
if FOwner is TWinControl then
OleVariant(VarResult^) := (FOwner as TWinControl).ControlCount;
{return the collection count}
if FOwner is TCollection then
OleVariant(VarResult^) := TCollection(FOwner).Count
else
{return the TStrings count}
if FOwner is TStrings then
OleVariant(VarResult^) := TStrings(FOwner).Count;
end;
DISPID_ADD: begin
{ADD function called}
if FOwner is TWinControl then
begin
{check parameter count}
CheckArgCount(dps.cArgs, [2,3], TRUE);
{check types for required parameters}
_ValidType(0, VT_BSTR, TRUE);
_ValidType(1, VT_BSTR, TRUE);
{third parameter is not required
False by default}
if (dps.cArgs = 3) and _ValidType(2, VT_BOOL, TRUE) then
B := dps.rgvarg^[pDispIds^[0]].vbool
else
B := False;
{call the method where we'll create a component}
DoCreateControl(dps.rgvarg^[pDispIds^[0]].bstrVal,
dps.rgvarg^[pDispIds^[1]].bstrVal, B)
end
else
if FOwner is TCollection then
begin
{add component}
P := TCollection(FOwner).Add;
{return the IDispatch}
OleVariant(varResult^) := FScriptControl.GetProvider(P);
end
else
if FOwner is TStrings then
begin
{check if parameters defined}
CheckArgCount(dps.cArgs, [1,2], TRUE);
{check if there is the string for first parameter}
_ValidType(0, VT_BSTR, TRUE);
if dps.cArgs = 2 then
{position in string list}
I := _IntValue(1)
else
{if not defined, add to end of list}
I := TStrings(FOwner).Count;
TStrings(FOwner).Insert(I, dps.rgvarg^[pDispIds^[0]].bstrVal);
end;
end;
DISPID_HASPROPERTY: begin
{check if parameters defined for HasProperty}
CheckArgCount(dps.cArgs, [1], TRUE);
{check the parameter type}
_ValidType(0, VT_BSTR, TRUE);
S := dps.rgvarg^[pDispIds^[0]].bstrVal;
{return True if property exists}
OleVariant(varResult^) := Assigned(GetPropInfo(FOwner.ClassInfo, S));
end;
else
{this is not our function but this is property
Check the Flags (to get or to set a property value)}
Put := (Flags and DISPATCH_PROPERTYPUT) <> 0;
if Put then
begin
{set property
Check the parameter and apply a value}
CheckArgCount(dps.cArgs, [1], True);
Result := SetVCLProperty(PPropInfo(DispId), dps.rgvarg^[pDispIds^[0]])
end
else
begin
{get property}
if DispId = 0 then
begin
{default property - return the IDispatch}
OleVariant(VarResult^) := Self as IDispatch;
Result := S_OK;
end
else
begin
{return the current value}
Result := GetVCLProperty(PPropInfo(DispId), dps, pDispIds, OutValue);
if Result = S_OK then
OleVariant(VarResult^) := OutValue;
end
end;
end;
end;
function TVCLProvider.GetTypeInfo(Index, LocaleID: Integer;
out TypeInfo): HResult;
begin
Pointer(TypeInfo) := NIL;
Result := E_NOTIMPL;
end;
function TVCLProvider.GetTypeInfoCount(out Count: Integer): HResult;
begin
Count := 0;
Result := E_NOTIMPL;
end;
procedure TVCLProvider.DoCreateControl(AName, AClassName: WideString; WithEvents: Boolean);
procedure SetHandler(Control: TPersistent; Owner:TObject; Name: String);
// To set the handler for method of form with Name property as
// Name + 'Handler'
var
Method: TMethod;
PropInfo: PPropInfo;
begin
// to get RTTI information
PropInfo := GetPropInfo(Control.ClassInfo, Name);
if Assigned(PropInfo) then
begin
{get the address for handler}
Method.Code := FScriptControl.MethodAddress(Name + 'Handler');
if Assigned(Method.Code) then
begin
{event exists}
Method.Data := FScriptControl;
{to set a handler}
SetMethodProp(Control, PropInfo, Method);
end;
end;
end;
var
ThisClass: TControlClass;
C: TComponent;
NewOwner: TCustomForm;
begin
{change the Owner as form}
if not (FOwner is TCustomForm) then
NewOwner := GetParentForm(FOwner as TControl)
else
NewOwner := FOwner as TCustomForm;
{get a class for new component}
ThisClass := TControlClass(GetClass(AClassName));
{create component}
C := ThisClass.Create(NewOwner);
{set the Name and Parent property}
C.Name := AName;
if C is TControl then
TControl(C).Parent := FOwner as TWinControl;
if WithEvents then
begin
{set our custom events}
SetHandler(C, NewOwner, 'OnClick');
SetHandler(C, NewOwner, 'OnChange');
SetHandler(C, NewOwner, 'OnEnter');
SetHandler(C, NewOwner, 'OnExit');
SetHandler(C, NewOwner, 'OnTimer');
end;
// create the class that realize the IDispatch and add this as object for TScriptControl
FScriptControl.RegisterClass(AName, C);
end;
function TVCLProvider.SetVCLProperty(PropInfo: PPropInfo;
Argument: TVariantArg): HResult;
var
I, J, K, CommaPos: Integer;
GoodToken: Boolean;
S, S1: string;
DT: TDateTime;
ST: TSystemTime;
IP: IQueryPersistent;
Data, TypeData: PTypeData;
TypeInfo: PTypeInfo;
begin
Result := S_OK;
case PropInfo^.PropType^.Kind of
tkChar,
tkString,
tkLString,
tkWChar,
{$IFDEF SMForDelphi2009} tkUString, {$ENDIF}
tkWString: // Символьная строка
begin
{check the parameter type and set a value}
ValidType(Argument, VT_BSTR, True);
SetStrProp(FOwner, PropInfo, Argument.bstrVal);
end;
tkInteger:
begin
// Проверяем тип свойства на TCursor, TColor
// если он совпадает и передано символьное значение
// пытаемся получить его идентификатор
if (UpperCase(PropInfo^.PropType^.Name) = 'TCURSOR') and
(Argument.vt = VT_BSTR) then
begin
if not IdentToCursor(Argument.bstrVal, I) then
begin
Result := DISP_E_BADVARTYPE;
Exit;
end;
end
else
if (UpperCase(PropInfo^.PropType^.Name) = 'TCOLOR') and
(Argument.vt = VT_BSTR) then
begin
if not IdentToColor(Argument.bstrVal, I) then
begin
Result := DISP_E_BADVARTYPE;
Exit;
end;
end
else
I := IntValue(Argument);
SetOrdProp(FOwner, PropInfo, I);
end;
tkEnumeration:
begin
// Проверяем на тип Boolean - для него в VBScript есть
// отдельный тип данных
if CompareText(PropInfo^.PropType^.Name, 'BOOLEAN') = 0 then
begin
// Проверяем тип данных аргумента
ValidType(Argument, VT_BOOL, TRUE);
// Это свойство Boolean - получаем значение и устанавливаем его
SetOrdProp(FOwner, PropInfo, Integer(Argument.vBool));
end
else
begin
// Иначе - перечислимый тип передается в виде символьной строки
// Проверяем тип данных аргумента
ValidType(Argument, VT_BSTR, TRUE);
// Получаем значение
S := Trim(Argument.bstrVal);
// Переводим в Integer
I := GetEnumValue(PropInfo^.PropType^, S);
// Если успешно - устанавливаем свойство
if I >= 0 then
SetOrdProp(FOwner, PropInfo, I)
else
raise EInvalidParamType.Create('');
end;
end;
tkClass:
begin
// check the type - must be IDispatch interfcae}
ValidType(Argument, VT_DISPATCH, TRUE);
if Assigned(Argument.dispVal) then
begin
// Передано непустое значение
// Получаем интерфейс IQueryPersistent
IP := IDispatch(Argument.dispVal) as IQueryPersistent;
// Получаем ссылку на класс, представителем которого
// является интерфейс
I := Integer(IP.GetPersistent);
end
else
// Иначе - очищаем свойство
I := 0;
// Устанавливаем значение
SetOrdProp(FOwner, PropInfo, I);
end;
tkFloat:
// Число с плавающей точкой
begin
if (PropInfo^.PropType^ = System.TypeInfo(TDateTime)) or
(PropInfo^.PropType^ = System.TypeInfo(TDate)) then
begin
// Проверяем тип данных аргумента
if Argument.vt = VT_BSTR then
begin
DT := StrToDate(Argument.bstrVal);
end
else
begin
ValidType(Argument, VT_DATE, TRUE);
if VariantTimeToSystemTime(Argument.date, ST) <> 0 then
DT := SystemTimeToDateTime(ST)
else
begin
Result := DISP_E_BADVARTYPE;
Exit;
end;
end;
SetFloatProp(FOwner, PropInfo, DT);
end
else
begin
// Проверяем тип данных аргумента
ValidType(Argument, VT_R8, TRUE);
// Устанавливаем значение}
SetFloatProp(FOwner, PropInfo, Argument.dblVal);
end;
end;
tkSet:
// Набор
begin
// Проверяем тип данных, должна быть символьная строка
ValidType(Argument, VT_BSTR, TRUE);
// Получаем данные
S := Trim(Argument.bstrVal);
// Получаем информацию RTTI
Data := GetTypeData(PropInfo^.PropType^);
TypeInfo := Data^.CompType^;
TypeData := GetTypeData(TypeInfo);
I := 0;
while Length(S) > 0 do
begin
// Проходим по строке, выбирая разделенные запятыми
// значения идентификаторов
CommaPos := Pos(',', S);
if CommaPos = 0 then
CommaPos := Length(S) + 1;
S1 := Trim(System.Copy(S, 1, CommaPos - 1));
System.Delete(S, 1, CommaPos);
if Length(S1) > 0 then
begin
// Поверяем, какому из допустимых значений соответствует
// полученный идентификатор
K := 1;
GoodToken := FALSE;
for J := TypeData^.MinValue to TypeData^.MaxValue do
begin
if CompareText(S1, GetEnumName(TypeInfo , J)) = 0 then
begin
// identificator is found, add to mask
I := I or K;
GoodToken := TRUE;
end;
K := K shl 1;
end;
if not GoodToken then
begin
// identificator is not found
Result := DISP_E_BADVARTYPE;
Exit;
end;
end;
end;
// to set a value
SetOrdProp(FOwner, PropInfo, I);
end;
tkVariant:
begin
// check the data type
ValidType(Argument, VT_VARIANT, TRUE);
// to set a value
SetVariantProp(FOwner, PropInfo, Argument.pvarVal^);
end;
else
// another data types are not supported by OLE
Result := DISP_E_MEMBERNOTFOUND;
end;
end;
function TVCLProvider.GetVCLProperty(PropInfo: PPropInfo; dps: TDispParams;
PDispIds: PDispIdList; var Value: OleVariant): HResult;
var
I, J, K: Integer;
S: String;
P, P1: TPersistent;
Data: PTypeData;
DT: TDateTime;
TypeInfo: PTypeInfo;
begin
Result := S_OK;
case PropInfo^.PropType^.Kind of
tkString,
tkLString,
tkWChar,
{$IFDEF SMForDelphi2009} tkUString, {$ENDIF}
tkWString:
// Символьная строка
Value := GetStrProp(FOwner, PropInfo);
tkChar, tkInteger:
// Целое число
Value := GetOrdProp(FOwner, PropInfo);
tkEnumeration:
// Перечислимый тип
begin
// Проверяем, не Boolean ли это
if CompareText(PropInfo^.PropType^.Name, 'BOOLEAN') = 0 then
begin
// Передаем как Boolean
Value := Boolean(GetOrdProp(FOwner, PropInfo));
end
else
begin
// Остальные - передаем как строку
I := GetOrdProp(FOwner, PropInfo);
Value := GetEnumName(PropInfo^.PropType^, I);
end;
end;
tkClass:
// Класс
begin
// Получаем значение свойства
P := TPersistent(GetOrdProp(FOwner, PropInfo));
if Assigned(P) and (P is TCollection) and (dps.cArgs = 1) then
begin
// Запрошен элемент коллекции с индексом (есть параметр)
if ValidType(dps.rgvarg^[pDispIds^[0]], VT_BSTR, FALSE) then
begin
// Параметр строковый, ищем элемент по свойству
// DisplayName
S := dps.rgvarg^[pDispIds^[0]].bstrVal;
P1 := nil;
for I := 0 to Pred(TCollection(P).Count) do
if CompareText(S, TCollection(P).Items[I].DisplayName) = 0 then
begin
P1 := TCollection(P).Items[I];
Break;
end;
if Assigned(P1) then
// Found - return the IDispatch interface
Value := FScriptControl.GetProvider(P1)
//IDispatch(TVCLProvider.Create(P1, FScriptControl))
else
// not found
Result := DISP_E_MEMBERNOTFOUND;
end
else
begin
// an integer parameter, return the element by index
I := IntValue(dps.rgvarg^[pDispIds^[0]]);
if (I >= 0) and (I < TCollection(P).Count) then
begin
P := TCollection(P).Items[I];
Value := FScriptControl.GetProvider(P);
//IDispatch(TVCLProvider.Create(P, FScriptControl));
end
else
Result := DISP_E_MEMBERNOTFOUND;
end;
end
else
if Assigned(P) and (P is TStrings) and (dps.cArgs = 1) then
begin
// Запрошен элемент из Strings с индексом (есть параметр)
if ValidType(dps.rgvarg^[pDispIds^[0]], VT_BSTR, FALSE) then
begin
// Параметр строковый - возвращаем значение свойства Values
S := dps.rgvarg^[pDispIds^[0]].bstrVal;
Value := TStrings(P).Values[S];
end
else
begin
// Параметр целый, возвращаем строку по индексу
I := IntValue(dps.rgvarg^[pDispIds^[0]]);
if (I >= 0) and (I < TStrings(P).Count) then
Value := TStrings(P)[I]
else
Result := DISP_E_MEMBERNOTFOUND;
end;
end
else
// Общий случай, возвращаем интерфейс IDispatch свойства
if Assigned(P) then
Value := FScriptControl.GetProvider(P)
//IDispatch(TVCLProvider.Create(P, FScriptControl))
else
// Или Unassigned, если P = NIL
Value := Unassigned;
end;
tkFloat:
begin
if (PropInfo^.PropType^ = System.TypeInfo(TDateTime)) or
(PropInfo^.PropType^ = System.TypeInfo(TDate)) then
begin
DT := GetFloatProp(FOwner, PropInfo);
Value := DT;
end
else
Value := GetFloatProp(FOwner, PropInfo);
end;
tkSet:
begin
// Получаем значение свойства (битовая маска)
I := GetOrdProp(FOwner, PropInfo);
// Получаем информацию RTTI
Data := GetTypeData(PropInfo^.PropType^);
TypeInfo := Data^.CompType^;
// Формируем строку с набором значений
S := '';
if I <> 0 then
begin
for K := 0 to 31 do
begin
J := 1 shl K;
if (J and I) = J then
S := S + GetEnumName(TypeInfo, K) + ',';
end;
System.Delete(S, Length(S), 1);
end;
Value := S;
end;
tkVariant:
// Вариант
Value := GetVariantProp(FOwner, PropInfo);
else
// Остальные типы не поддерживаются
Result := DISP_E_MEMBERNOTFOUND;
end;
end;
function TVCLProvider.GetPersistent: TPersistent;
begin
// Реализация IQueryPersistent
// Возвращаем ссылку на класс
Result := FOwner;
end;
destructor TVCLProvider.Destroy;
begin
// must delete self from object list TVCLProvider
FScriptControl.ProviderDestroyed(Self);
inherited;
end;
{ TVCLEnumerator }
constructor TVCLEnumerator.Create(AOwner: TPersistent; AScriptControl: TSMScriptExecutor);
begin
inherited Create;
FOwner := AOwner;
FScriptControl := AScriptControl;
FEnumPosition := 0;
end;
type
CVCLEnumerator = class of TVCLEnumerator;
function TVCLEnumerator.Clone(out Enum: IEnumVariant): HResult;
var
EnumeratorClass: CVCLEnumerator;
NewEnum: TVCLEnumerator;
begin
EnumeratorClass := CVCLENumerator(Self.ClassType);
NewEnum := EnumeratorClass.Create(FOwner, FScriptControl);
NewEnum.FEnumPosition := FEnumPosition;
Enum := NewEnum as IEnumVariant;
Result := S_OK;
end;
function TVCLEnumerator.Next(celt: LongWord; var rgvar: OleVariant;
pceltFetched: PLongWord): HResult;
var
I: Cardinal;
begin
Result := S_OK;
I := 0;
if FOwner is TWinControl then
begin
with TWinControl(FOwner) do
begin
while (FEnumPosition < ControlCount) and (I < celt) do
begin
TVariantList(rgvar)[I] :=
FScriptControl.GetProvider(Controls[FEnumPosition]);
// TVCLProvider.Create(Controls[FEnumPosition], FScriptControl) as IDispatch;
Inc(I);
Inc(FEnumPosition);
end;
end;
end
else
if FOwner is TCollection then
begin
with TCollection(FOwner) do
begin
while (FEnumPosition < Count) and (I < celt) do
begin
TVariantList(rgvar)[I] :=
FScriptControl.GetProvider(Items[FEnumPosition]);
// TVCLProvider.Create(Items[FEnumPosition], FScriptControl) as IDispatch;
Inc(I);
Inc(FEnumPosition);
end;
end;
end
else
if FOwner is TStrings then
begin
with TStrings(FOwner) do
begin
while (FEnumPosition < Count) and (I < celt) do
begin
TVariantList(rgvar)[I] := TStrings(FOwner)[FEnumPosition];
Inc(I);
Inc(FEnumPosition);
end;
end;
end
else
Result := S_FALSE;
if I <> celt then
Result := S_FALSE;
if Assigned(pceltFetched) then
pceltFetched^ := I;
end;
function TVCLEnumerator.Reset: HResult;
begin
FEnumPosition := 0;
Result := S_OK;
end;
function TVCLEnumerator.Skip(celt: LongWord): HResult;
var
Total: Integer;
begin
Result := S_FALSE;
if FOwner is TWinControl then
Total := TWinControl(FOwner).ControlCount
else
if FOwner is TCollection then
Total := TCollection(FOwner).Count
else
if FOwner is TStrings then
Total := TStrings(FOwner).Count
else
Exit;
{$WARNINGS OFF}
if FEnumPosition + celt <= Total then
begin
{$WARNINGS ON}
Result := S_OK;
Inc(FEnumPosition, celt)
end;
end;
function TSMScriptExecutor.GetProvider(AOwner: TPersistent): IDispatch;
var
I: Integer;
QP: IQueryPersistent;
begin
Result := nil;
with FProviderList do
for I := 0 to Pred(Count) do
begin
if TObject(FProviderList[I]).GetInterface(IQueryPersistent, QP) and
(QP.GetPersistent = AOwner) then
begin
Result := TVCLProvider(FProviderList[I]) as IDispatch;
Exit;
end;
end;
I := FProviderList.Add(TVCLProvider.Create(AOwner, Self));
Result := TVCLProvider(FProviderList[I]) as IDispatch;
end;
procedure TSMScriptExecutor.ProviderDestroyed(Address: Pointer);
begin
if Assigned(FProviderList) then
with FProviderList do
Delete(IndexOf(Address));
end;
procedure TSMScriptExecutor.RegisterClass(const Name: String;
AClass: TPersistent);
begin
AddObject(Name, GetProvider(AClass), False);
end;
procedure TSMScriptExecutor.OnChangeHandler(Sender: TObject);
begin
Run((Sender as TComponent).Name + '_' + 'OnChange', UnAssigned);
end;
procedure TSMScriptExecutor.OnClickHandler(Sender: TObject);
begin
Run((Sender as TComponent).Name + '_' + 'OnClick', UnAssigned);
end;
procedure TSMScriptExecutor.OnEnterHandler(Sender: TObject);
begin
Run((Sender as TComponent).Name + '_' + 'OnEnter', UnAssigned);
end;
procedure TSMScriptExecutor.OnExitHandler(Sender: TObject);
begin
Run((Sender as TComponent).Name + '_' + 'OnExit', UnAssigned);
end;
procedure TSMScriptExecutor.OnTimerHandler(Sender: TObject);
begin
Run((Sender as TComponent).Name + '_' + 'OnTimer', UnAssigned);
end;
end.
|
////////////////////////////////////////////////////////////////////////////////
//
//
// FileName : SUIPageControl.pas
// Creator : Shen Min
// Date : 2002-11-20 V1-V3
// 2003-07-11 V4
// Comment :
//
// Copyright (c) 2002-2003 Sunisoft
// http://www.sunisoft.com
// Email: support@sunisoft.com
//
////////////////////////////////////////////////////////////////////////////////
unit SUIPageControl;
interface
{$I SUIPack.inc}
uses Windows, Messages, SysUtils, Classes, Controls, Forms, CommCtrl, ExtCtrls,
Graphics, Dialogs,
SUITabControl, SUIThemes, SUIMgr;
type
// -------------- TsuiPageControlTopPanel ------------------
TsuiPageControlTopPanel = class(TsuiTabControlTopPanel)
private
procedure CMDesignHitTest(var Msg: TCMDesignHitTest); message CM_DESIGNHITTEST;
end;
TsuiPageControl = class;
// -------------- TsuiTabSheet -----------------------------
TsuiTabSheet = class(TCustomPanel)
private
m_PageControl : TsuiPageControl;
m_PageIndex : Integer;
m_Caption : TCaption;
m_BorderColor : TColor;
m_TabVisible : Boolean;
m_OnShow: TNotifyEvent;
m_OnHide : TNotifyEvent;
procedure SetPageControl(const Value: TsuiPageControl);
procedure SetPageIndex(const Value: Integer);
procedure ReadPageControl(Reader: TReader);
procedure WritePageControl(Writer: TWriter);
procedure SetCaption(const Value: TCaption);
function GetTabVisible: Boolean;
procedure SetTabVisible(const Value: Boolean);
procedure DoShow();
procedure DoHide();
protected
procedure DefineProperties(Filer: TFiler); override;
procedure Notification(AComponent: TComponent; Operation: TOperation); override;
public
constructor Create(AOwner : TComponent); override;
procedure UpdateUIStyle(UIStyle: TsuiUIStyle; FileTheme : TsuiFileTheme);
property PageControl : TsuiPageControl read m_PageControl write SetPageControl;
published
property PageIndex : Integer read m_PageIndex write SetPageIndex;
property Caption : TCaption read m_Caption write SetCaption;
property TabVisible : Boolean read GetTabVisible write SetTabVisible;
property BiDiMode;
property Color;
property Constraints;
property UseDockManager default True;
property DockSite;
property DragCursor;
property DragKind;
property DragMode;
property Enabled;
property FullRepaint;
property Font;
property Locked;
property ParentBiDiMode;
property ParentColor;
property ParentCtl3D;
property ParentFont;
property ParentShowHint;
property PopupMenu;
property ShowHint;
property TabOrder;
property TabStop;
property Visible;
property OnCanResize;
property OnClick;
property OnShow: TNotifyEvent read m_OnShow write m_OnShow;
property OnHide : TNotifyEvent read m_OnHide write m_OnHide;
property OnConstrainedResize;
property OnContextPopup;
property OnDockDrop;
property OnDockOver;
property OnDblClick;
property OnDragDrop;
property OnDragOver;
property OnEndDock;
property OnEndDrag;
property OnEnter;
property OnExit;
property OnGetSiteInfo;
property OnMouseDown;
property OnMouseMove;
property OnMouseUp;
property OnResize;
property OnStartDock;
property OnStartDrag;
property OnUnDock;
end;
// -------------- TsuiPageControl --------------------------
TsuiPageControl = class(TsuiTab)
private
m_PageList : TList;
m_ActivePage : TsuiTabSheet;
m_TempList : TStrings;
function NewPage() : TsuiTabSheet;
procedure ActivatePage(Page : TsuiTabSheet); overload;
procedure ActivatePage(nPageIndex : Integer); overload;
procedure RemovePage(Page: TsuiTabSheet);
procedure InsertPage(Page: TsuiTabSheet);
function GetCurPage() : TsuiTabSheet;
procedure MovePage(Page : TsuiTabSheet; var NewIndex : Integer);
procedure ActivateNextVisiblePage(CurPageIndex : Integer);
procedure UpdateTabVisible();
function FindNextVisiblePage(CurPageIndex : Integer) : Integer;
function FindPrevVisiblePage(CurPageIndex : Integer) : Integer;
procedure UpdateCaptions();
procedure UpdatePageIndex();
procedure CMCONTROLLISTCHANGE(var Msg : TMessage); message CM_CONTROLLISTCHANGE;
procedure CMCOLORCHANGED(var Msg : TMessage); message CM_COLORCHANGED;
procedure SetActivePage(const Value: TsuiTabSheet);
procedure ReadPages(Reader: TReader);
procedure WritePages(Writer: TWriter);
procedure ReSortPages();
function GetPageCount: Integer;
function GetPage(Index: Integer): TsuiTabSheet;
function GetActivePageIndex: Integer;
procedure SetActivePageIndex(const Value: Integer);
protected
function CreateTopPanel() : TsuiTabControlTopPanel; override;
procedure TabActive(TabIndex : Integer); override;
procedure DefineProperties(Filer: TFiler); override;
procedure BorderColorChanged(); override;
procedure ShowControl(AControl: TControl); override;
public
constructor Create(AOwner : TComponent); override;
destructor Destroy(); override;
procedure UpdateUIStyle(UIStyle : TsuiUIStyle; FileTheme : TsuiFileTheme); override;
procedure SelectNextPage(GoForward: Boolean);
function FindNextPage(CurPage: TsuiTabSheet; GoForward : Boolean): TsuiTabSheet;
property Pages[Index: Integer]: TsuiTabSheet read GetPage;
property ActivePageIndex: Integer read GetActivePageIndex write SetActivePageIndex;
published
property ActivePage : TsuiTabSheet read m_ActivePage write SetActivePage;
property PageCount : Integer read GetPageCount;
end;
procedure PageControl_InsertPage(AComponent : TComponent);
procedure PageControl_RemovePage(AComponent : TComponent);
function PageControl_CanRemove(AComponent : TComponent) : Boolean;
procedure TabSheet_InsertPage(AComponent : TComponent);
procedure TabSheet_RemovePage(AComponent : TComponent);
function TabSheet_CanRemove(AComponent : TComponent) : Boolean;
implementation
uses SUIPublic;
var
l_EditorRemove : Boolean = false;
procedure PageControl_InsertPage(AComponent : TComponent);
begin
(AComponent as TsuiPageControl).NewPage();
end;
procedure PageControl_RemovePage(AComponent : TComponent);
var
TabSheet : TsuiTabSheet;
begin
with (AComponent as TsuiPageControl) do
begin
l_EditorRemove := true;
TabSheet := GetCurPage();
TabSheet.PageControl := nil;
TabSheet.Parent := nil;
TabSheet.Free();
l_EditorRemove := false;
end;
end;
function PageControl_CanRemove(AComponent : TComponent) : Boolean;
begin
if ((AComponent as TsuiPageControl).m_TopPanel.Tabs.Count = 0) then
Result := false
else
Result := true;
end;
procedure TabSheet_InsertPage(AComponent : TComponent);
begin
if (AComponent as TsuiTabSheet).PageControl <> nil then
(AComponent as TsuiTabSheet).PageControl.NewPage();
end;
procedure TabSheet_RemovePage(AComponent : TComponent);
begin
l_EditorRemove := true;
with (AComponent as TsuiTabSheet) do
begin
PageControl := nil;
Parent := nil;
Free();
end;
l_EditorRemove := false;
end;
function TabSheet_CanRemove(AComponent : TComponent) : Boolean;
begin
Result := false;
if (AComponent as TsuiTabSheet).PageControl = nil then
Exit;
if ((AComponent as TsuiTabSheet).PageControl.m_TopPanel.Tabs.Count = 0) then
Result := false
else
Result := true;
end;
{ TsuiPageControl }
procedure TsuiPageControl.ActivatePage(Page: TsuiTabSheet);
begin
if (m_ActivePage <> nil) and (m_ActivePage <> Page) then
begin
m_ActivePage.Enabled := false;
m_ActivePage.DoHide();
end;
m_ActivePage := Page;
if Page = nil then
Exit;
TabIndex := Page.PageIndex;
m_TopPanel.TabIndex := Page.PageIndex;
m_ActivePage.Visible := true;
m_ActivePage.Enabled := true;
m_ActivePage.BringToFront();
m_ActivePage.Repaint();
m_ActivePage.DoShow();
end;
procedure TsuiPageControl.ActivateNextVisiblePage(CurPageIndex: Integer);
var
i : Integer;
Found : Boolean;
begin
Found := false;
for i := CurPageIndex - 1 downto 0 do
begin
if TsuiTabSheet(m_PageList[i]).TabVisible then
begin
ActivatePage(i);
Found := true;
break;
end;
end;
if Found then
Exit;
for i := CurPageIndex + 1 to m_PageList.Count - 1 do
begin
if TsuiTabSheet(m_PageList[i]).TabVisible then
begin
ActivatePage(i);
break;
end;
end;
end;
procedure TsuiPageControl.ActivatePage(nPageIndex: Integer);
begin
if (m_ActivePage <> nil) and (m_ActivePage.PageIndex <> nPageIndex) then
begin
m_ActivePage.Enabled := false;
m_ActivePage.DoHide();
end;
if (
(nPageIndex > m_TopPanel.Tabs.Count - 1) or
(nPageIndex < 0)
) then
begin
ActivePage := nil;
Exit;
end;
TabIndex := nPageIndex;
m_TopPanel.TabIndex := nPageIndex;
m_ActivePage := TsuiTabSheet(m_PageList[nPageIndex]);
m_ActivePage.Visible := true;
m_ActivePage.Enabled := true;
m_ActivePage.BringToFront();
m_ActivePage.Repaint();
m_ActivePage.DoShow();
end;
procedure TsuiPageControl.BorderColorChanged;
var
i : Integer;
begin
if m_PageList = nil then
Exit;
for i := 0 to m_PageList.Count - 1 do
TsuiTabSheet(m_PageList[i]).m_BorderColor := BorderColor;
if m_ActivePage <> nil then
m_ActivePage.Repaint();
end;
procedure TsuiPageControl.CMCOLORCHANGED(var Msg: TMessage);
var
i : Integer;
begin
if m_PageList = nil then
Exit;
for i := 0 to m_PageList.Count - 1 do
TsuiTabSheet(m_PageList[i]).Color := Color;
end;
procedure TsuiPageControl.CMCONTROLLISTCHANGE(var Msg: TMessage);
begin
if not Boolean(Msg.LParam) then
begin // remove
if TControl(Msg.WParam) is TsuiTabSheet then
RemovePage(TsuiTabSheet(Msg.WParam));
end
else
begin // add
if TControl(Msg.WParam) is TsuiTabSheet then
InsertPage(TsuiTabSheet(Msg.WParam));
end;
end;
constructor TsuiPageControl.Create(AOwner: TComponent);
begin
inherited;
m_PageList := TList.Create();
m_TempList := TStringList.Create();
m_TopPanel.Tabs.Clear();
end;
function TsuiPageControl.CreateTopPanel: TsuiTabControlTopPanel;
begin
Result := TsuiPageControlTopPanel.Create(self, self);
end;
procedure TsuiPageControl.DefineProperties(Filer: TFiler);
begin
inherited;
Filer.DefineProperty(
'Pages',
ReadPages,
WritePages,
true
);
end;
destructor TsuiPageControl.Destroy;
var
i : Integer;
begin
for i := 0 to m_PageList.Count - 1 do
TsuiTabSheet(m_PageList[i]).m_PageControl := nil;
m_TempList.Free();
m_TempList := nil;
m_PageList.Free();
m_PageList := nil;
inherited;
end;
function TsuiPageControl.GetCurPage: TsuiTabSheet;
begin
Result := m_PageList[m_TopPanel.TabIndex];
end;
procedure TsuiPageControl.InsertPage(Page: TsuiTabSheet);
begin
Page.m_PageControl := self;
Page.Color := Color;
Page.m_BorderColor := BorderColor;
m_TopPanel.Tabs.Add(Page.Caption);
m_PageList.Add(Page);
UpdatePageIndex();
UpdateCaptions();
ActivatePage(Page);
end;
procedure TsuiPageControl.MovePage(Page: TsuiTabSheet; var NewIndex: Integer);
begin
if (NewIndex < 0) or (NewIndex > m_PageList.Count - 1) then
begin
NewIndex := Page.PageIndex;
Exit;
end;
m_PageList.Move(Page.PageIndex, NewIndex);
UpdatePageIndex();
UpdateCaptions();
ActivatePage(Page);
end;
function TsuiPageControl.NewPage: TsuiTabSheet;
var
Form : TCustomForm;
begin
Result := TsuiTabSheet.Create(Owner);
Form := TCustomForm(Owner);
if Form <> nil then
Result.Name := Form.Designer.UniqueName('suiTabSheet')
else
Result.Name := 'suiTabSheet' + IntToStr(m_PageList.Count + 1);
Result.Caption := Result.Name;
Result.Parent := self;
Result.Align := alClient;
end;
procedure TsuiPageControl.ReadPages(Reader: TReader);
begin
Reader.ReadListBegin();
while not Reader.EndOfList() do
m_TempList.Add(Reader.ReadIdent());
Reader.ReadListEnd();
end;
procedure TsuiPageControl.RemovePage(Page: TsuiTabSheet);
begin
m_TopPanel.Tabs.Delete(Page.PageIndex);
m_PageList.Delete(Page.PageIndex);
UpdatePageIndex();
ActivatePage(Page.PageIndex - 1);
end;
procedure TsuiPageControl.ReSortPages;
function SortList(Item1, Item2: Pointer): Integer;
begin
if TsuiTabSheet(Item1).m_PageIndex < TsuiTabSheet(Item2).m_PageIndex then
Result := -1
else if TsuiTabSheet(Item1).m_PageIndex = TsuiTabSheet(Item2).m_PageIndex then
Result := 0
else
Result := 1;
end;
var
i : Integer;
begin
for i := 0 to m_PageList.Count - 1 do
TsuiTabSheet(m_PageList[i]).m_PageIndex := m_TempList.IndexOf(TsuiTabSheet(m_PageList[i]).Name);
m_PageList.Sort(@SortList);
UpdatePageIndex();
UpdateCaptions();
end;
procedure TsuiPageControl.SetActivePage(const Value: TsuiTabSheet);
begin
ActivatePage(Value);
end;
procedure TsuiPageControl.TabActive(TabIndex: Integer);
begin
if (m_ActivePage <> nil) and (m_ActivePage.PageIndex <> TabIndex) then
begin
m_ActivePage.Enabled := false;
m_ActivePage.DoHide();
end;
m_ActivePage := TsuiTabSheet(m_PageList[TabIndex]);
m_ActivePage.Visible := true;
m_ActivePage.Enabled := true;
m_ActivePage.BringToFront();
m_ActivePage.Repaint();
if (not (csLoading in ComponentState)) and (not (csDesigning in ComponentState)) then
begin
if (
(m_ActivePage.ControlCount > 0) and
(m_ActivePage.Controls[0] is TWinControl) and
(m_ActivePage.Controls[0].Visible) //"Fastream Technologies (http://www.fastream.com) fixed a bug here. Happy Coding!"
) then
try
if (m_ActivePage.Controls[0] as TWinControl).CanFocus() then
GetParentForm(self).ActiveControl := m_ActivePage.Controls[0] as TWinControl;
except
end;
end;
m_ActivePage.DoShow();
inherited;
end;
procedure TsuiPageControl.UpdateCaptions;
var
i : Integer;
begin
m_TopPanel.Tabs.Clear();
for i := 0 to m_PageList.Count - 1 do
m_TopPanel.Tabs.Add(TsuiTabSheet(m_PageList[i]).Caption)
end;
procedure TsuiPageControl.UpdatePageIndex;
var
i : Integer;
begin
for i := 0 to m_PageList.Count - 1 do
TsuiTabSheet(m_PageList[i]).m_PageIndex := i;
end;
procedure TsuiPageControl.UpdateUIStyle(UIStyle: TsuiUIStyle; FileTheme : TsuiFileTheme);
var
i : Integer;
begin
if m_PageList = nil then
Exit;
for i := 0 to m_PageList.Count - 1 do
begin
TsuiTabSheet(m_PageList[i]).UpdateUIStyle(UIStyle, FileTheme);
TsuiTabSheet(m_PageList[i]).Color := Color;
TsuiTabSheet(m_PageList[i]).m_BorderColor := BorderColor;
TsuiTabSheet(m_PageList[i]).Align := alClient;
end;
end;
procedure TsuiPageControl.WritePages(Writer: TWriter);
var
i : Integer;
begin
Writer.WriteListBegin();
for i := 0 to m_PageList.Count - 1 do
Writer.WriteIdent(TsuiTabSheet(m_PageList[i]).Name);
Writer.WriteListEnd();
end;
procedure TsuiPageControl.UpdateTabVisible;
var
i : Integer;
begin
for i := 0 to m_PageList.Count - 1 do
m_TopPanel.m_TabVisible[i] := TsuiTabSheet(m_PageList[i]).m_TabVisible;
end;
function TsuiPageControl.GetPageCount: Integer;
begin
Result := m_PageList.Count;
end;
function TsuiPageControl.GetPage(Index: Integer): TsuiTabSheet;
begin
if (Index > m_PageList.Count - 1) or (Index < 0) then
Result := nil
else
Result := TsuiTabSheet(m_PageList[Index]);
end;
function TsuiPageControl.GetActivePageIndex: Integer;
begin
if m_ActivePage <> nil then
Result := m_ActivePage.PageIndex
else
Result := 0;
end;
procedure TsuiPageControl.SetActivePageIndex(const Value: Integer);
begin
if (Value > m_PageList.Count - 1) or (Value < 0) then
Exit;
ActivatePage(Value);
end;
procedure TsuiPageControl.SelectNextPage(GoForward: Boolean);
begin
if m_ActivePage = nil then
Exit;
ActivatePage(FindNextPage(m_ActivePage, GoForward));
end;
function TsuiPageControl.FindNextVisiblePage(CurPageIndex: Integer) : Integer;
var
i : Integer;
Found : Boolean;
begin
Result := -1;
Found := false;
for i := CurPageIndex + 1 to m_PageList.Count - 1 do
begin
if TsuiTabSheet(m_PageList[i]).TabVisible then
begin
Result := i;
Found := true;
break;
end;
end;
if Found then
Exit;
for i := 0 to CurPageIndex - 1 do
begin
if TsuiTabSheet(m_PageList[i]).TabVisible then
begin
Result := i;
break;
end;
end;
end;
function TsuiPageControl.FindPrevVisiblePage(CurPageIndex: Integer) : Integer;
var
i : Integer;
Found : Boolean;
begin
Result := -1;
Found := false;
for i := CurPageIndex - 1 downto 0 do
begin
if TsuiTabSheet(m_PageList[i]).TabVisible then
begin
Result := i;
Found := true;
break;
end;
end;
if Found then
Exit;
for i := m_PageList.Count - 1 downto CurPageIndex + 1 do
begin
if TsuiTabSheet(m_PageList[i]).TabVisible then
begin
Result := i;
break;
end;
end;
end;
function TsuiPageControl.FindNextPage(CurPage: TsuiTabSheet; GoForward: Boolean): TsuiTabSheet;
var
NextPage : Integer;
begin
Result := nil;
if GoForward then
NextPage := FindNextVisiblePage(CurPage.PageIndex)
else
NextPage := FindPrevVisiblePage(CurPage.PageIndex);
if NextPage <> -1 then
Result := m_PageList[NextPage];
end;
procedure TsuiPageControl.ShowControl(AControl: TControl);
begin
inherited;
if not (AControl is TsuiTabSheet) then
Exit;
ActivatePage(AControl as TsuiTabSheet);
end;
{ TsuiPageControlTopPanel }
procedure TsuiPageControlTopPanel.CMDesignHitTest(var Msg: TCMDesignHitTest);
var
HitPos : TPoint;
Form : TCustomForm;
begin
if Msg.Keys = MK_LBUTTON then
begin
HitPos := SmallPointToPoint(Msg.Pos);
MouseDown(mbLeft, [], HitPos.X, HitPos.Y);
if Owner.Owner is TCustomForm then
begin
Form := TCustomForm(Owner.Owner);
if Form <> nil then
Form.Designer.Modified();
end;
Msg.Result := 0;
end;
end;
{ TsuiTabSheet }
constructor TsuiTabSheet.Create(AOwner: TComponent);
begin
inherited;
inherited Caption := ' ';
m_PageIndex := -1;
m_TabVisible := true;
BevelInner := bvNone;
BevelOuter := bvNone;
BorderWidth := 0;
Align := alClient;
end;
procedure TsuiTabSheet.DefineProperties(Filer: TFiler);
begin
inherited;
Filer.DefineProperty(
'PageControl',
ReadPageControl,
WritePageControl,
true
);
end;
procedure TsuiTabSheet.DoHide;
begin
if Assigned(m_OnHide) then
m_OnHide(self);
end;
procedure TsuiTabSheet.DoShow;
begin
if Assigned(m_OnShow) then
m_OnShow(Self);
end;
function TsuiTabSheet.GetTabVisible: Boolean;
begin
Result := m_PageControl.m_TopPanel.m_TabVisible[PageIndex];
end;
procedure TsuiTabSheet.Notification(AComponent: TComponent;
Operation: TOperation);
begin
inherited;
if l_EditorRemove then
Exit;
if m_PageControl = nil then
Exit;
if (Operation = opRemove) and (AComponent = self) then
Parent := nil;
end;
procedure TsuiTabSheet.ReadPageControl(Reader: TReader);
begin
m_PageControl := TsuiPageControl(Owner.FindComponent(Reader.ReadIdent()));
if m_PageControl = nil then
Exit;
if m_PageControl.m_PageList.Count = m_PageControl.m_TempList.Count then
begin
m_PageControl.ReSortPages();
m_PageControl.UpdateTabVisible();
end;
end;
procedure TsuiTabSheet.SetCaption(const Value: TCaption);
begin
m_Caption := Value;
if m_PageControl = nil then
Exit;
m_PageControl.UpdateCaptions();
end;
procedure TsuiTabSheet.SetPageControl(const Value: TsuiPageControl);
begin
m_PageControl := Value;
if m_PageControl = nil then
Exit;
Parent := m_PageControl;
end;
procedure TsuiTabSheet.SetPageIndex(const Value: Integer);
var
NewIndex : Integer;
begin
if m_PageControl = nil then
Exit;
NewIndex := Value;
m_PageControl.MovePage(self, NewIndex);
m_PageIndex := NewIndex;
end;
procedure TsuiTabSheet.SetTabVisible(const Value: Boolean);
begin
m_TabVisible := Value;
if m_PageControl = nil then
Exit;
m_PageControl.m_TopPanel.m_TabVisible[PageIndex] := Value;
m_PageControl.m_TopPanel.Repaint();
if (not Value) and (m_PageControl.ActivePage = self) then
m_PageControl.ActivateNextVisiblePage(PageIndex)
// else
// m_PageControl.ActivatePage(PageIndex);
end;
procedure TsuiTabSheet.UpdateUIStyle(UIStyle: TsuiUIStyle; FileTheme : TsuiFileTheme);
begin
ContainerApplyUIStyle(self, UIStyle, FileTheme);
end;
procedure TsuiTabSheet.WritePageControl(Writer: TWriter);
begin
if m_PageControl <> nil then
Writer.WriteIdent(m_PageControl.Name);
end;
end.
|
unit Login;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, Buttons, BasePopup, BaseForm, Vcl.StdCtrls, RzLabel, System.UITypes,
Vcl.Imaging.pngimage, Vcl.ExtCtrls, RzPanel, Vcl.Mask, RzEdit, RzPrgres,
RzButton;
type
TfrmLogin = class(TfrmBasePopup)
Label4: TLabel;
Label5: TLabel;
Label1: TLabel;
Label2: TLabel;
edUsername: TRzEdit;
edPassword: TRzEdit;
lbErrorMessage: TLabel;
imgLogo: TImage;
prbStatus: TRzProgressBar;
lblStatus: TLabel;
pnlClose: TRzPanel;
btnClose: TRzShapeButton;
pnlLogin: TRzPanel;
btnLogin: TRzShapeButton;
lblVersion: TLabel;
procedure FormShow(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure edUsernameChange(Sender: TObject);
procedure edPasswordKeyPress(Sender: TObject; var Key: Char);
procedure btnCloseClick(Sender: TObject);
procedure btnLoginClick(Sender: TObject);
procedure pnlTitleMouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
private
{ Private declarations }
procedure LoadModules;
procedure LoadSettings;
procedure SettingAccessRights;
procedure PauseWindow(timer: integer);
procedure GetLocations;
function UserExists: boolean;
function PasswordIsValid: boolean;
public
{ Public declarations }
class function LoggedIn: boolean;
end;
const
LIMITGLOBAL = 6;
TICK = 80;
INCREMENT = 16;
implementation
{$R *.dfm}
uses
AppData, AppUtil, IFinanceGlobal, IFinanceDialogs, Location;
class function TfrmLogin.LoggedIn: boolean;
begin
with TfrmLogin.Create(nil) do
try
Result := ShowModal = mrOk;
finally
Free;
end;
end;
function TfrmLogin.UserExists: boolean;
var
username: string;
begin
with dmApplication.dstUser do
begin
username := Trim(edUsername.Text);
Close;
Parameters.ParamByName('@username').Value := username;
Open;
Result := RecordCount > 0;
if not Result then lbErrorMessage.Caption := 'Invalid username or password.';
end;
end;
procedure TfrmLogin.edPasswordKeyPress(Sender: TObject; var Key: Char);
begin
inherited;
if Key = #13 then btnLogin.Click;
end;
procedure TfrmLogin.edUsernameChange(Sender: TObject);
begin
inherited;
lbErrorMessage.Visible := false;
end;
procedure TfrmLogin.FormCreate(Sender: TObject);
begin
inherited;
dmApplication := TdmApplication.Create(Application);
lblVersion.Caption := 'Version ' + GetAppVersionStr(ParamStr(0));;
end;
procedure TfrmLogin.FormShow(Sender: TObject);
begin
prbStatus.Visible := false;
end;
procedure TfrmLogin.PauseWindow(timer: integer);
var
StartTimer: integer;
EndTimer: Integer;
begin
// wait a few miliseconds
StartTimer := GetTickCount;
EndTimer := StartTimer + timer;
while StartTimer < EndTimer do
StartTimer := GetTickCount;
end;
procedure TfrmLogin.pnlTitleMouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
const
SC_DRAGMOVE = $F012;
begin
if Button = mbLeft then
begin
ReleaseCapture;
Perform(WM_SYSCOMMAND, SC_DRAGMOVE, 0);
end;
end;
procedure TfrmLogin.btnLoginClick(Sender: TObject);
begin
if (UserExists) and (PasswordIsValid) then
begin
try
try
edUsername.Enabled := false;
edPassword.Enabled := false;
btnLogin.Enabled := false;
btnClose.Enabled := false;
lblVersion.Visible := false;
lblStatus.Visible := true;
prbStatus.Visible := true;
lbErrorMessage.Visible := false;
self.Update;
ifn := TIFinance.Create;
LoadModules;
SettingAccessRights;
LoadSettings;
{$ifdef TESTMODE}
LoadTestInfo;
{$endif}
ModalResult := 1;
except
on e: Exception do
begin
ShowErrorBox('An exception has been detected and the application needs to close. ' +
'Please contact the administrator with the message below.' + #13#10 + #13#10 +
e.Message);
Application.Terminate;
end;
end;
finally
end;
end
else
begin
lbErrorMessage.Visible := true;
edUsername.SetFocus;
end;
end;
procedure TfrmLogin.btnCloseClick(Sender: TObject);
begin
inherited;
ModalResult := mrAbort;
end;
procedure TfrmLogin.LoadSettings;
var
limit: integer;
i: integer;
timer: integer;
begin
limit := LIMITGLOBAL;
i := 1;
timer := TICK;
prbStatus.Percent := 0;
lblStatus.Caption := 'Loading settings.';
self.Update;
with dmApplication.dstConfig do
begin
Open;
ifn.AppDate := Date;
// location code
if Locate('sysconfig_code','LOCATION_CODE',[]) then
ifn.LocationCode := FieldbyName('sysconfig_value').AsString;
// location prefix
if Locate('sysconfig_code','LOCATION_PREFIX',[]) then
ifn.LocationPrefix := FieldbyName('sysconfig_value').AsString;
// backlog entry
if Locate('sysconfig_code','BACKLOG_ENTRY_ENABLED',[]) then
ifn.BacklogEntryEnabled := FieldByName('sysconfig_value').AsInteger = 1;
if Locate('sysconfig_code','CUT_OFF_DATE',[]) then
ifn.CutoffDate := FieldByName('sysconfig_value').AsDateTime;
Close;
// photo path
ifn.PhotoPath := ExtractFilePath(Application.ExeName) + 'photos\';
if not DirectoryExists(ifn.PhotoPath) then
CreateDir(ifn.PhotoPath);
// application images path
ifn.AppImagesPath := ExtractFilePath(Application.ExeName) + '_images\';
// version
ifn.Version := GetAppVersionStr(ParamStr(0));
// get all locations
GetLocations;
end;
while i <= limit do
begin
PauseWindow(timer);
prbStatus.Percent := prbStatus.Percent + INCREMENT;
Application.ProcessMessages;
self.Update;
Inc(i);
end;
end;
procedure TfrmLogin.LoadModules;
var
limit: integer;
i: integer;
timer: integer;
begin
limit := LIMITGLOBAL;
i := 1;
timer := TICK;
lblStatus.Caption := 'Loading modules.';
while i <= limit do
begin
PauseWindow(timer);
prbStatus.Percent := prbStatus.Percent + INCREMENT;
Application.ProcessMessages;
self.Update;
Inc(i);
end;
end;
procedure TfrmLogin.SettingAccessRights;
var
limit, i, timer: integer;
right: string;
begin
limit := LIMITGLOBAL;
i := 1;
timer := TICK;
prbStatus.Percent := 0;
lblStatus.Caption := 'Setting user rights.';
while i <= limit do
begin
PauseWindow(timer);
prbStatus.Percent := prbStatus.Percent + INCREMENT;
Application.ProcessMessages;
self.Update;
Inc(i);
end;
with dmApplication.dstUser, ifn.User do
begin
Passkey := edPassword.Text;
UserId := FieldByName('id_num').AsString;
FirstName := FieldByName('employee_firstname').AsString;
LastName := FieldByName('employee_lastname').AsString;
CreditLimit := FieldByName('credit_limit').AsCurrency;
while not Eof do
begin
right := FieldbyName('privilege_code').AsString;
SetRight(right);
Next;
end;
end;
end;
function TfrmLogin.PasswordIsValid: boolean;
var
password: string;
begin
with dmApplication.dstUser do
begin
password := FieldByName('password').AsString;
Result := SameText(password, Trim(edPassword.Text));
if not Result then
lbErrorMessage.Caption := 'Invalid username or password.';
end;
end;
procedure TfrmLogin.GetLocations;
var
loc: TLocation;
begin
with dmApplication.dstLocation do
begin
DisableControls;
Open;
while not Eof do
begin
loc := TLocation.Create;
loc.LocationCode := FieldByName('location_code').AsString;
loc.LocationName := FieldByName('location_name').AsString;
loc.LocationType := FieldByName('locationtype_code').AsString;
ifn.AddLocation(loc);
Next;
end;
Close;
end;
end;
end.
|
{*******************************************************}
{ }
{ Delphi Runtime Library }
{ SOAP Support }
{ }
{ Copyright(c) 1995-2011 Embarcadero Technologies, Inc. }
{ }
{*******************************************************}
unit Soap.SOAPDomConv;
interface
uses
System.Classes, Xml.xmldom, Xml.XMLIntf, Xml.XMLDoc, Soap.OPConvert;
type
IDOMHeaderProcessor = interface
['{27F23F8F-23A2-4257-95A8-0204EEFF937B}']
procedure ProcessHeader(HeaderNode: IXMLNode; var Handled, AbortRequest: Boolean);
function CreateHeader(HeaderNode: IXMLNode): IXMLNode;
end;
TDOMHeaderProcessorEntry = record
Processor: IDOMHeaderProcessor;
NameSpace: WideString;
HeaderName: WideString;
TypeName: WideString;
end;
TDOMHeaderProcessorArray = array of TDOMHeaderProcessorEntry;
TSOAPDOMProcessor = class(TComponent, IInterface)
private
FRefCount: Integer;
FOwnerIsComponent: Boolean;
protected
FHeaderProcessors: TDOMHeaderProcessorArray;
function FindHeaderProcessor(Namespace, HeaderName, TypeName: WideString): IDOMHeaderProcessor; virtual;
function MakeHeaderNodes(HeaderNode: IXMLNode): IXMLNode;
function _AddRef: Integer; stdcall;
function _Release: Integer; stdcall;
public
procedure AddHeaderProcessor(Namespace, HeaderName, TypeName: WideString; Processor: IDOMHeaderProcessor); virtual;
procedure DefaultProcessHeader(HeaderNode: IXMLNode; var Handled, AbortRequest: Boolean); virtual;
class function NewInstance: TObject; override;
procedure AfterConstruction; override;
destructor Destroy; override;
end;
implementation
uses
System.Variants, System.SyncObjs, System.SysUtils, Soap.SOAPConst, Soap.InvokeRegistry;
{ TSOAPDOMProcessor }
destructor TSOAPDOMProcessor.Destroy;
begin
inherited;
end;
class function TSOAPDOMProcessor.NewInstance: TObject;
begin
Result := inherited NewInstance;
TSOAPDOMProcessor(Result).FRefCount := 1;
end;
procedure TSOAPDOMProcessor.AfterConstruction;
begin
inherited;
FOwnerIsComponent := Assigned(Owner) and (Owner is TComponent);
TInterlocked.Decrement(FRefCount);
end;
{ IInterface }
function TSOAPDOMProcessor._AddRef: Integer;
begin
Result := TInterlocked.Increment(FRefCount)
end;
function TSOAPDOMProcessor._Release: Integer;
begin
Result := TInterlocked.Decrement(FRefCount);
{ If we are not being used as a TComponent, then use refcount to manage our
lifetime as with TInterfacedObject. }
if (Result = 0) and not FOwnerIsComponent then
Destroy;
end;
procedure TSOAPDOMProcessor.AddHeaderProcessor(Namespace, HeaderName, TypeName: WideString;
Processor: IDOMHeaderProcessor);
var
I: Integer;
begin
I := Length(FHeaderProcessors);
SetLength(FHeaderProcessors, I + 1);
FHeaderProcessors[I].NameSpace := NameSpace;
FHeaderProcessors[I].HeaderName := HeaderName;
FHeaderProcessors[I].TypeName := TypeName;
FHeaderProcessors[I].Processor := Processor;
end;
procedure TSOAPDOMProcessor.DefaultProcessHeader(HeaderNode: IXMLNode;
var Handled, AbortRequest: Boolean);
var
V: Variant;
begin
V := HeaderNode.Attributes[SHeaderMustUnderstand];
if not VarIsNull(V) then
begin
if (V = '1') or SameText(V, 'true') then
raise ERemotableException.Create(Format(SHeaderAttributeError, [ExtractLocalName(HeaderNode.NodeName)]),
SFaultCodeMustUnderstand);
end;
end;
function TSOAPDOMProcessor.FindHeaderProcessor(Namespace, HeaderName,
TypeName: WideString): IDOMHeaderProcessor;
var
I: Integer;
begin
Result := nil;
for I := 0 to Length(FHeaderProcessors) - 1 do
begin
if (FHeaderProcessors[I].NameSpace = NameSpace) and
(FHeaderProcessors[I].HeaderName = HeaderName) and
(FHeaderProcessors[I].TypeName = TypeName) then
begin
Result := FHeaderProcessors[I].Processor;
Exit;
end;
end;
end;
function TSOAPDOMProcessor.MakeHeaderNodes(HeaderNode: IXMLNode): IXMLNode;
var
I: Integer;
Node: IXMLNode;
begin
for I := 0 to Length(FHeaderProcessors) - 1 do
if Assigned(FHeaderProcessors[I].Processor) then
begin
Node := FHeaderProcessors[I].Processor.CreateHeader(HeaderNode);
if Node <> nil then
HeaderNode.ChildNodes.Add(Node);
end;
end;
end.
|
unit USelectSortInPlant;
interface
uses
Winapi.Windows,
Winapi.Messages,
System.SysUtils,
System.Variants,
System.Classes,
Vcl.Graphics,
Vcl.Controls,
Vcl.Forms,
Vcl.Dialogs,
cxGraphics,
cxControls,
cxLookAndFeels,
cxLookAndFeelPainters,
cxContainer,
cxEdit,
dxSkinsCore,
Vcl.Menus,
cxStyles,
dxSkinscxPCPainter,
cxCustomData,
cxFilter,
cxData,
cxDataStorage,
cxNavigator,
Data.DB,
cxDBData,
MemDS,
DBAccess,
Uni,
cxGridLevel,
cxGridCustomTableView,
cxGridTableView,
cxGridDBTableView,
cxClasses,
cxGridCustomView,
cxGrid,
Vcl.DBCtrls,
sDBLookupListBox,
Vcl.StdCtrls,
cxButtons,
cxGroupBox,
UFrameSave,
dxSkinDevExpressStyle,
dxSkinXmas2008Blue;
type
TFSelectSortInPlant = class(TForm)
FrameSave1: TFrameSave;
Group3: TcxGroupBox;
btnAddAll: TcxButton;
btnAdd: TcxButton;
btnDelAll: TcxButton;
btnDel: TcxButton;
GroupDest: TcxGroupBox;
GroupSource: TcxGroupBox;
GridDest: TcxGrid;
ViewDest: TcxGridDBTableView;
ColumnName: TcxGridDBColumn;
LevelStatWork: TcxGridLevel;
QuerySource: TUniQuery;
dsSource: TDataSource;
Query1: TUniQuery;
QueryDist: TUniQuery;
dsDist: TDataSource;
QuerySelDetail: TUniQuery;
dsSelDetail: TDataSource;
QuerySelOsnDb: TUniQuery;
procedure btnAddClick(Sender: TObject);
procedure btnDelClick(Sender: TObject);
procedure FrameSave1btnSaveClick(Sender: TObject);
procedure lstSourceDblClick(Sender: TObject);
procedure ViewDestDblClick(Sender: TObject);
procedure btnAddAllClick(Sender: TObject);
private
{ Private declarations }
public
id_dist, id_source: array of Integer;
procedure ShowDist(id_locate: Integer = 0);
procedure ShowSource(id_locate: Integer = 0);
{ Public declarations }
end;
var
FSelectSortInPlant: TFSelectSortInPlant;
implementation
{$R *.dfm}
uses
UDataModule1,
UPasswd;
procedure TFSelectSortInPlant.btnAddAllClick(Sender: TObject);
begin
with QuerySource do
begin
First;
Query1.Close;
Query1.SQL.Text := 'insert into Назначение (id, name, uni_name, reg_name) '
+ ' values (:id, :name, :uni_name, :reg_name)';
while not eof do
begin
Query1.ParamByName('id').Value := Fields[0].AsInteger;
Query1.ParamByName('name').Value := FieldByName('name').AsString;
Query1.ParamByName('uni_name').Value := FieldByName('uni_name').AsString;
Query1.ParamByName('reg_name').Value := FieldByName('reg_name').AsString;
Query1.ExecSQL;
Next;
end;
Query1.Close;
Query1.SQL.Text := 'delete from Источник';
Query1.ExecSQL;
ShowDist();
ShowSource();
end;
end;
procedure TFSelectSortInPlant.btnAddClick(Sender: TObject);
var
id: Integer;
begin
with Query1 do
begin
Close;
SQL.Text := 'select * from [Источник] ';
case FPasswd.Lang of
0:
begin
SQL.Add('where name>:n order by name limit 1');
ParamByName('n').AsString := QuerySource.FieldByName('name').AsString;
end;
1:
begin
SQL.Add('where uni_name>:n order by uni_name limit 1');
ParamByName('n').AsString := QuerySource.FieldByName
('uni_name').AsString;
end;
2:
begin
SQL.Add('where reg_name>:n order by uni_name limit 1');
ParamByName('n').AsString := QuerySource.FieldByName
('reg_name').AsString;
end;
end;
Open;
id := FieldByName('id').AsInteger;
Close;
SQL.Text := 'delete from Источник where id=' + QuerySource.FieldByName
('id').AsString;
ExecSQL;
Close;
SQL.Text := 'insert into Назначение (id, name, uni_name, reg_name) ' +
' values (:id, :name, :uni_name, :reg_name)';
ParamByName('id').Value := QuerySource.Fields[0].AsInteger;
ParamByName('name').Value := QuerySource.FieldByName('name').AsString;
ParamByName('uni_name').Value := QuerySource.FieldByName
('uni_name').AsString;
ParamByName('reg_name').Value := QuerySource.FieldByName
('reg_name').AsString;
ExecSQL;
ShowDist(QuerySource.Fields[0].AsInteger);
ShowSource(id);
end;
end;
procedure TFSelectSortInPlant.btnDelClick(Sender: TObject);
var
id: Integer;
begin
with Query1 do
begin
Close;
SQL.Text := 'select * from [Назначение] ';
case FPasswd.Lang of
0:
begin
SQL.Add('where name<:n order by name limit 1');
ParamByName('n').AsString := QuerySource.FieldByName('name').AsString;
end;
1:
begin
SQL.Add('where uni_name<:n order by uni_name limit 1');
ParamByName('n').AsString := QuerySource.FieldByName
('uni_name').AsString;
end;
2:
begin
SQL.Add('where reg_name<:n order by uni_name limit 1');
ParamByName('n').AsString := QuerySource.FieldByName
('reg_name').AsString;
end;
end;
Open;
id := FieldByName('id').AsInteger;
Close;
SQL.Text := 'delete from Назначение where id=' + QueryDist.FieldByName
('id').AsString;
ExecSQL;
Close;
SQL.Text := 'insert into Источник (id, name, uni_name, reg_name) ' +
' values (:id, :name, :uni_name, :reg_name)';
ParamByName('id').Value := QueryDist.Fields[0].AsInteger;
ParamByName('name').Value := QueryDist.FieldByName('name').AsString;
ParamByName('uni_name').Value := QueryDist.FieldByName('uni_name').AsString;
ParamByName('reg_name').Value := QueryDist.FieldByName('reg_name').AsString;
ExecSQL;
ShowSource(QueryDist.Fields[0].AsInteger);
ShowDist(id);
end;
end;
procedure TFSelectSortInPlant.FrameSave1btnSaveClick(Sender: TObject);
begin
FrameSave1.btnSaveClick(Sender);
Close;
end;
procedure TFSelectSortInPlant.lstSourceDblClick(Sender: TObject);
begin
btnDelClick(Sender);
end;
procedure TFSelectSortInPlant.ShowDist(id_locate: Integer = 0);
begin
with QueryDist do
begin
Close;
SQL.Text := 'select * from Назначение ';
case FPasswd.Lang of
0:
SQL.Add('order by name');
1:
SQL.Add('order by uni_name');
2:
SQL.Add('order by reg_name');
end;
Open;
Locate('id', id_locate, [])
end;
end;
procedure TFSelectSortInPlant.ShowSource(id_locate: Integer = 0);
begin
with QuerySource do
begin
Close;
SQL.Text := 'select * from Источник ';
case FPasswd.Lang of
0:
SQL.Add('order by name');
1:
SQL.Add('order by uni_name');
2:
SQL.Add('order by reg_name');
end;
Open;
Locate('id', id_locate, [])
end;
end;
procedure TFSelectSortInPlant.ViewDestDblClick(Sender: TObject);
begin
btnAddClick(Sender);
end;
end.
|
unit u_SolidWastte_Upload;
interface
uses
Classes, SysUtils, Math, SolidWasteService, Json, StrUtils, u_WeightComm;
function SolidWastte_Desc(RetCode: Byte): String;
Function SolidWaste_Auth(const AuthInfo: TWeightAuth): Integer;
Function SolidWaste_Commit(const CommitInfo: TWeightInfo): Integer;
implementation
uses
u_Log;
var
g_Intf: ISolidWasteService;
g_RetPaire: JSon.TJSONObject;
Function SolidWastte_Upload(const Info: String): Integer;
var
Log: IMultiLineLog;
RetStr: String;
begin
{$IFDEF EMU_NET}
Result:= 1;
{$ELSE}
try
With MultiLineLog do
begin
AddLine('------------------------------------');
AddLine('数据：'#$D#$A+ Info);
Result:= -1;
if g_Intf = Nil then
begin
g_Intf:= GetISolidWasteService;
end;
if g_RetPaire = Nil then
begin
g_RetPaire:= TJSONObject.Create;
end;
RetStr:= g_Intf.process(Info);
With TJSONObject.ParseJSONValue(Trim(RetStr )) as TJSONObject do
begin
AddLine('返回值：' + RetStr);
RetStr:= (GetValue('obj') as TJSONString).Value;
Result:= StrToIntDef(RetStr, -1);
AddLine('解析值：' + IntToStr(Result));
Free;
end;
AddLine('------------------------------------');
Flush();
end;
except
On E: Exception do
begin
u_Log.Log(Format('发生异常: %s : %s', [E.ClassName, e.Message]));
end;
end;
{$ENDIF}
end;
function SolidWastte_Desc(RetCode: Byte): String;
const
CONST_DESC_ARR: Array[0..7] of String = (
'001：执行成功验证通过',
'002：服务器接口发生异常',
'003：参数不正确',
'004：企业身份标识不合法（平台分配的唯一token）',
'005：电子联单编号不存在',
'006：车牌及驾驶员信息与转移联单信息不一致',
'007：车牌信息与转移联单信息不一致',
'008：驾驶员信息与转移联单信息不一致'
);
begin
if InRange(RetCode - 1, Low(CONST_DESC_ARR), High(CONST_DESC_ARR)) then
begin
Result:= CONST_DESC_ARR[RetCode - 1];
end
else
begin
Result:= Format('%-0.3d: 未定义的返回码', [RetCode]);
end;
end;
Function SolidWaste_Auth(const AuthInfo: TWeightAuth): Integer;
var
jso: TJSONObject;
jsoBody: TJSONObject;
EscapedBody: String;
begin
Result:= -1;
jso:= TJSONObject.Create;
try
jsoBody:= TJSONObject.Create;
with jsoBody do
begin
AddPair('mainifestNo', AuthInfo.MainfestNo);
AddPair('plateNumber', AuthInfo.PlateNum);
AddPair('driverIdentityCardNo', AuthInfo.DriverIDC);
AddPair('driverName', AuthInfo.DriverName);
end;
jso.AddPair('token','1a523260ca71c085f4e2655ec524ec54cd74a0deee91fcaa21181d'+
'7470e121af6e2cbd74418c0487e141f65879003a509db79fe196e5'+
'7e2b5d6486a10cecdc2bf9ec06ae4f90cf9903a3146dbfcbb758e3'+
'a1b35d18cc4954a22c7c62ba18357eca7c264387cf94cfc87203b9'+
'3f382b05e92fb75ce90833fd7f3d2938dbfd08fe');
// jso.AddPair('token','1a523260ca71c085f4e2655ec524ec54cd74a0deee91fcaa21181d'+
// '3f382b05e92fb75ce90833fd7f3d2938dbfd08fe');
jso.AddPair('msgType', '10001');
EscapedBody:= jsoBody.ToString;
EscapedBody:= ReplaceText(EscapedBody, '"', '''');
jso.AddPair('msgBody', EscapedBody);
Result:= SolidWastte_Upload(jso.ToString);
With MultiLineLog do
begin
AddLine('----------提交数据----------');
Log(jso.ToString);
AddLine('----------返回码: ' + SolidWastte_Desc(Result) + '----------');
Flush;
end;
finally
jso.Free;
end;
end;
Function SolidWaste_Commit(const CommitInfo: TWeightInfo): Integer;
var
jso: TJSONObject;
jsoBody: TJSONObject;
EscapedBody: String;
begin
Result:= -1;
jso:= TJSONObject.Create;
try
jsoBody:= TJSONObject.Create;
with jsoBody do
begin
AddPair('mainifestNo', CommitInfo.Auth.MainfestNo);
AddPair('plateNumber', CommitInfo.Auth.PlateNum);
AddPair('driverIdentityCardNo', CommitInfo.Auth.DriverIDC);
AddPair('driverName', CommitInfo.Auth.DriverName);
AddPair('grossWeight', Format('%.2f', [CommitInfo.Mesure.Gross.Wegiht]));
AddPair('grossWeightWeighingTime', FormatDateTime('YYYY-MM-DD HH:NN:SS', CommitInfo.Mesure.Gross.WegihtTime));
AddPair('tare', Format('%.2f', [CommitInfo.Mesure.Tare.Wegiht]));
AddPair('tareWeighingTime', FormatDateTime('YYYY-MM-DD HH:NN:SS', CommitInfo.Mesure.Tare.WegihtTime));
AddPair('rem', CommitInfo.Mesure.Note);
end;
jso.AddPair('token','1a523260ca71c085f4e2655ec524ec54cd74a0deee91fcaa21181d'+
'7470e121af6e2cbd74418c0487e141f65879003a509db79fe196e5'+
'7e2b5d6486a10cecdc2bf9ec06ae4f90cf9903a3146dbfcbb758e3'+
'a1b35d18cc4954a22c7c62ba18357eca7c264387cf94cfc87203b9'+
'3f382b05e92fb75ce90833fd7f3d2938dbfd08fe');
jso.AddPair('msgType', '10002');
EscapedBody:= jsoBody.ToString;
EscapedBody:= ReplaceText(EscapedBody, '"', '''');
jso.AddPair('msgBody', EscapedBody);
Result:= SolidWastte_Upload(jso.ToString);
With MultiLineLog do
begin
AddLine('----------提交数据----------');
Log(jso.ToString);
AddLine('----------返回码: ' + SolidWastte_Desc(Result) + '----------');
Flush;
end;
finally
jso.Free;
end;
end;
initialization
finalization
if g_RetPaire <> NIl then
FreeAndNil(g_RetPaire);
end.
|
{----------------------------------------------------------------------------}
{ Written by Nguyen Le Quang Duy }
{ Nguyen Quang Dieu High School, An Giang }
{----------------------------------------------------------------------------}
Program QBMSEQ;
Uses Math;
Const
maxN =10000;
Var
n,res :Integer;
A :Array[1..maxN] of LongInt;
procedure Enter;
var
i :Integer;
begin
Read(n);
for i:=1 to n do Read(A[i]);
end;
function Check(x :LongInt) :Boolean;
var
tmp1,tmp2 :LongInt;
begin
tmp1:=1+8*x; tmp2:=Round(Sqrt(tmp1));
if (tmp2*tmp2=tmp1) and ((-1+tmp2) mod 2=0) and (tmp2<>1) then
Exit(true) else Exit(false);
end;
procedure Optimize;
var
tmp :LongInt;
i :Integer;
begin
res:=0; tmp:=0;
for i:=1 to n do
if (A[i]>0) and (Check(A[i])) then
begin
if (tmp=0) or (A[i]>=A[i-1]) then Inc(tmp)
else
begin
res:=Max(res,tmp); tmp:=1;
end;
end
else
begin
res:=Max(res,tmp); tmp:=0;
end;
res:=Max(res,tmp);
end;
Begin
Assign(Input,''); Reset(Input);
Assign(Output,''); Rewrite(Output);
Enter;
Optimize;
Write(res);
Close(Input); Close(Output);
End. |
//
// This unit is part of the GLScene Project, http://glscene.org
//
{: GLEllipseCollision<p>
Ellipsoid collision functions (mainly used by DCE).
<b>History : </b><font size=-1><ul>
<li>30/03/07 - DaStr - Added $I GLScene.inc
<li>09/05/05 - Mathx - Protection agains float error on getLowestRoot
<li>23/01/05 - LucasG - Code reorganized, many fixes and some new features
<li>03/09/04 - LucasG - First release
<li>29/07/04 - LucasG - Creation
</ul></font>
}
unit GLEllipseCollision;
interface
{$I GLScene.inc}
uses
GLVectorGeometry, GLOctree, GLVectorLists , GLVectorTypes;
type
TECPlane = class
public
Equation: array [0..3] of Single;
Origin: TAffineVector;
Normal: TAffineVector;
procedure MakePlane(const nOrigin, nNormal: TAffineVector); overload;
procedure MakePlane(const p1, p2, p3: TAffineVector); overload;
function isFrontFacingTo(const Direction: TAffineVector): Boolean;
function signedDistanceTo(const Point: TAffineVector): Single;
end;
//Object collision properties
TECObjectInfo = record
AbsoluteMatrix: TMatrix;
Solid: Boolean;
IsDynamic: Boolean;
ObjectID: Integer;
end;
TECTriangle = record
p1,p2,p3: TAffineVector;
end;
TECTriMesh = record
Triangles: Array of TECTriangle;
ObjectInfo: TECObjectInfo;
end;
TECTriMeshList = Array of TECTriMesh;
TECFreeForm = record
OctreeNodes : array of POctreeNode;
triangleFiler : ^TAffineVectorList;
InvertedNormals: Boolean;
ObjectInfo: TECObjectInfo;
end;
TECFreeFormList = Array of TECFreeForm;
TECColliderShape = (csEllipsoid, csPoint);
TECCollider = record
Position: TAffineVector;
Radius: TAffineVector;
Shape: TECColliderShape;
ObjectInfo: TECObjectInfo;
end;
TECColliderList = Array of TECCollider;
TECContact = record
//Generated by the collision procedure
Position: TAffineVector;
SurfaceNormal: TAffineVector;
Distance: Single;
//Collider data
ObjectInfo: TECObjectInfo;
end;
TECContactList = Array of TECContact;
TECCollisionPacket = record
// Information about the move being requested: (in eSpace)
velocity: TAffineVector;
normalizedVelocity: TAffineVector;
basePoint: TAffineVector;
// Hit information
foundCollision: Boolean;
nearestDistance: Single;
NearestObject: Integer;
intersectionPoint: TAffineVector;
intersectionNormal: TAffineVector;
end;
TECMovePack = record
//List of closest triangles
TriMeshes : TECTriMeshList;
//List of freeform octree nodes
Freeforms: TECFreeFormList;
//List of other colliders (f.i. ellipsoids)
Colliders: TECColliderList;
//Movement params
Position : TAffineVector;
Velocity : TAffineVector;
Gravity : TAffineVector;
Radius : TAffineVector;
ObjectInfo : TECObjectInfo;
CollisionRange: Single; //Stores the range where objects may collide
//Internal
UnitScale : Double;
MaxRecursionDepth: Byte;
CP: TECCollisionPacket;
collisionRecursionDepth : Byte;
//Result
ResultPos : TAffineVector;
NearestObject: Integer;
VelocityCollided : Boolean;
GravityCollided : Boolean;
GroundNormal : TAffineVector;
Contacts: TECContactList
end;
function VectorDivide(const v, divider : TAffineVector): TAffineVector;
procedure CollideAndSlide(var MP: TECMovePack);
procedure CollideWithWorld(var MP: TECMovePack; pos, vel: TAffineVector;
var HasCollided: Boolean);
const cECCloseDistance : Single = 0.005;
{.$DEFINE DEBUG}
var debug_tri: Array of TECTriangle;
implementation
{$IFDEF DEBUG}
procedure AddDebugTri(p1,p2,p3: TAffineVector);
begin
SetLength(debug_tri,Length(debug_tri) + 1);
debug_tri[High(debug_tri)].p1 := p1;
debug_tri[High(debug_tri)].p2 := p2;
debug_tri[High(debug_tri)].p3 := p3;
end;
{$ENDIF}
{ Utility functions }
function CheckPointInTriangle(point, pa, pb, pc: TAffineVector):boolean;
var
e10, e20, vp : TAffineVector;
a,b,c,d,e,ac_bb, x,y,z: Single;
begin
e10 := VectorSubtract(pb,pa);
e20 := VectorSubtract(pc,pa);
a := VectorDotProduct(e10,e10);
b := VectorDotProduct(e10,e20);
c := VectorDotProduct(e20,e20);
ac_bb := (a*c)-(b*b);
vp := AffineVectorMake(point.V[0]-pa.V[0], point.V[1]-pa.V[1], point.V[2]-pa.V[2]);
d := VectorDotProduct(vp,e10);
e := VectorDotProduct(vp,e20);
x := (d*c)-(e*b);
y := (e*a)-(d*b);
z := x+y-ac_bb;
result := ((z < 0) and not((x < 0) or (y < 0)));
end;
function getLowestRoot(a, b, c, maxR: Single; var Root: Single): Boolean;
var
determinant: Single;
sqrtD, r1,r2, temp: Single;
begin
// No (valid) solutions
result := false;
// Check if a solution exists
determinant := b*b - 4*a*c;
// If determinant is negative it means no solutions.
if (determinant < 0) then Exit;
// calculate the two roots: (if determinant == 0 then
// x1==x2 but letís disregard that slight optimization)
sqrtD := sqrt(determinant);
if a = 0 then a:= -0.01; //is this really needed?
r1 := (-b - sqrtD) / (2*a);
r2 := (-b + sqrtD) / (2*a);
// Sort so x1 <= x2
if (r1 > r2) then
begin
temp := r2;
r2 := r1;
r1 := temp;
end;
// Get lowest root:
if (r1 > 0) and (r1 < maxR) then
begin
root := r1;
result := true;
Exit;
end;
// It is possible that we want x2 - this can happen
// if x1 < 0
if (r2 > 0) and (r2 < maxR) then
begin
root := r2;
result := true;
Exit;
end;
end;
function VectorDivide(const v, divider : TAffineVector): TAffineVector;
begin
result.V[0]:=v.V[0]/divider.V[0];
result.V[1]:=v.V[1]/divider.V[1];
result.V[2]:=v.V[2]/divider.V[2];
end;
procedure VectorSetLength(var V: TAffineVector; Len: Single);
var l,l2: Single;
begin
l2 := V.V[0]*V.V[0] + V.V[1]*V.V[1] + V.V[2]*V.V[2];
l := sqrt(l2);
if L <> 0 then
begin
Len := Len / l;
V.V[0] := V.V[0] * Len;
V.V[1] := V.V[1] * Len;
V.V[2] := V.V[2] * Len;
end;
end;
{ TECPlane }
procedure TECPlane.MakePlane(const nOrigin, nNormal: TAffineVector);
begin
Normal := nNormal;
Origin := nOrigin;
Equation[0] := normal.V[0];
Equation[1] := normal.V[1];
Equation[2] := normal.V[2];
Equation[3] := -(normal.V[0]*origin.V[0]+normal.V[1]*origin.V[1]+normal.V[2]*origin.V[2]);
end;
procedure TECPlane.MakePlane(const p1, p2, p3: TAffineVector);
begin
Normal := CalcPlaneNormal(p1,p2,p3);
MakePlane(p1,Normal);
end;
function TECPlane.isFrontFacingTo(const Direction: TAffineVector): Boolean;
var Dot: Single;
begin
Dot := VectorDotProduct(Normal,Direction);
result := (Dot <= 0);
end;
function TECPlane.signedDistanceTo(const Point: TAffineVector): Single;
begin
result := VectorDotProduct(Point,Normal) + Equation[3];
end;
{ Collision detection functions }
// Assumes: p1,p2 and p3 are given in ellisoid space:
//Returns true if collided
function CheckTriangle(var MP: TECMovePack; const p1, p2, p3: TAffineVector;
ColliderObjectInfo: TECObjectInfo; var ContactInfo: TECContact): Boolean;
var
trianglePlane: TECPlane;
t0,t1: Double;
embeddedInPlane: Boolean;
signedDistToTrianglePlane: Double;
normalDotVelocity: Single;
temp: Double;
collisionPoint : TAffineVector;
foundCollison : Boolean;
t : Single;
planeIntersectionPoint, V: TAffineVector;
velocity,base : TAffineVector;
velocitySquaredLength : Single;
a,b,c: Single; // Params for equation
newT: Single;
edge, baseToVertex : TAffineVector;
edgeSquaredLength : Single;
edgeDotVelocity : Single;
edgeDotBaseToVertex : Single;
distToCollision : Single;
begin
Result := False;
// Make the plane containing this triangle.
trianglePlane := TECPlane.Create;
trianglePlane.MakePlane(p1,p2,p3);
// Is triangle front-facing to the velocity vector?
// We only check front-facing triangles
// (your choice of course)
if not (trianglePlane.isFrontFacingTo(MP.CP.normalizedVelocity)) then
begin
trianglePlane.Free;
Exit;
end;//}
// Get interval of plane intersection:
embeddedInPlane := false;
// Calculate the signed distance from sphere
// position to triangle plane
//V := VectorAdd(MP.CP.basePoint,MP.CP.velocity);
//signedDistToTrianglePlane := trianglePlane.signedDistanceTo(v);
signedDistToTrianglePlane := trianglePlane.signedDistanceTo(MP.CP.basePoint);
// cache this as weíre going to use it a few times below:
normalDotVelocity := VectorDotProduct(trianglePlane.normal,MP.CP.velocity);
// if sphere is travelling parrallel to the plane:
if normalDotVelocity = 0 then
begin
if (abs(signedDistToTrianglePlane) >= 1) then
begin
// Sphere is not embedded in plane.
// No collision possible:
trianglePlane.Free;
Exit;
end else
begin
// sphere is embedded in plane.
// It intersects in the whole range [0..1]
embeddedInPlane := true;
t0 := 0;
//t1 := 1;
end;
end else
begin
// N dot D is not 0. Calculate intersection interval:
t0 := (-1 - signedDistToTrianglePlane)/normalDotVelocity;
t1 := ( 1 - signedDistToTrianglePlane)/normalDotVelocity;
// Swap so t0 < t1
if (t0 > t1) then
begin
temp := t1;
t1 := t0;
t0 := temp;
end;
// Check that at least one result is within range:
if (t0 > 1) or (t1 < 0) then
begin
trianglePlane.Free;
Exit; // Both t values are outside values [0,1] No collision possible:
end;
// Clamp to [0,1]
if (t0 < 0) then t0 := 0;
if (t0 > 1) then t0 := 1;
//if (t1 < 0) then t1 := 0;
//if (t1 > 1) then t1 := 1;
end;
// OK, at this point we have two time values t0 and t1
// between which the swept sphere intersects with the
// triangle plane. If any collision is to occur it must
// happen within this interval.
foundCollison := false;
t := 1;
// First we check for the easy case - collision inside
// the triangle. If this happens it must be at time t0
// as this is when the sphere rests on the front side
// of the triangle plane. Note, this can only happen if
// the sphere is not embedded in the triangle plane.
if (not embeddedInPlane) then
begin
planeIntersectionPoint := VectorSubtract(MP.CP.basePoint,trianglePlane.Normal);
V := VectorScale(MP.CP.velocity,t0);
VectorAdd(planeIntersectionPoint , V);
if checkPointInTriangle(planeIntersectionPoint,p1,p2,p3) then
begin
foundCollison := True;
t := t0;
collisionPoint := planeIntersectionPoint;
end;
end;
// if we havenít found a collision already weíll have to
// sweep sphere against points and edges of the triangle.
// Note: A collision inside the triangle (the check above)
// will always happen before a vertex or edge collision!
// This is why we can skip the swept test if the above
// gives a collision!
if (not foundCollison) then
begin
// some commonly used terms:
velocity := MP.CP.velocity;
base := MP.CP.basePoint;
velocitySquaredLength := VectorNorm(velocity); //velocitySquaredLength := Sqr(VectorLength(velocity));
// For each vertex or edge a quadratic equation have to
// be solved. We parameterize this equation as
// a*t^2 + b*t + c = 0 and below we calculate the
// parameters a,b and c for each test.
// Check against points:
a := velocitySquaredLength;
// P1
V := VectorSubtract(base,p1);
b := 2.0*(VectorDotProduct(velocity, V));
c := VectorNorm(V) - 1.0; // c := Sqr(VectorLength(V)) - 1.0;
if (getLowestRoot(a,b,c, t, newT)) then
begin
t := newT;
foundCollison := true;
collisionPoint := p1;
end;
// P2
V := VectorSubtract(base,p2);
b := 2.0*(VectorDotProduct(velocity, V));
c := VectorNorm(V) - 1.0; // c := Sqr(VectorLength(V)) - 1.0;
if (getLowestRoot(a,b,c, t, newT)) then
begin
t := newT;
foundCollison := true;
collisionPoint := p2;
end;
// P3
V := VectorSubtract(base,p3);
b := 2.0*(VectorDotProduct(velocity, V));
c := VectorNorm(V) - 1.0; // c := Sqr(VectorLength(V)) - 1.0;
if (getLowestRoot(a,b,c, t, newT)) then
begin
t := newT;
foundCollison := true;
collisionPoint := p3;
end;
// Check against edges:
// p1 -> p2:
edge := VectorSubtract(p2,p1);
baseToVertex := VectorSubtract(p1, base);
edgeSquaredLength := VectorNorm(edge); // edgeSquaredLength := Sqr(VectorLength(edge));
edgeDotVelocity := VectorDotProduct(edge,velocity);
edgeDotBaseToVertex := VectorDotProduct(edge,baseToVertex);
// Calculate parameters for equation
a := edgeSquaredLength * -velocitySquaredLength +
edgeDotVelocity * edgeDotVelocity;
b := edgeSquaredLength*(2* VectorDotProduct(velocity,baseToVertex))-
2.0*edgeDotVelocity*edgeDotBaseToVertex;
c := edgeSquaredLength*(1- VectorNorm(baseToVertex) )+ //(1- Sqr(VectorLength(baseToVertex)) )
edgeDotBaseToVertex*edgeDotBaseToVertex;
// Does the swept sphere collide against infinite edge?
if (getLowestRoot(a,b,c, t, newT)) then
begin
// Check if intersection is within line segment:
temp := (edgeDotVelocity*newT-edgeDotBaseToVertex)/ edgeSquaredLength;
if (temp >= 0) and (temp <= 1) then
begin
// intersection took place within segment.
t := newT;
foundCollison := true;
collisionPoint := VectorAdd(p1, VectorScale(edge,temp));
end;
end;
// p1 -> p2:
edge := VectorSubtract(p3,p2);
baseToVertex := VectorSubtract(p2, base);
edgeSquaredLength := VectorNorm(edge); // edgeSquaredLength := Sqr(VectorLength(edge));
edgeDotVelocity := VectorDotProduct(edge,velocity);
edgeDotBaseToVertex := VectorDotProduct(edge,baseToVertex);
// Calculate parameters for equation
a := edgeSquaredLength * -velocitySquaredLength +
edgeDotVelocity * edgeDotVelocity;
b := edgeSquaredLength*(2* VectorDotProduct(velocity,baseToVertex))-
2.0*edgeDotVelocity*edgeDotBaseToVertex;
c := edgeSquaredLength*(1- VectorNorm(baseToVertex) )+ //(1- Sqr(VectorLength(baseToVertex)) )
edgeDotBaseToVertex*edgeDotBaseToVertex;
// Does the swept sphere collide against infinite edge?
if (getLowestRoot(a,b,c, t, newT)) then
begin
// Check if intersection is within line segment:
temp := (edgeDotVelocity*newT-edgeDotBaseToVertex)/ edgeSquaredLength;
if (temp >= 0) and (temp <= 1) then
begin
// intersection took place within segment.
t := newT;
foundCollison := true;
collisionPoint := VectorAdd(p2, VectorScale(edge,temp));
end;
end;
// p3 -> p1:
edge := VectorSubtract(p1,p3);
baseToVertex := VectorSubtract(p3, base);
edgeSquaredLength := VectorNorm(edge); // edgeSquaredLength := Sqr(VectorLength(edge));
edgeDotVelocity := VectorDotProduct(edge,velocity);
edgeDotBaseToVertex := VectorDotProduct(edge,baseToVertex);
// Calculate parameters for equation
a := edgeSquaredLength * -velocitySquaredLength +
edgeDotVelocity * edgeDotVelocity;
b := edgeSquaredLength*(2* VectorDotProduct(velocity,baseToVertex))-
2.0*edgeDotVelocity*edgeDotBaseToVertex;
c := edgeSquaredLength*(1- VectorNorm(baseToVertex) )+ //(1- Sqr(VectorLength(baseToVertex)) )
edgeDotBaseToVertex*edgeDotBaseToVertex;
// Does the swept sphere collide against infinite edge?
if (getLowestRoot(a,b,c, t, newT)) then
begin
// Check if intersection is within line segment:
temp := (edgeDotVelocity*newT-edgeDotBaseToVertex)/ edgeSquaredLength;
if (temp >= 0) and (temp <= 1) then
begin
// intersection took place within segment.
t := newT;
foundCollison := true;
collisionPoint := VectorAdd(p3, VectorScale(edge,temp));
end;
end;
end;
// Set result:
if foundCollison then
begin
// distance to collision: ítí is time of collision
distToCollision := t * VectorLength(MP.CP.velocity);
Result := True;
with ContactInfo do
begin
Position := collisionPoint;
SurfaceNormal := trianglePlane.Normal;
Distance := distToCollision;
ObjectInfo := ColliderObjectInfo;
end;
// Does this triangle qualify for the closest hit?
// it does if itís the first hit or the closest
if ((MP.CP.foundCollision = false) or (distToCollision < MP.CP.nearestDistance))
and (MP.ObjectInfo.Solid) and (ColliderObjectInfo.Solid) then
begin
// Collision information nessesary for sliding
MP.CP.nearestDistance := distToCollision;
MP.CP.NearestObject := ColliderObjectInfo.ObjectID;
MP.CP.intersectionPoint := collisionPoint;
MP.CP.intersectionNormal := trianglePlane.Normal;
MP.CP.foundCollision := true;
end;
end;
trianglePlane.Free;
end;
function CheckPoint(var MP: TECMovePack; pPos, pNormal: TAffineVector;
ColliderObjectInfo: TECObjectInfo): Boolean;
var newPos: TAffineVector;
Distance: Single;
FoundCollision: Boolean;
begin
newPos := VectorAdd(MP.CP.basePoint, MP.CP.Velocity);
//*** Need to check if the ellipsoid is embedded ***
Distance := VectorDistance(pPos,newPos)-1; //1 is the sphere radius
if Distance < 0 then Distance := 0;
if (VectorNorm(MP.CP.Velocity) >= VectorDistance2(MP.CP.basePoint,pPos)) then
Distance := 0;
FoundCollision := Distance <= (cECCloseDistance * MP.UnitScale); //Very small distance
Result := FoundCollision;
// Set result:
if FoundCollision then
begin
//Add a contact
SetLength(MP.Contacts,Length(MP.Contacts)+1);
with MP.Contacts[High(MP.Contacts)] do
begin
Position := pPos;
ScaleVector(Position,MP.Radius);
SurfaceNormal := pNormal;
Distance := Distance;
ObjectInfo := ColliderObjectInfo;
end;
if ((MP.CP.foundCollision = false) or (Distance < MP.CP.nearestDistance))
and (MP.ObjectInfo.Solid) and (ColliderObjectInfo.Solid) then
begin
// Collision information nessesary for sliding
MP.CP.nearestDistance := Distance;
MP.CP.NearestObject := ColliderObjectInfo.ObjectID;
MP.CP.intersectionPoint := pPos;
MP.CP.intersectionNormal := pNormal;
MP.CP.foundCollision := true;
end;
end;
end;
function CheckEllipsoid(var MP: TECMovePack; ePos, eRadius: TAffineVector;
ColliderObjectInfo: TECObjectInfo): Boolean;
var newPos, nA, rA, nB, rB, iPoint, iNormal: TAffineVector;
dist: single;
begin
Result := False;
//Check if the new position has passed the ellipse
if VectorNorm(MP.CP.velocity) < VectorDistance2(MP.CP.basePoint, ePos) then
newPos := VectorAdd(MP.CP.basePoint, MP.CP.Velocity)
else begin
nA := VectorScale(VectorNormalize(VectorSubtract(MP.CP.basePoint,ePos)),1);
newPos := VectorAdd(ePos,nA);
end;
//Find intersection
nA := VectorNormalize(VectorDivide(VectorSubtract(ePos,newPos),eRadius));
rA := VectorAdd(newPos,nA);
nB := VectorNormalize(VectorDivide(VectorSubtract(rA,ePos),eRadius));
ScaleVector(nB,eRadius);
//Is colliding?
dist := VectorDistance(newPos, ePos) - 1 - VectorLength(nB);
if (dist > cECCloseDistance) then Exit;
rB := VectorAdd(ePos,nB);
iPoint := rB;
iNormal := VectorNormalize(VectorDivide(VectorSubtract(newPos,ePos),eRadius));
if dist < 0 then dist := 0;
//Add a contact
SetLength(MP.Contacts,Length(MP.Contacts)+1);
with MP.Contacts[High(MP.Contacts)] do
begin
Position := iPoint;
ScaleVector(Position,MP.Radius);
SurfaceNormal := iNormal;
Distance := Dist;
ObjectInfo := ColliderObjectInfo;
end;
if ((MP.CP.foundCollision = false) or (Dist < MP.CP.nearestDistance))
and (MP.ObjectInfo.Solid) and (ColliderObjectInfo.Solid) then
begin
MP.CP.nearestDistance := Dist;
MP.CP.NearestObject := ColliderObjectInfo.ObjectID;
MP.CP.intersectionPoint := iPoint;
MP.CP.intersectionNormal := iNormal;
MP.CP.foundCollision := true;
end;
Result := True;
end;
procedure CheckCollisionFreeForm(var MP: TECMovePack);
var
n,i,t,k : Integer;
p: POctreeNode;
p1, p2, p3: PAffineVector;
v1, v2, v3: TAffineVector;
Collided: Boolean;
ContactInfo: TECContact;
begin
//For each freeform
for n := 0 to High(MP.Freeforms) do
begin
//For each octree node
for i:=0 to High(MP.Freeforms[n].OctreeNodes) do begin
p:=MP.Freeforms[n].OctreeNodes[i];
//for each triangle
for t:=0 to High(p.TriArray) do begin
k:=p.triarray[t];
//These are the vertices of the triangle to check
p1:=@MP.Freeforms[n].triangleFiler^.List[k];
p2:=@MP.Freeforms[n].triangleFiler^.List[k+1];
p3:=@MP.Freeforms[n].triangleFiler^.List[k+2];
if not MP.Freeforms[n].InvertedNormals then
begin
SetVector(v1, VectorTransform(p1^, MP.Freeforms[n].ObjectInfo.AbsoluteMatrix));
SetVector(v2, VectorTransform(p2^, MP.Freeforms[n].ObjectInfo.AbsoluteMatrix));
SetVector(v3, VectorTransform(p3^, MP.Freeforms[n].ObjectInfo.AbsoluteMatrix));
end else
begin
SetVector(v1, VectorTransform(p3^, MP.Freeforms[n].ObjectInfo.AbsoluteMatrix));
SetVector(v2, VectorTransform(p2^, MP.Freeforms[n].ObjectInfo.AbsoluteMatrix));
SetVector(v3, VectorTransform(p1^, MP.Freeforms[n].ObjectInfo.AbsoluteMatrix));
end;
{$IFDEF DEBUG}
AddDebugTri(v1,v2,v3); //@Debug
{$ENDIF}
//Set the triangles to the ellipsoid space
v1 := VectorDivide(v1, MP.Radius);
v2 := VectorDivide(v2, MP.Radius);
v3 := VectorDivide(v3, MP.Radius);
Collided := CheckTriangle(MP,v1,v2,v3,MP.Freeforms[n].ObjectInfo,ContactInfo);
//Add a contact
if Collided then
begin
SetLength(MP.Contacts,Length(MP.Contacts)+1);
ScaleVector(ContactInfo.Position,MP.Radius);
MP.Contacts[High(MP.Contacts)] := ContactInfo;
end;
end;
end;
end; //for n
end;
procedure CheckCollisionTriangles(var MP: TECMovePack);
var
n,i : Integer;
p1, p2, p3: TAffineVector;
Collided: Boolean;
ContactInfo: TECContact;
begin
for n := 0 to High(MP.TriMeshes) do
begin
for i := 0 to High(MP.TriMeshes[n].Triangles) do
begin
{$IFDEF DEBUG}
AddDebugTri(MP.TriMeshes[n].Triangles[i].p1,MP.TriMeshes[n].Triangles[i].p2,MP.TriMeshes[n].Triangles[i].p3); //@Debug
{$ENDIF}
//These are the vertices of the triangle to check
p1 := VectorDivide( MP.TriMeshes[n].Triangles[i].p1, MP.Radius);
p2 := VectorDivide( MP.TriMeshes[n].Triangles[i].p2, MP.Radius);
p3 := VectorDivide( MP.TriMeshes[n].Triangles[i].p3, MP.Radius);
Collided := CheckTriangle(MP,p1,p2,p3,MP.TriMeshes[n].ObjectInfo, ContactInfo);
//Add a contact
if Collided then
begin
SetLength(MP.Contacts,Length(MP.Contacts)+1);
ScaleVector(ContactInfo.Position,MP.Radius);
MP.Contacts[High(MP.Contacts)] := ContactInfo;
end;
end;
end;
end;
procedure CheckCollisionColliders(var MP: TECMovePack);
var
i : Integer;
p1, p2: TAffineVector;
begin
for i := 0 to High(MP.Colliders) do
begin
p1 := VectorDivide( MP.Colliders[i].Position, MP.Radius);
p2 := VectorDivide( MP.Colliders[i].Radius, MP.Radius);
case MP.Colliders[i].Shape of
csEllipsoid : CheckEllipsoid(MP,p1,p2,MP.Colliders[i].ObjectInfo);
csPoint : CheckPoint(MP,p1,p2,MP.Colliders[i].ObjectInfo);
end;
end;
end;
procedure CollideAndSlide(var MP: TECMovePack);
var
eSpacePosition, eSpaceVelocity: TAffineVector;
begin
// calculate position and velocity in eSpace
eSpacePosition := VectorDivide(MP.Position, MP.Radius);
eSpaceVelocity := VectorDivide(MP.velocity, MP.Radius);
// Iterate until we have our final position.
MP.collisionRecursionDepth := 0;
collideWithWorld(MP, eSpacePosition,eSpaceVelocity, MP.VelocityCollided);
// Add gravity pull:
// Set the new R3 position (convert back from eSpace to R3
MP.GroundNormal := NullVector;
MP.GravityCollided := False;
if not VectorIsNull(MP.Gravity) then
begin
eSpaceVelocity := VectorDivide(MP.Gravity,MP.Radius);
eSpacePosition := MP.ResultPos;
MP.collisionRecursionDepth := 0;
collideWithWorld(MP, eSpacePosition,eSpaceVelocity, MP.GravityCollided);
if MP.GravityCollided then MP.GroundNormal := MP.CP.intersectionNormal;
end;
// Convert final result back to R3:
ScaleVector(MP.ResultPos, MP.Radius);
end;
procedure CollideWithWorld(var MP: TECMovePack; pos, vel: TAffineVector;
var HasCollided: Boolean);
var
veryCloseDistance: Single;
destinationPoint, newBasePoint, V : TAffineVector;
slidePlaneOrigin,slidePlaneNormal : TAffineVector;
slidingPlane : TECPlane;
newDestinationPoint, newVelocityVector : TAffineVector;
begin
//First we set to false (no collision)
if (MP.collisionRecursionDepth = 0) then HasCollided := False;
veryCloseDistance := cECCloseDistance * MP.UnitScale;
MP.ResultPos := pos;
// do we need to worry?
if (MP.collisionRecursionDepth > MP.MaxRecursionDepth) then Exit;
// Ok, we need to worry:
MP.CP.velocity := vel;
MP.CP.normalizedVelocity := VectorNormalize(vel);
MP.CP.basePoint := pos;
MP.CP.foundCollision := false;
// Check for collision (calls the collision routines)
CheckCollisionFreeForm(MP);
CheckCollisionTriangles(MP);
CheckCollisionColliders(MP);
// If no collision we just move along the velocity
if (not MP.CP.foundCollision) then
begin
MP.ResultPos := VectorAdd(pos, vel);
Exit;
end;
// *** Collision occured ***
if (MP.CP.foundCollision) then HasCollided := True;
MP.NearestObject := MP.CP.NearestObject;
// The original destination point
destinationPoint := VectorAdd(pos, vel);
newBasePoint := pos;
// only update if we are not already very close
// and if so we only move very close to intersection..not
// to the exact spot.
if (MP.CP.nearestDistance >= veryCloseDistance) then
begin
V := vel;
VectorSetLength(V,MP.CP.nearestDistance - veryCloseDistance);
newBasePoint := VectorAdd(MP.CP.BasePoint, V);
// Adjust polygon intersection point (so sliding
// plane will be unaffected by the fact that we
// move slightly less than collision tells us)
NormalizeVector(V);
ScaleVector(V,veryCloseDistance);
SubtractVector(MP.CP.intersectionPoint, V);
end;
// Determine the sliding plane
slidePlaneOrigin := MP.CP.intersectionPoint;
slidePlaneNormal := VectorSubtract( newBasePoint , MP.CP.intersectionPoint );
NormalizeVector(slidePlaneNormal);
slidingPlane := TECPlane.Create;
slidingPlane.MakePlane(slidePlaneOrigin,slidePlaneNormal);
V := VectorScale(slidePlaneNormal, slidingPlane.signedDistanceTo(destinationPoint));
newDestinationPoint := VectorSubtract( destinationPoint , V );
// Generate the slide vector, which will become our new
// velocity vector for the next iteration
newVelocityVector := VectorSubtract( newDestinationPoint , MP.CP.intersectionPoint);
if (MP.CP.nearestDistance = 0) then
begin
V := VectorNormalize(VectorSubtract(newBasePoint,MP.CP.intersectionPoint));
V := VectorScale(V, veryCloseDistance);
AddVector(newVelocityVector, v);
end;
// Recurse:
// dont recurse if the new velocity is very small
if (VectorNorm(newVelocityVector) < Sqr(veryCloseDistance)) then
begin
MP.ResultPos := newBasePoint;
slidingPlane.Free;
Exit;
end;
slidingPlane.Free;
Inc(MP.collisionRecursionDepth);
collideWithWorld(MP, newBasePoint,newVelocityVector,HasCollided);
end;
end.
|
{ ***************************************************************************
Copyright (c) 2016-2018 Kike Pérez
Unit : Quick.ImageFX
Description : Image manipulation
Author : Kike Pérez
Version : 4.0
Created : 21/11/2017
Modified : 11/08/2018
This file is part of QuickImageFX: https://github.com/exilon/QuickImageFX
***************************************************************************
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 Quick.ImageFX;
interface
uses
Classes,
System.SysUtils,
Winapi.ShellAPI,
Winapi.Windows,
Vcl.Controls,
Graphics,
System.Math,
Vcl.Imaging.pngimage,
Vcl.Imaging.jpeg,
Vcl.Imaging.GIFImg,
System.Net.HttpClient,
CCR.Exif,
Quick.ImageFX.Types;
type
IImageFX = interface
['{58BC1417-EC58-472E-A503-92B199C21AE8}']
function ResizeOptions : TResizeOptions;
function NewBitmap(w,h : Integer) : IImageFX;
function LoadFromFile(const fromfile : string; CheckIfFileExists : Boolean = False) : IImageFX;
function LoadFromStream(stream : TStream) : IImageFX;
function LoadFromString(const str : string) : IImageFX;
function LoadFromImageList(imgList : TImageList; ImageIndex : Integer) : IImageFX;
function LoadFromIcon(Icon : TIcon) : IImageFX;
function LoadFromFileIcon(const FileName : string; IconIndex : Word) : IImageFX;
function LoadFromFileExtension(const aFilename : string; LargeIcon : Boolean) : IImageFX;
function LoadFromResource(const ResourceName : string) : IImageFX;
function LoadFromHTTP(const urlImage : string; out HTTPReturnCode : Integer; RaiseExceptions : Boolean = False) : IImageFX;
procedure GetResolution(var x,y : Integer); overload;
function GetResolution : string; overload;
function AspectRatio : Double;
function AspectRatioStr : string;
function IsEmpty : Boolean;
function Clone : IImageFX;
function IsGray : Boolean;
procedure Assign(Graphic : TGraphic);
function Clear(pcolor : TColor = clWhite) : IImageFX;
function Draw(Graphic : TGraphic; x, y : Integer; alpha : Double = 1) : IImageFX; overload;
function Draw(stream : TStream; x, y : Integer; alpha : Double = 1) : IImageFX; overload;
function DrawCentered(Graphic : TGraphic; alpha : Double = 1) : IImageFX; overload;
function DrawCentered(stream: TStream; alpha : Double = 1) : IImageFX; overload;
function AsBitmap : TBitmap;
function AsPNG : TPngImage;
function AsJPG : TJpegImage;
function AsGIF : TGifImage;
function AsString(imgFormat : TImageFormat = ifJPG) : string;
procedure SaveToPNG(const outfile : string);
procedure SaveToJPG(const outfile : string);
procedure SaveToBMP(const outfile : string);
procedure SaveToGIF(const outfile : string);
procedure SaveToStream(stream : TStream; imgFormat : TImageFormat = ifJPG);
function Resize(w, h : Integer) : IImageFX; overload;
function Resize(w, h : Integer; ResizeMode : TResizeMode; ResizeFlags : TResizeFlags = []; ResampleMode : TResamplerMode = rsLinear) : IImageFX; overload;
function Rotate90 : IImageFX;
function Rotate180 : IImageFX;
function Rotate270 : IImageFX;
function RotateBy(RoundAngle : Integer) : IImageFX;
function RotateAngle(RotAngle : Single) : IImageFX;
function FlipX : IImageFX;
function FlipY : IImageFX;
function GrayScale : IImageFX;
function ScanlineH : IImageFX;
function ScanlineV : IImageFX;
function Lighten(StrenghtPercent : Integer = 30) : IImageFX;
function Darken(StrenghtPercent : Integer = 30) : IImageFX;
function Tint(mColor : TColor) : IImageFX;
function TintAdd(R, G , B : Integer) : IImageFX;
function TintBlue : IImageFX;
function TintRed : IImageFX;
function TintGreen : IImageFX;
function Solarize : IImageFX;
function Rounded(RoundLevel : Integer = 27) : IImageFX;
function JPEGCorruptionCheck(jpg : TJPEGImage): Boolean; overload;
function JPEGCorruptionCheck(const stream : TMemoryStream): Boolean; overload;
end;
TImageFX = class(TInterfacedObject)
private
fJPGQualityLevel : TJPGQualityLevel;
fPNGCompressionLevel : TPNGCompressionLevel;
fProgressiveJPG : Boolean;
fResizeOptions : TResizeOptions;
fHTTPOptions : THTTPOptions;
fLastResult : TImageActionResult;
fExifRotation : Boolean;
function GetHTTPStream(const urlImage: string; out HTTPReturnCode: Integer): TMemoryStream;
public
constructor Create; overload; virtual;
constructor Create(const fromfile : string); overload; virtual;
destructor Destroy; override;
property JPGQualityPercent : TJPGQualityLevel read fJPGQualityLevel write fJPGQualityLevel;
property PNGCompressionLevel : TPNGCompressionLevel read fPNGCompressionLevel write fPNGCompressionLevel;
property ProgressiveJPG : Boolean read fProgressiveJPG write fProgressiveJPG;
property HTTPOptions : THTTPOptions read fHTTPOptions write fHTTPOptions;
property ExifRotation : Boolean read fExifRotation write fExifRotation;
property LastResult : TImageActionResult read fLastResult write fLastResult;
function ResizeOptions : TResizeOptions;
function GetResolution : string;
function AspectRatioStr : string;
procedure CloneValues(var ImgTarget : IImageFX);
procedure InitBitmap(var bmp : TBitmap);
procedure ProcessExifRotation(stream: TStream);
function NeedsEXIFRotation(stream: TStream) : Boolean;
function FindGraphicClass(const Buffer; const BufferSize: Int64; out GraphicClass: TGraphicClass): Boolean; overload;
function FindGraphicClass(Stream: TStream; out GraphicClass: TGraphicClass): Boolean; overload;
function GetImageFmtExt(imgFormat : TImageFormat) : string;
function GetFileInfo(const AExt : string; var AInfo : TSHFileInfo; ALargeIcon : Boolean = false) : boolean;
function LoadFromHTTP(const urlImage : string; out HTTPReturnCode : Integer; RaiseExceptions : Boolean = False) : IImageFX;
class function GetAspectRatio(cWidth, cHeight : Integer) : string;
class function ColorToRGBValues(PColor: TColor) : TRGB;
class function RGBValuesToColor(RGBValues : TRGB) : TColor;
class function ActionResultToString(aImgResult : TImageActionResult) : string;
class function ColorIsLight(Color: TColor): Boolean;
class function ColorIsDark(Color: TColor): Boolean;
class function GetLightColor(BaseColor: TColor): TColor;
class function GetDarkColor(BaseColor: TColor): TColor;
class function ChangeColorIntesity(MyColor: TColor; Factor: Double): TColor;
class procedure CleanTransparentPng(var png: TPngImage; NewWidth, NewHeight: Integer);
function JPEGCorruptionCheck(jpg : TJPEGImage): Boolean; overload;
function JPEGCorruptionCheck(const stream : TMemoryStream): Boolean; overload;
class procedure AutoCropBitmap(var bmp : TBitmap; aColor : TColor);
end;
TImageFXClass = class of TImageFX;
implementation
{ TImageFX }
constructor TImageFX.Create;
begin
ProgressiveJPG := False;
JPGQualityPercent := 85;
PNGCompressionLevel := 7;
LastResult := arNone;
fResizeOptions := TResizeOptions.Create;
fResizeOptions.NoMagnify := False;
fResizeOptions.ResizeMode := rmStretch;
fResizeOptions.ResamplerMode := rsAuto;
fResizeOptions.Center := False;
fResizeOptions.FillBorders := False;
fResizeOptions.BorderColor := clWhite;
fResizeOptions.SkipSmaller := False;
HTTPOptions := THTTPOptions.Create;
HTTPOptions.UserAgent := DEF_USERAGENT;
HTTPOptions.ConnectionTimeout := DEF_CONNECTION_TIMEOUT;
HTTPOptions.ResponseTimeout := DEF_RESPONSE_TIMEOUT;
HTTPOptions.AllowCookies := False;
HTTPOptions.HandleRedirects := True;
HTTPOptions.MaxRedirects := 10;
fExifRotation := True;
end;
destructor TImageFX.Destroy;
begin
if Assigned(fResizeOptions) then fResizeOptions.Free;
if Assigned(HTTPOptions) then HTTPOptions.Free;
inherited;
end;
function TImageFX.FindGraphicClass(const Buffer; const BufferSize: Int64; out GraphicClass: TGraphicClass): Boolean;
var
LongWords: array[Byte] of LongWord absolute Buffer;
Words: array[Byte] of Word absolute Buffer;
begin
GraphicClass := nil;
Result := False;
if BufferSize < MinGraphicSize then Exit;
case Words[0] of
$4D42: GraphicClass := TBitmap;
$D8FF: GraphicClass := TJPEGImage;
$4949: if Words[1] = $002A then GraphicClass := TWicImage; //i.e., TIFF
$4D4D: if Words[1] = $2A00 then GraphicClass := TWicImage; //i.e., TIFF
else
begin
if Int64(Buffer) = $A1A0A0D474E5089 then GraphicClass := TPNGImage
else if LongWords[0] = $9AC6CDD7 then GraphicClass := TMetafile
else if (LongWords[0] = 1) and (LongWords[10] = $464D4520) then GraphicClass := TMetafile
else if StrLComp(PAnsiChar(@Buffer), 'GIF', 3) = 0 then GraphicClass := TGIFImage
else if Words[1] = 1 then GraphicClass := TIcon;
end;
end;
Result := (GraphicClass <> nil);
end;
function TImageFX.FindGraphicClass(Stream: TStream; out GraphicClass: TGraphicClass): Boolean;
var
Buffer: PByte;
CurPos: Int64;
BytesRead: Integer;
begin
if Stream is TCustomMemoryStream then
begin
Buffer := TCustomMemoryStream(Stream).Memory;
CurPos := Stream.Position;
Inc(Buffer, CurPos);
Result := FindGraphicClass(Buffer^, Stream.Size - CurPos, GraphicClass);
end
else
begin
GetMem(Buffer, MinGraphicSize);
try
BytesRead := Stream.Read(Buffer^, MinGraphicSize);
Stream.Seek(-BytesRead, soCurrent);
Result := FindGraphicClass(Buffer^, BytesRead, GraphicClass);
finally
FreeMem(Buffer);
end;
end;
end;
function TImageFX.GetImageFmtExt(imgFormat : TImageFormat) : string;
begin
case imgFormat of
ifBMP: Result := '.bmp';
ifJPG: Result := '.jpg';
ifPNG: Result := '.png';
ifGIF: Result := '.gif';
else Result := '.jpg';
end;
end;
function TImageFX.GetFileInfo(const AExt : string; var AInfo : TSHFileInfo; ALargeIcon : Boolean = False) : Boolean;
var uFlags : integer;
begin
FillMemory(@AInfo,SizeOf(TSHFileInfo),0);
uFlags := SHGFI_ICON+SHGFI_TYPENAME+SHGFI_USEFILEATTRIBUTES;
if ALargeIcon then uFlags := uFlags + SHGFI_LARGEICON
else uFlags := uFlags + SHGFI_SMALLICON;
if SHGetFileInfo(PChar(AExt),FILE_ATTRIBUTE_NORMAL,AInfo,SizeOf(TSHFileInfo),uFlags) = 0 then Result := False
else Result := True;
end;
function TImageFX.GetHTTPStream(const urlImage : string; out HTTPReturnCode : Integer) : TMemoryStream;
var
http : THTTPClient;
StatusCode : Integer;
begin
StatusCode := 500;
LastResult := arUnknowFmtType;
http := THTTPClient.Create;
try
http.UserAgent := HTTPOptions.UserAgent;
http.HandleRedirects := HTTPOptions.HandleRedirects;
http.MaxRedirects := HTTPOptions.MaxRedirects;
http.AllowCookies := HTTPOptions.AllowCookies;
http.ConnectionTimeout := HTTPOptions.ConnectionTimeout;
http.ResponseTimeout := HTTPOptions.ResponseTimeout;
Result := TMemoryStream.Create;
StatusCode := http.Get(urlImage,Result).StatusCode;
if StatusCode = 200 then
begin
if (Result = nil) or (Result.Size = 0) then
begin
StatusCode := 500;
raise Exception.Create('http stream empty!');
end
else LastResult := arOk;
end else raise Exception.Create(Format('Error %d retrieving url %s',[StatusCode,urlImage]));
finally
HTTPReturnCode := StatusCode;
http.Free;
end;
end;
function TImageFX.LoadFromHTTP(const urlImage : string; out HTTPReturnCode : Integer; RaiseExceptions : Boolean = False) : IImageFX;
var
http : THTTPClient;
ms : TMemoryStream;
begin
Result := (Self as IImageFX);
HTTPReturnCode := 500;
LastResult := arUnknowFmtType;
try
ms := GetHTTPStream(urlImage,HTTPReturnCode);
try
(Self as IImageFX).LoadFromStream(ms);
if (Self as IImageFX).IsEmpty then
begin
HTTPReturnCode := 500;
if RaiseExceptions then raise Exception.Create('Unknown Format');
end
else LastResult := arOk;
finally
ms.Free;
end;
except
on E : Exception do if RaiseExceptions then raise Exception.Create(e.message);
end;
end;
class function TImageFX.ColorToRGBValues(PColor: TColor): TRGB;
begin
Result.B := PColor and $FF;
Result.G := (PColor shr 8) and $FF;
Result.R := (PColor shr 16) and $FF;
end;
constructor TImageFX.Create(const fromfile: string);
begin
Create;
(Self as IImageFX).LoadFromFile(fromfile);
end;
function TImageFX.ResizeOptions: TResizeOptions;
begin
Result := fResizeOptions;
end;
function TImageFX.AspectRatioStr : string;
var
x, y : Integer;
begin
if not (Self as IImageFX).IsEmpty then
begin
(Self as IImageFX).GetResolution(x,y);
Result := GetAspectRatio(x,y);
end
else Result := 'N/A';
end;
function TImageFX.GetResolution : string;
var
x, y : Integer;
begin
if not (Self as IImageFX).IsEmpty then
begin
(Self as IImageFX).GetResolution(x,y);
Result := Format('%d x %d',[x,y]);
LastResult := arOk;
end
else
begin
Result := 'N/A';
LastResult := arCorruptedData;
end;
end;
class function TImageFX.RGBValuesToColor(RGBValues : TRGB) : TColor;
begin
Result := RGB(RGBValues.R,RGBValues.G,RGBValues.B);
end;
class function TImageFX.ActionResultToString(aImgResult: TImageActionResult) : string;
begin
case aImgResult of
arNone : Result := 'None';
arOk : Result := 'Action Ok';
arAlreadyOptim : Result := 'Already optimized';
arRotateError : Result := 'Rotate or Flip error';
arColorizeError : Result := 'Error manipulating pixel colors';
arZeroBytes : Result := 'File/Stream is empty';
arResizeError : Result := 'Resize error';
arConversionError : Result := 'Conversion error';
arUnknowFmtType : Result := 'Unknow Format type';
arFileNotExist : Result := 'File not exists';
arUnknowError : Result := 'Unknow error';
arNoOverwrited : Result := 'Not overwrited';
arCorruptedData : Result := 'Corrupted data';
else Result := Format('Unknow error (%d)',[Integer(aImgResult)]);
end;
end;
//check if color is light
class function TImageFX.ColorIsLight(Color: TColor): Boolean;
begin
Color := ColorToRGB(Color);
Result := ((Color and $FF) + (Color shr 8 and $FF) +
(Color shr 16 and $FF))>= $180;
end;
//check if color is dark
class function TImageFX.ColorIsDark(Color: TColor): Boolean;
begin
Result := not ColorIsLight(Color);
end;
//gets a more light color
class function TImageFX.GetLightColor(BaseColor: TColor): TColor;
begin
Result := RGB(Min(GetRValue(ColorToRGB(BaseColor)) + 64, 255),
Min(GetGValue(ColorToRGB(BaseColor)) + 64, 255),
Min(GetBValue(ColorToRGB(BaseColor)) + 64, 255));
end;
procedure TImageFX.InitBitmap(var bmp: TBitmap);
begin
bmp.PixelFormat := pf32bit;
bmp.HandleType := bmDIB;
bmp.AlphaFormat := afDefined;
end;
//gets a more dark color
class function TImageFX.GetDarkColor(BaseColor: TColor): TColor;
begin
Result := RGB(Max(GetRValue(ColorToRGB(BaseColor)) - 64, 0),
Max(GetGValue(ColorToRGB(BaseColor)) - 64, 0),
Max(GetBValue(ColorToRGB(BaseColor)) - 64, 0));
end;
class function TImageFX.ChangeColorIntesity(MyColor: TColor; Factor: Double): TColor;
var
Red, Green, Blue: Integer;
ChangeAmount: Double;
begin
// get the color components
Red := MyColor and $FF;
Green := (MyColor shr 8) and $FF;
Blue := (MyColor shr 16) and $FF;
// calculate the new color
ChangeAmount := Red * Factor;
Red := Min(Max(Round(Red + ChangeAmount), 0), 255);
ChangeAmount := Green * Factor;
Green := Min(Max(Round(Green + ChangeAmount), 0), 255);
ChangeAmount := Blue * Factor;
Blue := Min(Max(Round(Blue + ChangeAmount), 0), 255);
// and return it as a TColor
Result := Red or (Green shl 8) or (Blue shl 16);
end;
function TImageFX.JPEGCorruptionCheck(jpg : TJPEGImage): Boolean;
var
w1 : Word;
w2 : Word;
ms : TMemoryStream;
begin
Assert(SizeOf(WORD) = 2);
ms := TMemoryStream.Create;
try
jpg.SaveToStream(ms);
Result := Assigned(ms);
if Result then
begin
ms.Seek(0, soFromBeginning);
ms.Read(w1,2);
ms.Position := ms.Size - 2;
ms.Read(w2,2);
Result := (w1 = $D8FF) and (w2 = $D9FF);
end;
finally
ms.Free;
end;
end;
function TImageFX.JPEGCorruptionCheck(const stream: TMemoryStream): Boolean;
var
w1 : Word;
w2 : Word;
begin
Assert(SizeOf(WORD) = 2);
Result := Assigned(stream);
if Result then
begin
stream.Seek(0, soFromBeginning);
stream.Read(w1,2);
stream.Position := stream.Size - 2;
stream.Read(w2,2);
Result := (w1 = $D8FF) and (w2 = $D9FF);
end;
end;
procedure TImageFX.ProcessExifRotation(stream: TStream);
var
ExifData : TExifData;
begin
//read Exif info and rotates image if needed
stream.Seek(soFromBeginning,0);
ExifData := TExifData.Create;
try
if ExifData.IsSupportedGraphic(stream) then
begin
stream.Seek(soFromBeginning,0);
ExifData.LoadFromGraphic(stream);
ExifData.EnsureEnumsInRange := False;
if not ExifData.Empty then
begin
case ExifData.Orientation of
//TExifOrientation.toTopLeft : //Normal
TExifOrientation.toTopRight : (Self as IImageFX).FlipX; //Mirror horizontal
TExifOrientation.toBottomRight : (Self as IImageFX).Rotate180; //Rotate 180°
TExifOrientation.toBottomLeft : (Self as IImageFX).FlipY; //Mirror vertical
TExifOrientation.toLeftTop : begin (Self as IImageFX).FlipX.Rotate270; end; //Mirrow horizontal and rotate 270°
TExifOrientation.toRightTop : (Self as IImageFX).Rotate90; //Rotate 90°
TExifOrientation.toRightBottom : begin (Self as IImageFX).FlipX.Rotate90; end; //Mirror horizontal and rotate 90°
TExifOrientation.toLeftBottom : (Self as IImageFX).Rotate270; //Rotate 270°
end;
end;
end;
finally
ExifData.Free;
end;
end;
function TImageFX.NeedsEXIFRotation(stream: TStream) : Boolean;
var
ExifData : TExifData;
begin
Result := False;
stream.Seek(soFromBeginning,0);
ExifData := TExifData.Create;
try
if ExifData.IsSupportedGraphic(stream) then
begin
stream.Seek(soFromBeginning,0);
ExifData.LoadFromGraphic(stream);
ExifData.EnsureEnumsInRange := False;
if not ExifData.Empty then
begin
if (ExifData.Orientation <> TExifOrientation.toUndefined) and (ExifData.Orientation <> TExifOrientation.toTopLeft) then Result := True;
end;
end;
finally
ExifData.Free;
end;
end;
class procedure TImageFX.CleanTransparentPng(var png: TPngImage; NewWidth, NewHeight: Integer);
var
BasePtr: Pointer;
begin
png := TPngImage.CreateBlank(COLOR_RGBALPHA, 16, NewWidth, NewHeight);
BasePtr := png.AlphaScanline[0];
ZeroMemory(BasePtr, png.Header.Width * png.Header.Height);
end;
procedure TImageFX.CloneValues(var ImgTarget : IImageFX);
begin
(ImgTarget as TImageFX).JPGQualityPercent := Self.JPGQualityPercent;
(ImgTarget as TImageFX).PNGCompressionLevel := Self.PNGCompressionLevel;
(ImgTarget as TImageFX).ProgressiveJPG := Self.ProgressiveJPG;
(ImgTarget as TImageFX).ResizeOptions.NoMagnify := Self.ResizeOptions.NoMagnify;
(ImgTarget as TImageFX).ResizeOptions.ResizeMode := Self.ResizeOptions.ResizeMode;
(ImgTarget as TImageFX).ResizeOptions.ResamplerMode := Self.ResizeOptions.ResamplerMode;
(ImgTarget as TImageFX).ResizeOptions.Center := Self.ResizeOptions.Center;
(ImgTarget as TImageFX).ResizeOptions.FillBorders := Self.ResizeOptions.FillBorders;
(ImgTarget as TImageFX).ResizeOptions.BorderColor := Self.ResizeOptions.BorderColor;
(ImgTarget as TImageFX).HTTPOptions.UserAgent := Self.HTTPOptions.UserAgent;
(ImgTarget as TImageFX).HTTPOptions.HandleRedirects := Self.HTTPOptions.HandleRedirects;
(ImgTarget as TImageFX).HTTPOptions.MaxRedirects := Self.HTTPOptions.MaxRedirects;
(ImgTarget as TImageFX).HTTPOptions.AllowCookies := Self.HTTPOptions.AllowCookies;
(ImgTarget as TImageFX).HTTPOptions.ConnectionTimeout := Self.HTTPOptions.ConnectionTimeout;
(ImgTarget as TImageFX).HTTPOptions.ResponseTimeout := Self.HTTPOptions.ResponseTimeout;
end;
function CalcCloseCrop(ABitmap: TBitmap; const ABackColor: TColor) : TRect;
var
X: Integer;
Y: Integer;
Color: TColor;
Pixel: PRGBTriple;
RowClean: Boolean;
LastClean: Boolean;
begin
if ABitmap.PixelFormat <> pf24bit then
raise Exception.Create('Incorrect bit depth, bitmap must be 24-bit!');
LastClean := False;
Result := Rect(ABitmap.Width, ABitmap.Height, 0, 0);
for Y := 0 to ABitmap.Height-1 do
begin
RowClean := True;
Pixel := ABitmap.ScanLine[Y];
for X := 0 to ABitmap.Width - 1 do
begin
Color := RGB(Pixel.rgbtRed, Pixel.rgbtGreen, Pixel.rgbtBlue);
if Color <> ABackColor then
begin
RowClean := False;
if X < Result.Left then
Result.Left := X;
if X + 1 > Result.Right then
Result.Right := X + 1;
end;
Inc(Pixel);
end;
if not RowClean then
begin
if not LastClean then
begin
LastClean := True;
Result.Top := Y;
end;
if Y + 1 > Result.Bottom then
Result.Bottom := Y + 1;
end;
end;
if Result.IsEmpty then
begin
if Result.Left = ABitmap.Width then
Result.Left := 0;
if Result.Top = ABitmap.Height then
Result.Top := 0;
if Result.Right = 0 then
Result.Right := ABitmap.Width;
if Result.Bottom = 0 then
Result.Bottom := ABitmap.Height;
end;
end;
class procedure TImageFX.AutoCropBitmap(var bmp : TBitmap; aColor : TColor);
var
auxbmp : TBitmap;
rect : TRect;
begin
rect := CalcCloseCrop(bmp,aColor);
auxbmp := TBitmap.Create;
try
auxbmp.PixelFormat := bmp.PixelFormat;
auxbmp.Width := rect.Width;
auxbmp.Height := rect.Height;
BitBlt(auxbmp.Canvas.Handle, 0, 0, rect.BottomRight.x, rect.BottomRight.Y, bmp.Canvas.Handle, rect.TopLeft.x, rect.TopLeft.Y, SRCCOPY);
bmp.Assign(auxbmp);
finally
auxbmp.Free;
end;
end;
class function TImageFX.GetAspectRatio(cWidth, cHeight : Integer) : string;
var
ar : Integer;
begin
if cHeight = 0 then Exit;
ar := GCD(cWidth,cHeight);
Result := Format('%d:%d',[cWidth div ar, cHeight div ar]);
end;
end.
|
unit uReduxStore;
interface
uses System.Generics.Collections, System.SysUtils, System.Variants,
System.Classes;
type
TReducer<S> = reference to function(State : S; Action : Integer):S;
TListener<S> = reference to procedure(State : S);
TReduxStore<T> = class(TObject)
private
FState : T;
FReducer : TReducer<T>;
FListeners : TList<TListener<T>>;
public
constructor Create(InitialState : T; Reducer : TReducer<T>); reintroduce; overload;
procedure DispatchAction(Action : Integer);
procedure AddListener(Listener:TListener<T>);
function GetState: T;
end;
implementation
{ TReduxStore }
procedure TReduxStore<T>.AddListener(Listener: TListener<T>);
begin
FListeners.Add(Listener);
end;
constructor TReduxStore<T>.Create(InitialState : T; Reducer : TReducer<T>);
begin
FState := InitialState;
FReducer := Reducer;
FListeners := TList<TListener<T>>.Create;
end;
procedure TReduxStore<T>.DispatchAction(Action: Integer);
var
Listener : TListener<T>;
begin
FState := FReducer(FState,Action);
for Listener in FListeners do
Listener(FState);
end;
function TReduxStore<T>.GetState: T;
begin
Result := FState;
end;
end.
|
unit Unit_FrameSampleSoloMesh;
interface
uses
Vcl.Forms, Vcl.Controls, Vcl.StdCtrls, System.Classes, Vcl.ExtCtrls, Vcl.Samples.Spin;
type
TFrameSampleSoloMesh = class(TFrame)
Label13: TLabel;
Label12: TLabel;
Label11: TLabel;
Label10: TLabel;
Label9: TLabel;
Label8: TLabel;
Label7: TLabel;
Label6: TLabel;
Label5: TLabel;
Label4: TLabel;
Label2: TLabel;
seCellSize: TSpinEdit;
seMaxSampleError: TSpinEdit;
seSampleDistance: TSpinEdit;
seVertsPerPoly: TSpinEdit;
seMaxEdgeError: TSpinEdit;
seMaxEdgeLength: TSpinEdit;
rgPartitioning: TRadioGroup;
seMergedRegionSize: TSpinEdit;
seMinRegionSize: TSpinEdit;
seMaxSlope: TSpinEdit;
seMaxClimb: TSpinEdit;
seAgentRadius: TSpinEdit;
seAgentHeight: TSpinEdit;
seCellHeight: TSpinEdit;
chkKeepIntermediateResults: TCheckBox;
rgDrawMode: TRadioGroup;
Label1: TLabel;
Label3: TLabel;
end;
implementation
{$R *.dfm}
end.
|
Program Example9;
uses Crt;
{ Program to demonstrate the ClrEol function. }
begin
Write('This line will be cleared from the',
' cursor postion until the right of the screen');
GotoXY(27,WhereY);
ReadKey;
ClrEol;
WriteLn;
end.
|
Unit WlanInterface;
Interface
Uses
Windows, Classes, WlanAPI, WlanAPIClient;
Type
TWlanInterfaceState = (
wisNotReady, wisConnected, wisAdhocFormed,
wisDisconnecting, wisDisconnected, wisAssociating,
wisDiscovering, wisAuthenticationg);
TWlanInterface = Class
Private
FGuid : PGUID;
FDescription : WideString;
FState : TWlanInterfaceState;
FClient : TWlanAPIClient;
Public
Class Function NewInstance(AClient:TWlanAPIClient; ARecord:PWLAN_INTERFACE_INFO_LIST):TWlanInterface;
Class Function StateToStr(AState:TWlanInterfaceState):WideString;
Destructor Destroy; Override;
Function EnumNetworks(AList:TList):Boolean;
Function Connect(AParameters:PWLAN_CONNECTION_PARAMETERS):Boolean;
Function Disconnect:Boolean;
Function GetNetworkBssList(pDot11Ssid:PDOT11_SSID; dot11BssType:DWORD; bSecurityEnabled:BOOL; Var pWlanBssList:PWLAN_BSS_LIST):Boolean;
Property Guid : PGUID Read FGuid;
Property Description : WideString Read FDescription;
Property State : TWlanInterfaceState Read FState;
end;
Implementation
Uses
WlanNetwork;
Destructor TWlanInterface.Destroy;
begin
If Assigned(FGuid) Then
begin
FreeMem(FGuid);
FGuid := Nil;
end;
Inherited Destroy;
end;
Class Function TWlanInterface.NewInstance(AClient:TWlanAPIClient; ARecord:PWLAN_INTERFACE_INFO_LIST):TWlanInterface;
begin
Try
Result := TWlanInterface.Create;
GetMem(Result.FGuid, SizeOf(TGUID));
Except
If Assigned(Result) Then
begin
Result.Free;
Result := Nil;
end;
end;
If Assigned(Result) Then
begin
ZeroMemory(Result.FGuid, SizeOf(TGUID));
Result.FGuid^ := ARecord.InterfaceInfo[ARecord.dwIndex].InterfaceGuid;
Result.FState := TWlanInterfaceSTate(ARecord.InterfaceInfo[ARecord.dwIndex].isState);
Result.FDescription := Copy(WideString(ARecord.InterfaceInfo[ARecord.dwIndex].strInterfaceDescription), 1, Length(WideString(ARecord.InterfaceInfo[ARecord.dwIndex].strInterfaceDescription)));
Result.FClient := AClient;
end;
end;
Class Function TWlanInterface.StateToStr(AState:TWlanInterfaceState):WideString;
begin
Case AState Of
wisNotReady : Result := 'nepřipravena';
wisConnected : Result := 'připojena';
wisAdhocFormed : Result := 'sí ad-hoc';
wisDisconnecting : Result := 'odpojování';
wisDisconnected : Result := 'odpojena';
wisAssociating : Result := 'připojování';
wisDiscovering : Result := 'vyhledávání sítí';
wisAuthenticationg : Result := 'autentizace';
end;
end;
Function TWlanInterface.EnumNetworks(AList:TList):Boolean;
Var
Flags : DWORD;
Networks : PWLAN_AVAILABLE_NETWORK_LIST;
I, J : Integer;
Tmp : TWlanNetwork;
begin
Flags := 0;
Result := FClient._WlanGetAvailableNetworkList(FGuid, Flags, Networks);
If Result Then
begin
For I := 0 To Networks.dwNumberOfItems - 1 Do
begin
Networks.dwIndex := I;
If ((Networks.Network[Networks.dwIndex].dwFlags And WLAN_AVAILABLE_NETWORK_HAS_PROFILE) = 0) Then
begin
Tmp := TWlanNetwork.NewInstance(FClient, Self, Networks);
Result := Assigned(Tmp);
If Result Then
begin
AList.Add(Tmp);
end
Else begin
For J := I - 1 DownTo 0 Do
TWlanNetwork(AList[J]).Free;
AList.Clear;
Break;
end;
end;
end;
WlanFreeMemory(Networks);
end;
end;
Function TWlanInterface.Connect(AParameters:PWLAN_CONNECTION_PARAMETERS):Boolean;
begin
Result := FClient._WlanConnect(FGUid, AParameters);
end;
Function TWlanInterface.Disconnect:Boolean;
begin
Result := FClient._WlanDisconnect(FGuid);
end;
Function TWlanInterface.GetNetworkBssList(pDot11Ssid:PDOT11_SSID; dot11BssType:DWORD; bSecurityEnabled:BOOL; Var pWlanBssList:PWLAN_BSS_LIST):Boolean;
begin
Result := FClient._WlanGetNetworkBssList(FGuid, pDot11Ssid, dot11BssType, bSecurityEnabled, pWlanBssList);
end;
End.
|
{*******************************************************}
{ }
{ Delphi LiveBindings Framework }
{ }
{ Copyright(c) 2011 Embarcadero Technologies, Inc. }
{ }
{*******************************************************}
{$HPPEMIT '#pragma link "Fmx.Bind.Editors"'} {Do not Localize}
unit Fmx.Bind.Editors;
interface
uses
System.Classes, System.Bindings.EvalProtocol, Data.Bind.Components, Data.Bind.Editors, System.Bindings.ObjEval,
FMX.ListBox, FMX.Grid, FMX.Controls, FMX.Types;
type
TBindStateCheckBoxEditor = class(TBindCheckBoxEditor)
private
FCheckBox: TCheckBox;
public
constructor Create(ACheckBox: TCheckBox);
function GetState: TBindCheckBoxState; override;
procedure SetState(Value: TBindCheckBoxState); override;
function GetAllowGrayed: Boolean; override;
procedure SetAllowGrayed(Value: Boolean); override;
end;
TBindListListBoxEditor = class(TBindListEditor)
private
FIndex: Integer;
FListBox: TCustomListBox;
public
constructor Create(AListBox: TCustomListBox);
destructor Destroy; override;
procedure BeginUpdate; override;
procedure EndUpdate; override;
procedure DeleteToEnd; override;
function AddItem(Select: Boolean): IScope; override;
function InsertItem(Select: Boolean): IScope; override;
function CanInsertItem: Boolean; override;
function MoveNext: Boolean; override;
function GetRowCount: Integer; override;
function CurrentItem: IScope; override;
procedure ClearList; override;
function GetSelectedText: string; override;
procedure SetSelectedText(const AValue: string); override;
function GetSelectedItem: TObject; override;
end;
TBindListComboBoxEditor = class(TBindListEditor)
private
FIndex: Integer;
FComboBox: TCustomComboBox;
protected
procedure BeginUpdate; override;
procedure EndUpdate; override;
procedure DeleteToEnd; override;
function AddItem(Select: Boolean): IScope; override;
function InsertItem(Select: Boolean): IScope; override;
function CanInsertItem: Boolean; override;
function MoveNext: Boolean; override;
function GetRowCount: Integer; override;
function CurrentItem: IScope; override;
procedure ClearList; override;
function GetSelectedText: string; override;
function GetSelectedItem: TObject; override;
procedure SetSelectedText(const AValue: string); override;
public
constructor Create(AComboBox: TCustomComboBox);
destructor Destroy; override;
end;
TBaseListBoxItemEditorObject = class
protected
FIndex: Integer;
function GetControlItems: TStrings; virtual; abstract;
function GetControlItemIndex: Integer; virtual; abstract;
procedure SetControlItemIndex(AIndex: Integer); virtual; abstract;
procedure ControlClear; virtual; abstract;
public
property ControlItems: TStrings read GetControlItems;
property ControlItemIndex: Integer read GetControlItemIndex write SetControlItemIndex;
end;
TStringGridItemEditorObject = class
private
FStringGrid: TStringGrid;
FIndex: Integer;
function GetOwner: TStringGrid;
function GetCells(ACol: Integer): string;
procedure SetCells(ACol: Integer; const Value: string);
public
property Owner: TStringGrid read GetOwner;
property Cells[ACol: Integer]: string read GetCells write SetCells;
end;
TGridItemEditorObject = class
private
FGrid: TGrid;
FIndex: Integer;
function GetOwner: TGrid;
function GetCells(ACol: Integer): string;
procedure SetCells(ACol: Integer; const Value: string);
public
property Owner: TGrid read GetOwner;
property Cells[ACol: Integer]: string read GetCells write SetCells;
end;
TBindListStringGridEditor = class(TBindGridEditor)
private
FEditorObject: TStringGridItemEditorObject;
function IsEmpty: Boolean;
function GetFixedRows: Integer;
function GetFixedCols: Integer;
function GetRowIndex: Integer;
function GetColumnIndex: Integer;
protected
procedure BeginUpdate; override;
procedure EndUpdate; override;
function AddItem(Select: Boolean): IScope; override;
function InsertItem(Select: Boolean): IScope; override;
function CanInsertItem: Boolean; override;
function CurrentItem: IScope; override;
function GetRowCount: Integer; override;
function MoveNext: Boolean; override;
procedure DeleteToEnd; override;
procedure ClearList; override;
function GetSelectedText: string; override;
procedure SetSelectedText(const AValue: string); override;
procedure GetColumnNames(ANames: TStrings); override;
procedure GetColumnIndices(ANames: TStrings); override;
public
constructor Create(AGrid: TStringGrid);
destructor Destroy; override;
end;
TBindListGridEditor = class(TBindGridEditor)
private
FEditorObject: TGridItemEditorObject;
function IsEmpty: Boolean;
function GetFixedRows: Integer;
function GetFixedCols: Integer;
function GetRowIndex: Integer;
function GetColumnIndex: Integer;
protected
procedure BeginUpdate; override;
procedure EndUpdate; override;
function AddItem(Select: Boolean): IScope; override;
function InsertItem(Select: Boolean): IScope; override;
function CanInsertItem: Boolean; override;
function CurrentItem: IScope; override;
function GetRowCount: Integer; override;
function MoveNext: Boolean; override;
procedure DeleteToEnd; override;
procedure ClearList; override;
function GetSelectedText: string; override;
procedure SetSelectedText(const AValue: string); override;
procedure GetColumnNames(ANames: TStrings); override;
procedure GetColumnIndices(ANames: TStrings); override;
public
constructor Create(AGrid: TGrid);
destructor Destroy; override;
end;
implementation
uses System.SysUtils, System.Math, FMX.Edit;
type
TBindCheckBoxEditorFactory = class(TBindEditorFactory)
public
constructor Create; override;
function Supports(AIntf: TGuid; AObject: TObject): Boolean; override;
function CreateEditor(AIntf: TGuid;
AObject: TObject): IInterface; override;
end;
TBindListBoxEditorFactory = class(TBindEditorFactory)
public
constructor Create; override;
function Supports(AIntf: TGuid; AObject: TObject): Boolean; override;
function CreateEditor(AIntf: TGuid;
AObject: TObject): IInterface; override;
end;
TBindComboBoxEditorFactory = class(TBindEditorFactory)
public
constructor Create; override;
function Supports(AIntf: TGuid; AObject: TObject): Boolean; override;
function CreateEditor(AIntf: TGuid;
AObject: TObject): IInterface; override;
end;
TBindComboEditEditorFactory = class(TBindEditorFactory)
public
constructor Create; override;
function Supports(AIntf: TGuid; AObject: TObject): Boolean; override;
function CreateEditor(AIntf: TGuid;
AObject: TObject): IInterface; override;
end;
TBindStringGridEditorFactory = class(TBindEditorFactory)
public
constructor Create; override;
function Supports(AIntf: TGuid; AObject: TObject): Boolean; override;
function CreateEditor(AIntf: TGuid;
AObject: TObject): IInterface; override;
end;
TBindGridEditorFactory = class(TBindEditorFactory)
public
constructor Create; override;
function Supports(AIntf: TGuid; AObject: TObject): Boolean; override;
function CreateEditor(AIntf: TGuid;
AObject: TObject): IInterface; override;
end;
TComboEditItemEditorObject = class(TBaseListBoxItemEditorObject)
private
FListBox: TComboEdit;
function GetOwner: TComboEdit;
procedure SetText(const Value: string);
function GetText: string;
protected
function GetControlItems: TStrings; override;
function GetControlItemIndex: Integer; override;
procedure SetControlItemIndex(AIndex: Integer); override;
procedure ControlClear; override;
public
constructor Create(AListBox: TComboEdit);
property Text: string read GetText write SetText;
property Owner: TComboEdit read GetOwner;
end;
TBindListComboEditEditor = class(TBindListEditor)
private
FEditorObject: TBaseListBoxItemEditorObject;
protected
function CreateItemsEditor(
AControl: TControl): TBaseListBoxItemEditorObject; virtual;
procedure BeginUpdate; override;
procedure EndUpdate; override;
procedure DeleteToEnd; override;
function AddItem(Select: Boolean): IScope; override;
function InsertItem(Select: Boolean): IScope; override;
function CanInsertItem: Boolean; override;
function MoveNext: Boolean; override;
function GetRowCount: Integer; override;
function CurrentItem: IScope; override;
procedure ClearList; override;
function GetSelectedText: string; override;
procedure SetSelectedText(const AValue: string); override;
public
constructor Create(AComboBox: TComboEdit);
destructor Destroy; override;
end;
{ TBindListListBoxEditor }
function TBindListListBoxEditor.AddItem(Select: Boolean): IScope;
var
LListBoxItem: TListBoxItem;
begin
LListBoxItem := TListBoxItem.Create(nil);
LListBoxItem.Parent := FListBox;
FIndex := LListBoxItem.Index;
if Select then
FListBox.ItemIndex := FIndex;
Result := WrapObject(LListBoxItem);
end;
function TBindListListBoxEditor.MoveNext: Boolean;
begin
if FListBox.Count = 0 then
Exit(False);
if FIndex = -1 then
begin
FIndex := FListBox.ItemIndex;
if FIndex < 0 then
FIndex := 0;
end
else
FIndex := FIndex + 1;
Result := (FIndex >= 0) and (FIndex < FListBox.Count);
end;
function TBindListListBoxEditor.GetRowCount: Integer;
begin
Result := FListBox.Count;
end;
function TBindListListBoxEditor.CurrentItem: IScope;
begin
if FIndex = -1 then
FIndex := FListBox.ItemIndex;
if (FIndex <> -1) and (FIndex < FListBox.Count) then
Result := WrapObject(FListBox.ListItems[FIndex])
else
Result := nil;
end;
procedure TBindListListBoxEditor.BeginUpdate;
begin
// BeginUpdate prevents resources from being applied
//FEditorObject.FListBox.BeginUpdate;
end;
function TBindListListBoxEditor.CanInsertItem: Boolean;
begin
Result := FListBox.ItemIndex <> -1;
end;
procedure TBindListListBoxEditor.ClearList;
begin
FListBox.Clear;
end;
constructor TBindListListBoxEditor.Create(AListBox: TCustomListBox);
begin
FListBox := AListBox;
FIndex := -1;
end;
destructor TBindListListBoxEditor.Destroy;
begin
inherited;
end;
procedure TBindListListBoxEditor.EndUpdate;
begin
//FEditorObject.FListBox.EndUpdate;
end;
function TBindListListBoxEditor.GetSelectedText: string;
begin
Result := '';
if FListBox.ItemIndex <> -1 then
with FListBox do
if ItemIndex < Count then
Result := ListItems[ItemIndex].Text;
end;
function TBindListListBoxEditor.InsertItem(Select: Boolean): IScope;
var
LListBoxItem: TListBoxItem;
begin
LListBoxItem := TListBoxItem.Create(nil);
LListBoxItem.Parent := FListBox;
FIndex := LListBoxItem.Index;
if Select then
FListBox.ItemIndex := FIndex;
Result := WrapObject(LListBoxItem);
end;
function TBindListListBoxEditor.GetSelectedItem: TObject;
begin
Result := nil;
if FListBox.ItemIndex <> -1 then
with FListBox do
if ItemIndex < Count then
Result := ListItems[ItemIndex];
end;
procedure TBindListListBoxEditor.SetSelectedText(const AValue: string);
var
I: Integer;
begin
for I := 0 to FListBox.Count - 1 do
with FListBox do
if SameText(ListItems[I].Text, AValue) then
begin
ItemIndex := I;
Exit;
end;
FListBox.ItemIndex := -1;
end;
procedure TBindListListBoxEditor.DeleteToEnd;
begin
if FIndex = -1 then
FIndex := FListBox.ItemIndex;
while FListBox.Count > Max(0, FIndex) do
FListBox.RemoveObject(
FListBox.ListItems[FListBox.Count-1]);
FIndex := FListBox.Count - 1;
end;
{ TBindListComboBoxEditor }
function TBindListComboBoxEditor.AddItem(Select: Boolean): IScope;
var
LListBoxItem: TListBoxItem;
begin
LListBoxItem := TListBoxItem.Create(nil);
LListBoxItem.Parent := FComboBox;
FIndex := LListBoxItem.Index;
if Select then
FComboBox.ItemIndex := FIndex;
Result := WrapObject(LListBoxItem);
end;
function TBindListComboBoxEditor.MoveNext: Boolean;
begin
if FComboBox.Count = 0 then
Exit(False);
if FIndex = -1 then
begin
FIndex := FComboBox.ItemIndex;
if FIndex < 0 then
FIndex := 0;
end
else
FIndex := FIndex + 1;
Result := (FIndex >= 0) and (FIndex < FComboBox.Count);
end;
function TBindListComboBoxEditor.GetRowCount: Integer;
begin
Result := FComboBox.Count;
end;
function TBindListComboBoxEditor.CurrentItem: IScope;
begin
if FIndex = -1 then
FIndex := FComboBox.ItemIndex;
if FIndex <> -1 then
Result := WrapObject(FComboBox.ListBox.ListItems[FIndex])
else
Result := nil;
end;
procedure TBindListComboBoxEditor.BeginUpdate;
begin
// BeginUpdate prevents resources from being applied
//FEditorObject.FListBox.BeginUpdate;
end;
function TBindListComboBoxEditor.CanInsertItem: Boolean;
begin
Result := FComboBox.ItemIndex <> -1;
end;
procedure TBindListComboBoxEditor.ClearList;
begin
FComboBox.Clear;
end;
constructor TBindListComboBoxEditor.Create(AComboBox: TCustomComboBox);
begin
FComboBox := AComboBox;
FIndex := -1;
end;
destructor TBindListComboBoxEditor.Destroy;
begin
inherited;
end;
procedure TBindListComboBoxEditor.EndUpdate;
begin
//FEditorObject.FListBox.EndUpdate;
end;
function TBindListComboBoxEditor.GetSelectedText: string;
begin
Result := '';
if FComboBox.ItemIndex <> -1 then
with FComboBox.ListBox do
if ItemIndex < Count then
Result := ListItems[ItemIndex].Text;
end;
function TBindListComboBoxEditor.InsertItem(Select: Boolean): IScope;
var
LListBoxItem: TListBoxItem;
begin
LListBoxItem := TListBoxItem.Create(nil);
LListBoxItem.Parent := FComboBox;
FIndex := LListBoxItem.Index;
if Select then
FComboBox.ItemIndex := FIndex;
//Result := WrapObject(FEditorObject);
Result := WrapObject(LListBoxItem);
end;
function TBindListComboBoxEditor.GetSelectedItem: TObject;
begin
Result := nil;
if FComboBox.ItemIndex <> -1 then
with FComboBox.ListBox do
if ItemIndex < Count then
Result := ListItems[ItemIndex];
end;
procedure TBindListComboBoxEditor.SetSelectedText(const AValue: string);
var
I: Integer;
begin
for I := 0 to FComboBox.Count - 1 do
with FComboBox do
if SameText(ListBox.ListItems[I].Text, AValue) then
begin
ItemIndex := I;
Exit;
end;
FComboBox.ItemIndex := -1;
end;
procedure TBindListComboBoxEditor.DeleteToEnd;
begin
if FIndex = -1 then
FIndex := FComboBox.ItemIndex;
while FComboBox.Count > Max(0, FIndex) do
FComboBox.RemoveObject(
FComboBox.ListBox.ListItems[FComboBox.Count-1]);
FIndex := FComboBox.Count - 1;
end;
{ TBindListComboEditEditor }
function TBindListComboEditEditor.AddItem(Select: Boolean): IScope;
begin
FEditorObject.FIndex := FEditorObject.ControlItems.Add('');
if Select then
FEditorObject.ControlItemIndex := FEditorObject.FIndex;
Result := WrapObject(FEditorObject);
end;
function TBindListComboEditEditor.MoveNext: Boolean;
begin
if FEditorObject.ControlItems.Count = 0 then
Exit(False);
if FEditorObject.FIndex = -1 then
begin
FEditorObject.FIndex := FEditorObject.ControlItemIndex;
if FEditorObject.FIndex < 0 then
FEditorObject.FIndex := 0;
end
else
FEditorObject.FIndex := FEditorObject.FIndex + 1;
Result := (FEditorObject.FIndex >= 0) and (FEditorObject.FIndex < FEditorObject.ControlItems.Count);
end;
function TBindListComboEditEditor.GetRowCount: Integer;
begin
Result := FEditorObject.ControlItems.Count;
end;
function TBindListComboEditEditor.CurrentItem: IScope;
begin
if FEditorObject.FIndex = -1 then
FEditorObject.FIndex := FEditorObject.ControlItemIndex;
if FEditorObject.FIndex <> -1 then
Result := WrapObject(FEditorObject);
end;
procedure TBindListComboEditEditor.BeginUpdate;
begin
FEditorObject.ControlItems.BeginUpdate;
end;
function TBindListComboEditEditor.CanInsertItem: Boolean;
begin
Result := FEditorObject.ControlItemIndex <> -1;
end;
procedure TBindListComboEditEditor.ClearList;
begin
FEditorObject.ControlClear;
FEditorObject.FIndex := -1;
end;
constructor TBindListComboEditEditor.Create(AComboBox: TComboEdit);
begin
FEditorObject := CreateItemsEditor(AComboBox);
FEditorObject.FIndex := -1;
end;
destructor TBindListComboEditEditor.Destroy;
begin
FEditorObject.Free;
inherited;
end;
procedure TBindListComboEditEditor.EndUpdate;
begin
FEditorObject.ControlItems.EndUpdate;
end;
function TBindListComboEditEditor.GetSelectedText: string;
begin
Result := '';
if FEditorObject.ControlItemIndex <> -1 then
with FEditorObject do
Result := ControlItems[ControlItemIndex];
end;
function TBindListComboEditEditor.InsertItem(Select: Boolean): IScope;
begin
if not CanInsertItem then
Result := nil
else
begin
FEditorObject.FIndex := FEditorObject.ControlItemIndex;
FEditorObject.ControlItems.Insert(FEditorObject.FIndex, '');
if Select then
FEditorObject.ControlItemIndex := FEditorObject.FIndex;
Result := WrapObject(FEditorObject);
end;
end;
procedure TBindListComboEditEditor.SetSelectedText(const AValue: string);
var
I: Integer;
begin
I := FEditorObject.ControlItems.IndexOf(AValue);
FEditorObject.ControlItemIndex := I;
end;
procedure TBindListComboEditEditor.DeleteToEnd;
begin
if FEditorObject.FIndex = -1 then
FEditorObject.FIndex := FEditorObject.ControlItemIndex;
while FEditorObject.ControlItems.Count > Max(0, FEditorObject.FIndex) do
FEditorObject.ControlItems.Delete(FEditorObject.ControlItems.Count-1);
FEditorObject.FIndex := FEditorObject.ControlItems.Count - 1;
end;
function TBindListComboEditEditor.CreateItemsEditor(
AControl: TControl): TBaseListBoxItemEditorObject;
begin
Result := TComboEditItemEditorObject.Create(AControl as TComboEdit);
end;
{ TBindListBoxEditorFactory }
constructor TBindListBoxEditorFactory.Create;
begin
inherited;
end;
function TBindListBoxEditorFactory.CreateEditor(AIntf: TGuid;
AObject: TObject): IInterface;
begin
Result := TBindListListBoxEditor.Create(TCustomListBox(AObject));
end;
function TBindListBoxEditorFactory.Supports(AIntf: TGuid; AObject:
TObject): Boolean;
begin
Result := False;
if AIntf = IBindListEditor then
if AObject.InheritsFrom(TCustomListBox) then
Result := True;
end;
{ TBindComboBoxEditorFactory }
constructor TBindComboBoxEditorFactory.Create;
begin
inherited;
end;
function TBindComboBoxEditorFactory.CreateEditor(AIntf: TGuid;
AObject: TObject): IInterface;
begin
Result := TBindListComboBoxEditor.Create(TCustomComboBox(AObject));
end;
function TBindComboBoxEditorFactory.Supports(AIntf: TGuid; AObject:
TObject): Boolean;
begin
Result := False;
if AIntf = IBindListEditor then
if AObject.InheritsFrom(TCustomComboBox) then
Result := True;
end;
{ TBindComboEditEditorFactory }
constructor TBindComboEditEditorFactory.Create;
begin
inherited;
end;
function TBindComboEditEditorFactory.CreateEditor(AIntf: TGuid;
AObject: TObject): IInterface;
begin
Result := TBindListComboEditEditor.Create(TComboEdit(AObject));
end;
function TBindComboEditEditorFactory.Supports(AIntf: TGuid; AObject:
TObject): Boolean;
begin
Result := False;
if AIntf = IBindListEditor then
if AObject.InheritsFrom(TComboEdit) then
Result := True;
end;
{ TBindStringGridEditorFactory }
constructor TBindStringGridEditorFactory.Create;
begin
inherited;
end;
function TBindStringGridEditorFactory.CreateEditor(AIntf: TGuid;
AObject: TObject): IInterface;
begin
Result := TBindListStringGridEditor.Create(TStringGrid(AObject));
end;
function TBindStringGridEditorFactory.Supports(AIntf: TGuid; AObject:
TObject): Boolean;
begin
Result := False;
if AIntf = IBindListEditor then
if (AObject <> nil) and AObject.InheritsFrom(TStringGrid) then
Result := True;
end;
{ TBindGridEditorFactory }
constructor TBindGridEditorFactory.Create;
begin
inherited;
end;
function TBindGridEditorFactory.CreateEditor(AIntf: TGuid;
AObject: TObject): IInterface;
begin
Result := TBindListGridEditor.Create(TGrid(AObject));
end;
function TBindGridEditorFactory.Supports(AIntf: TGuid; AObject:
TObject): Boolean;
begin
Result := False;
if AIntf = IBindListEditor then
if (AObject <> nil) and AObject.InheritsFrom(TGrid) then
Result := True;
end;
{ TBindListStringGridEditor }
function TBindListStringGridEditor.AddItem(Select: Boolean): IScope;
begin
// if IsEmpty then
// begin
// // Assume first row is empty and use it
// end
// else
FEditorObject.FStringGrid.RowCount := FEditorObject.FStringGrid.RowCount + 1;
FEditorObject.FIndex := FEditorObject.FStringGrid.RowCount - 1;
if Select then
FEditorObject.FStringGrid.Selected := FEditorObject.FIndex;
Result := WrapObject(FEditorObject);
end;
function TBindListStringGridEditor.GetFixedRows: Integer;
begin
Result := 0;
end;
function TBindListStringGridEditor.GetFixedCols: Integer;
begin
Result := 0;
end;
function TBindListStringGridEditor.GetRowIndex: Integer;
begin
if FEditorObject.FStringGrid.Selected >= FEditorObject.FStringGrid.RowCount then
Result := FEditorObject.FStringGrid.RowCount - 1
else
Result := FEditorObject.FStringGrid.Selected;
end;
function TBindListStringGridEditor.GetColumnIndex: Integer;
begin
Result := FEditorObject.FStringGrid.ColumnIndex;
end;
procedure TBindListStringGridEditor.GetColumnIndices(ANames: TStrings);
var
I: Integer;
begin
for I := 0 to FEditorObject.FStringGrid.ColumnCount - 1 do
ANames.Add(IntToStr(I));
end;
procedure TBindListStringGridEditor.GetColumnNames(ANames: TStrings);
var
I: Integer;
begin
for I := 0 to FEditorObject.FStringGrid.ColumnCount - 1 do
ANames.Add(FEditorObject.FStringGrid.Columns[I].Name);
end;
function TBindListStringGridEditor.CurrentItem: IScope;
begin
//FEditorObject.FIndex := FEditorObject.FStringGrid.Row;
if FEditorObject.FIndex = -1 then
FEditorObject.FIndex := GetRowIndex;
Result := WrapObject(FEditorObject);
end;
procedure TBindListStringGridEditor.BeginUpdate;
begin
FEditorObject.FStringGrid.BeginUpdate;
end;
function TBindListStringGridEditor.CanInsertItem: Boolean;
begin
Result := False; // Not supported
end;
procedure TBindListStringGridEditor.ClearList;
begin
FEditorObject.FIndex := -1;
if GetFixedRows > 0 then
begin
FEditorObject.FStringGrid.RowCount := GetFixedRows + 1;
end
else
FEditorObject.FStringGrid.RowCount := 0;
end;
constructor TBindListStringGridEditor.Create(AGrid: TStringGrid);
begin
FEditorObject := TStringGridItemEditorObject.Create;
FEditorObject.FStringGrid := AGrid;
FEditorObject.FIndex := -1;
end;
procedure TBindListStringGridEditor.DeleteToEnd;
begin
if FEditorObject.FIndex = -1 then
FEditorObject.FIndex := GetRowIndex;
if (FEditorObject.FIndex = -1) or (FEditorObject.FIndex = GetFixedRows) then
ClearList
else
FEditorObject.FStringGrid.RowCount := FEditorObject.FIndex;
end;
destructor TBindListStringGridEditor.Destroy;
begin
FEditorObject.Free;
inherited;
end;
procedure TBindListStringGridEditor.EndUpdate;
begin
FEditorObject.FStringGrid.EndUpdate;
end;
function TBindListStringGridEditor.InsertItem(Select: Boolean): IScope;
begin
Result := nil;
end;
function TBindListStringGridEditor.IsEmpty: Boolean;
begin
Result := (FEditorObject.FStringGrid.RowCount = GetFixedRows + 1)
end;
function TBindListStringGridEditor.GetRowCount: Integer;
begin
if IsEmpty then
Result := 0
else
Result := FEditorObject.FStringGrid.RowCount - GetFixedRows;
end;
function TBindListStringGridEditor.GetSelectedText: string;
begin
Result := '';
with FEditorObject do
begin
if GetRowIndex >= GetFixedRows then
if GetColumnIndex >= GetFixedCols then
Result := FStringGrid.Cells[GetColumnIndex, GetRowIndex];
end;
end;
function TBindListStringGridEditor.MoveNext: Boolean;
begin
if FEditorObject.FStringGrid.RowCount = 0 then
Exit(False);
if FEditorObject.FIndex = -1 then
FEditorObject.FIndex := GetRowIndex
else
FEditorObject.FIndex := FEditorObject.FIndex + 1;
Result := FEditorObject.FIndex < FEditorObject.FStringGrid.RowCount;
end;
procedure TBindListStringGridEditor.SetSelectedText(const AValue: string);
begin
with FEditorObject.FStringGrid do
begin
if GetRowIndex >= GetFixedRows then
if GetColumnIndex >= GetFixedCols then
Cells[GetColumnIndex, GetRowIndex] := AValue;
end;
end;
{ TStringGridItemEditorObject }
function TStringGridItemEditorObject.GetCells(ACol: Integer): string;
begin
Result := Self.FStringGrid.Cells[ACol, FIndex];
end;
function TStringGridItemEditorObject.GetOwner: TStringGrid;
begin
Result := FStringGrid;
end;
procedure TStringGridItemEditorObject.SetCells(ACol: Integer;
const Value: string);
begin
if FIndex > -1 then
if FIndex <= Self.FStringGrid.RowCount then
Self.FStringGrid.Cells[ACol, FIndex] := Value;
end;
{ TBindListGridEditor }
function TBindListGridEditor.AddItem(Select: Boolean): IScope;
begin
// if IsEmpty then
// begin
// // Assume first row is empty and use it
// end
// else
FEditorObject.FGrid.RowCount := FEditorObject.FGrid.RowCount + 1;
FEditorObject.FGrid.ApplyStyleLookup; // Update columns
FEditorObject.FIndex := FEditorObject.FGrid.RowCount - 1;
if Select then
FEditorObject.FGrid.Selected := FEditorObject.FIndex;
Result := WrapObject(FEditorObject);
end;
function TBindListGridEditor.GetFixedRows: Integer;
begin
Result := 0;
end;
function TBindListGridEditor.GetFixedCols: Integer;
begin
Result := 0;
end;
function TBindListGridEditor.GetRowIndex: Integer;
begin
Result := FEditorObject.FGrid.Selected;
end;
function TBindListGridEditor.GetColumnIndex: Integer;
begin
Result := FEditorObject.FGrid.ColumnIndex;
end;
procedure TBindListGridEditor.GetColumnIndices(ANames: TStrings);
var
I: Integer;
begin
for I := 0 to FEditorObject.FGrid.ColumnCount - 1 do
ANames.Add(IntToStr(I));
end;
procedure TBindListGridEditor.GetColumnNames(ANames: TStrings);
var
I: Integer;
begin
for I := 0 to FEditorObject.FGrid.ColumnCount - 1 do
ANames.Add(FEditorObject.FGrid.Columns[I].Name);
end;
function TBindListGridEditor.CurrentItem: IScope;
begin
//FEditorObject.FIndex := FEditorObject.FGrid.Row;
if FEditorObject.FIndex = -1 then
FEditorObject.FIndex := GetRowIndex;
Result := WrapObject(FEditorObject);
end;
procedure TBindListGridEditor.BeginUpdate;
begin
//FEditorObject.FGrid
end;
function TBindListGridEditor.CanInsertItem: Boolean;
begin
Result := False; // Not supported
end;
procedure TBindListGridEditor.ClearList;
begin
FEditorObject.FIndex := -1;
if GetFixedRows > 0 then
begin
FEditorObject.FGrid.RowCount := GetFixedRows + 1;
end
else
FEditorObject.FGrid.RowCount := 0;
end;
constructor TBindListGridEditor.Create(AGrid: TGrid);
begin
FEditorObject := TGridItemEditorObject.Create;
FEditorObject.FGrid := AGrid;
FEditorObject.FIndex := -1;
end;
procedure TBindListGridEditor.DeleteToEnd;
begin
if FEditorObject.FIndex = -1 then
FEditorObject.FIndex := GetRowIndex;
if (FEditorObject.FIndex = -1) or (FEditorObject.FIndex = GetFixedRows) then
ClearList
else
FEditorObject.FGrid.RowCount := FEditorObject.FIndex;
end;
destructor TBindListGridEditor.Destroy;
begin
FEditorObject.Free;
inherited;
end;
procedure TBindListGridEditor.EndUpdate;
begin
//FEditorObject.FListBox.Items.EndUpdate;
end;
function TBindListGridEditor.InsertItem(Select: Boolean): IScope;
begin
Result := nil;
end;
function TBindListGridEditor.IsEmpty: Boolean;
begin
Result := (FEditorObject.FGrid.RowCount = GetFixedRows + 1)
end;
function TBindListGridEditor.GetRowCount: Integer;
begin
if IsEmpty then
Result := 0
else
Result := FEditorObject.FGrid.RowCount - GetFixedRows;
end;
function TBindListGridEditor.GetSelectedText: string;
var
LColumn: TColumn;
begin
Result := '';
with FEditorObject do
begin
if GetRowIndex >= GetFixedRows then
if GetColumnIndex >= GetFixedCols then
begin
LColumn := FGrid.Columns[GetColumnIndex];
Result := LColumn.Binding['Text'];
end;
end;
end;
function TBindListGridEditor.MoveNext: Boolean;
begin
if FEditorObject.FGrid.RowCount = 0 then
Exit(False);
if FEditorObject.FIndex = -1 then
FEditorObject.FIndex := GetRowIndex
else
FEditorObject.FIndex := FEditorObject.FIndex + 1;
Result := FEditorObject.FIndex < FEditorObject.FGrid.RowCount;
end;
procedure TBindListGridEditor.SetSelectedText(const AValue: string);
var
LColumn: TColumn;
begin
with FEditorObject do
begin
if GetRowIndex >= GetFixedRows then
if GetColumnIndex >= GetFixedCols then
begin
LColumn := FGrid.Columns[GetColumnIndex];
LColumn.Binding['Text'] := AValue;
end;
end;
end;
{ TGridItemEditorObject }
function TGridItemEditorObject.GetCells(ACol: Integer): string;
var
LColumn: TColumn;
begin
LColumn := FGrid.Columns[ACol];
Result := LColumn.Binding['Text'];
end;
function TGridItemEditorObject.GetOwner: TGrid;
begin
Result := FGrid;
end;
procedure TGridItemEditorObject.SetCells(ACol: Integer;
const Value: string);
var
LColumn: TColumn;
LControl: TStyledControl;
begin
LColumn := FGrid.Columns[ACol];
LControl := LColumn.CellControlByRow(FIndex);
if LControl <> nil then
LControl.Binding['Text'] := Value;
end;
{ TBindCheckBoxEditorFactory }
constructor TBindCheckBoxEditorFactory.Create;
begin
inherited;
end;
function TBindCheckBoxEditorFactory.CreateEditor(AIntf: TGuid;
AObject: TObject): IInterface;
begin
Result := TBindStateCheckBoxEditor.Create(TCheckBox(AObject));
end;
function TBindCheckBoxEditorFactory.Supports(AIntf: TGuid;
AObject: TObject): Boolean;
begin
Result := False;
if AIntf = IBindCheckBoxEditor then
if AObject.InheritsFrom(TCheckBox) then
Result := True;
end;
{ TBindStateCheckBoxEditor }
constructor TBindStateCheckBoxEditor.Create(ACheckBox: TCheckBox);
begin
FCheckBox := ACheckBox;
end;
function TBindStateCheckBoxEditor.GetAllowGrayed: Boolean;
begin
Result := False;
end;
function TBindStateCheckBoxEditor.GetState: TBindCheckBoxState;
begin
// if GetAllowGrayed and FCheckBox.IsGrayed then
// Result := cbGrayed
// else
begin
if FCheckBox.IsChecked then
Result := cbChecked
else
Result := cbUnchecked;
end;
end;
procedure TBindStateCheckBoxEditor.SetAllowGrayed(Value: Boolean);
begin
//Note: FMX CheckBox does not allow Grayed state
assert(False);
end;
procedure TBindStateCheckBoxEditor.SetState(Value: TBindCheckBoxState);
begin
// if (Value = cbGrayed) and GetAllowedGrayed then
// FCheckBox.IsGrayed := cbGrayed
// else
begin
FCheckBox.IsChecked := Value = cbChecked;
end;
end;
{ TComboEditItemEditorObject }
procedure TComboEditItemEditorObject.ControlClear;
begin
FListBox.Items.Clear;
end;
constructor TComboEditItemEditorObject.Create(AListBox: TComboEdit);
begin
FListBox := AListBox;
end;
function TComboEditItemEditorObject.GetControlItemIndex: Integer;
begin
Result := FListBox.ItemIndex;
end;
function TComboEditItemEditorObject.GetControlItems: TStrings;
begin
Result := FListBox.Items;
end;
function TComboEditItemEditorObject.GetOwner: TComboEdit;
begin
Result := FListBox;
end;
function TComboEditItemEditorObject.GetText: string;
begin
Result := FListBox.Items[FIndex];
end;
procedure TComboEditItemEditorObject.SetControlItemIndex(AIndex: Integer);
begin
FListBox.ItemIndex := AIndex;
end;
procedure TComboEditItemEditorObject.SetText(const Value: string);
begin
FListBox.Items[FIndex] := Value;
end;
initialization
RegisterBindEditorFactory([TBindListBoxEditorFactory, TBindComboBoxEditorFactory,
TBindStringGridEditorFactory, TBindGridEditorFactory, TBindCheckBoxEditorFactory,
TBindComboEditEditorFactory]);
finalization
UnregisterBindEditorFactory([TBindListBoxEditorFactory, TBindComboBoxEditorFactory,
TBindStringGridEditorFactory, TBindGridEditorFactory, TBindCheckBoxEditorFactory,
TBindComboEditEditorFactory]);
end.
|
unit NtUtils.Exec.Nt;
interface
uses
NtUtils.Exec, NtUtils.Exceptions;
type
TExecRtlCreateUserProcess = class(TExecMethod)
class function Supports(Parameter: TExecParam): Boolean; override;
class function Execute(ParamSet: IExecProvider; out Info: TProcessInfo):
TNtxStatus; override;
end;
implementation
uses
Ntapi.ntdef, Ntapi.ntrtl, Ntapi.ntpsapi, Ntapi.ntobapi,
Winapi.ProcessThreadsApi, Ntapi.ntseapi, NtUtils.Objects;
function RefStr(const Str: UNICODE_STRING; Present: Boolean): PUNICODE_STRING;
inline;
begin
if Present then
Result := @Str
else
Result := nil;
end;
{ TExecRtlCreateUserProcess }
class function TExecRtlCreateUserProcess.Execute(ParamSet: IExecProvider;
out Info: TProcessInfo): TNtxStatus;
var
hToken, hParent: THandle;
ProcessParams: PRtlUserProcessParameters;
ProcessInfo: TRtlUserProcessInformation;
NtImageName, CurrDir, CmdLine, Desktop: UNICODE_STRING;
begin
// Convert the filename to native format
Result.Location := 'RtlDosPathNameToNtPathName_U_WithStatus';
Result.Status := RtlDosPathNameToNtPathName_U_WithStatus(
PWideChar(ParamSet.Application), NtImageName, nil, nil);
if not Result.IsSuccess then
Exit;
CmdLine.FromString(PrepareCommandLine(ParamSet));
if ParamSet.Provides(ppCurrentDirectory) then
CurrDir.FromString(ParamSet.CurrentDircetory);
if ParamSet.Provides(ppDesktop) then
Desktop.FromString(ParamSet.Desktop);
// Construct parameters
Result.Location := 'RtlCreateProcessParametersEx';
Result.Status := RtlCreateProcessParametersEx(
ProcessParams,
NtImageName,
nil,
RefStr(CurrDir, ParamSet.Provides(ppCurrentDirectory)),
@CmdLine,
nil,
nil,
RefStr(Desktop, ParamSet.Provides(ppDesktop)),
nil,
nil,
0
);
if not Result.IsSuccess then
begin
RtlFreeUnicodeString(NtImageName);
Exit;
end;
if ParamSet.Provides(ppShowWindowMode) then
begin
ProcessParams.WindowFlags := STARTF_USESHOWWINDOW;
ProcessParams.ShowWindowFlags := ParamSet.ShowWindowMode;
end;
if ParamSet.Provides(ppToken) and Assigned(ParamSet.Token) then
hToken := ParamSet.Token.Handle
else
hToken := 0;
if ParamSet.Provides(ppParentProcess) and Assigned(ParamSet.ParentProcess) then
hParent := ParamSet.ParentProcess.Handle
else
hParent := 0;
// Create the process
Result.Location := 'RtlCreateUserProcess';
Result.LastCall.ExpectedPrivilege := SE_ASSIGN_PRIMARY_TOKEN_PRIVILEGE;
Result.Status := RtlCreateUserProcess(
NtImageName,
OBJ_CASE_INSENSITIVE,
ProcessParams,
nil,
nil,
hParent,
ParamSet.Provides(ppInheritHandles) and ParamSet.InheritHandles,
0,
hToken,
ProcessInfo
);
RtlDestroyProcessParameters(ProcessParams);
RtlFreeUnicodeString(NtImageName);
if not Result.IsSuccess then
Exit;
// The process was created in a suspended state.
// Resume it unless the caller explicitly states it should stay suspended.
if not ParamSet.Provides(ppCreateSuspended) or
not ParamSet.CreateSuspended then
NtResumeThread(ProcessInfo.Thread, nil);
with Info do
begin
ClientId := ProcessInfo.ClientId;
hxProcess := TAutoHandle.Capture(ProcessInfo.Process);
hxThread := TAutoHandle.Capture(ProcessInfo.Thread);
end;
end;
class function TExecRtlCreateUserProcess.Supports(Parameter: TExecParam):
Boolean;
begin
case Parameter of
ppParameters, ppCurrentDirectory, ppDesktop, ppToken, ppParentProcess,
ppInheritHandles, ppCreateSuspended, ppShowWindowMode:
Result := True;
else
Result := False;
end;
end;
end.
|
unit Financas.Controller.Connections.Interfaces;
interface
uses Financas.Model.Connections.Interfaces;
type
iControllerFactoryConnection = interface
['{5EBF8D54-0A15-4A32-A123-D78C2DEF7E98}']
function Connection : iModelConnection;
end;
iControllerFactoryDataSet = interface
['{549A7119-DBF9-4141-B3A6-6325E54CC9B7}']
function DataSet(Connection : iModelConnection) : iModelDataSet;
end;
implementation
end.
|
{
Copyright (C) 2005 Fabio Almeida
fabiorecife@yahoo.com.br
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Autor : Jose Fabio Nascimento de Almeida
Data : 7/11/2005
}
unit uJSON;
interface
uses
{Windows,}SysUtils, Classes, TypInfo;
Type
TZAbstractObject = class
function equals(const Value: TZAbstractObject): Boolean; virtual;
function hash: LongInt;
function Clone: TZAbstractObject; virtual;
function toString: string; virtual;
function instanceOf(const Value: TZAbstractObject): Boolean;
class function getInt(o: TZAbstractObject; DefaultValue: Integer):Integer;
class function getDouble(o: TZAbstractObject; DefaultValue: Double):Double;
class function getBoolean(o: TZAbstractObject; DefaultValue: Boolean):Boolean;
end;
ClassCastException = class (Exception) end;
NoSuchElementException = class (Exception) end;
NumberFormatException = class (Exception) end;
NullPointerException = class (Exception) end;
NotImplmentedFeature = class (Exception) end;
JSONArray = class ;
_Number = class ;
_String = class;
_Double = class;
_NULL = class ;
ParseException = class (Exception)
constructor create (_message : string ; index : integer);
end;
JSONTokener = class (TZAbstractObject)
public
constructor create (const s: string) ;
procedure back();
class function dehexchar(c : char) :integer;
function more :boolean;
function next() : char; overload ;
function next (c:char ) : char; overload ;
function next (n:integer) : string; overload ;
function nextClean () : char;
function nextString (quote : char) : string;
function nextTo (d : char) : string; overload ;
function nextTo (const delimiters : string) : char; overload ;
function nextValue () : TZAbstractObject ;
procedure skipPast (const _to : string ) ;
function skipTo (_to : char ): char;
function syntaxError (const _message : string) : ParseException;
function toString : string; override;
function unescape (const s : string): string;
private
myIndex : integer;
mySource : string;
end;
JSONObject = class (TZAbstractObject)
private
myHashMap : TStringList;
function GetPropValues(const Key: String): String;
procedure SetPropValues(const Key: String; const Value: String);
procedure SetAsString(const Value: String);
function GetKeyByIndex(index: Integer): String;
procedure SetCascadeValueEx(const Value: String; const Keys: array of String;
StartIdx: Integer);
function GetValByIndex(index: Integer): String;
procedure UpdateByTokener(x: JSONTokener);
function GetValObjByIndex(index: Integer): TZAbstractObject;
public
constructor Create; overload;
constructor Create (jo : JSONObject; sa : array of string); overload;
constructor Create (x : JSONTokener); overload;
constructor Create (map : TStringList); overload;
constructor Create (const s : string); overload;
procedure Clean;
function Clone : TZAbstractObject; override;
function Accumulate (const key : string; value : TZAbstractObject): JSONObject;
function Get (const key : string) : TZAbstractObject;
function GetBoolean (const key : string): boolean;
function GetDouble (const key : string): double;
function GetInt (const key : string): integer;
function GetJSONArray (const key : string) :JSONArray;
function GetJSONObject (const key : string) : JSONObject;
function GetString (const key : string): string;
function Has (const key : string) : boolean;
function IsNull (const key : string) : boolean;
function Keys : TStringList ;
function Length : integer;
function Names : JSONArray;
class function NumberToString (n: _Number): string;
class function ValueToString(value : TZAbstractObject) : string; overload;
class function ValueToString(value : TZAbstractObject;
indentFactor, indent : integer) : string; overload;
function Opt (const key : string) : TZAbstractObject;
function OptBoolean (const key : string): boolean; overload;
function OptBoolean (const key : string; defaultValue : boolean): boolean; overload;
function OptDouble (const key : string): double; overload;
function OptDouble (const key : string; defaultValue : double): double; overload;
function OptInt (const key : string): integer; overload;
function OptInt (const key : string; defaultValue : integer): integer; overload;
function OptString (const key : string): string; overload;
function OptString (const key, defaultValue : string): string; overload;
function OptJSONArray (const key : string): JSONArray; overload;
function OptJSONObject (const key : string): JSONObject; overload;
function Put (const key : string; value : boolean): JSONObject; overload;
function Put (const key : string; value : double): JSONObject; overload;
function Put (const key : string; value : integer): JSONObject; overload;
function Put (const key : string; const value : string): JSONObject; overload;
function Put (const key : string; value : TZAbstractObject): JSONObject; overload;
function PutOpt (const key : string; value : TZAbstractObject): JSONObject;
class function quote (const s : string): string;
function Remove (const key : string): TZAbstractObject;
procedure AssignTo(json: JSONObject);
function ToJSONArray (names : JSONArray) : JSONArray;
function ToString (): string ; overload; override;
function ToString2 (indentFactor : integer): string; overload;
function ToString3 (indentFactor, indent : integer): string; overload;
//Add by creation_zy 2008-10-21
property PropValues[const Key: String]:String read GetPropValues write SetPropValues; default;
property KeyByIndex[index: Integer]:String read GetKeyByIndex;
property ValByIndex[index: Integer]:String read GetValByIndex;
property ValObjByIndex[index: Integer]:TZAbstractObject read GetValObjByIndex;
property AsString:String read ToString write SetAsString;
procedure Assign(Source: JSONObject);
function Opt2(key, key2: string): TZAbstractObject;
function OptString2(key, key2 : String; DefaultValue: String=''): String;
function OptInt2(key, key2 : String; DefaultValue: Integer=0): Integer;
function GetCascadeValue(const Keys: array of String): String;
procedure SetCascadeValue(const Value: String; const Keys: array of String);
function GetCascadeValObj(const Keys: array of String): TZAbstractObject;
//procedure MigrateFrom(Source: JSONObject; IgnoreEqual: Boolean=true);
function GetDiffFrom(Source: JSONObject):JSONObject;
procedure Delete(index: Integer);
procedure RemoveByKeyHeader(const Header: String='~');
procedure CleanKey(const Key: String);
function PropCount:Integer;
function KeyByVal(const Value: String):String;
function PartExtract(KeyNames: TStrings; DoRemove: Boolean):JSONObject;
function ExtractAll:JSONObject;
function TryNewJSONArray(const Key: String):JSONArray;
function TryNewJSONObject(const Key: String):JSONObject;
destructor Destroy;override;
class function NULL : _NULL;
end;
JSONArray = class (TZAbstractObject)
public
destructor destroy ; override;
constructor create ; overload;
constructor create (collection : TList); overload;
constructor create (x : JSONTokener); overload;
constructor create (const s : string); overload;
procedure Clean; //by creation_zy 2009-08-19
function Clone : TZAbstractObject; override; //by creation_zy 2008-10-05
function get (index : integer) : TZAbstractObject;
function getBoolean (index : integer) : boolean;
function getDouble (index : integer) : double;
function getInt (index : integer): integer;
function getJSONArray (index : integer) : JSONArray;
function getJSONObject (index : integer) : JSONObject;
function getString (index : integer) : string;
function isNull (index : integer): boolean;
function join (separator : string) : string;
function length : integer;
function opt (index : integer) : TZAbstractObject;
function optBoolean ( index : integer) : boolean; overload;
function optBoolean ( index : integer; defaultValue : boolean) : boolean; overload;
function optDouble (index : integer) : double; overload;
function optDouble (index : integer; defaultValue :double ) : double ; overload;
function optInt (index : integer) : integer; overload;
function optInt (index : integer; defaultValue : integer) : integer; overload;
function optJSONArray (index : integer) : JSONArray ; overload;
function optJSONObject (index : integer) : JSONObject ; overload;
function optString (index : integer) : string; overload;
function optString (index : integer; defaultValue : string) : string; overload;
function put ( value : boolean) : JSONArray; overload ;
function put ( value : double ) : JSONArray; overload ;
function put ( value : integer) : JSONArray; overload ;
function put ( value : TZAbstractObject) : JSONArray; overload ;
function put ( value: string): JSONArray; overload;
function put ( index : integer ; value : boolean): JSONArray; overload ;
function put ( index : integer ; value : double) : JSONArray; overload ;
function put ( index : integer ; value : integer) : JSONArray; overload ;
function put ( index : integer ; value : TZAbstractObject) : JSONArray; overload ;
function put ( index: integer; value: string): JSONArray; overload;
function toJSONObject (names :JSONArray ) : JSONObject ; overload ;
function toString : string; overload; override;
function toString2 (indentFactor : integer) : string; overload;
function toString3 (indentFactor, indent : integer) : string; overload;
function toList () : TList;
function appendJSONArray( value : JSONArray): Integer ; //2008-10-08
private
myArrayList : TList;
end;
_Number = class (TZAbstractObject)
public
function doubleValue : double; virtual; abstract;
function intValue : integer; virtual; abstract;
end;
_Boolean = class (TZAbstractObject)
public
class function _TRUE () : _Boolean;
class function _FALSE () : _Boolean;
class function valueOf (b : boolean) : _Boolean;
constructor create (b : boolean);
function boolValue : Boolean; //By creation_zy 2008-10-06
function toString () : string; override;
function clone :TZAbstractObject; override;
private
fvalue : boolean;
end;
_Double = class (_Number)
constructor create (const s : string); overload;
constructor create (s : _String); overload;
constructor create (d : double); overload;
function doubleValue : double; override;
function intValue : integer; override;
function toString () : string ; override;
class function NaN : double;
function clone :TZAbstractObject; override;
private
fvalue : double;
end;
_Integer = class (_Number)
class function parseInt (const s : string; i : integer): integer; overload;
class function parseInt (s : _String): integer; overload;
class function toHexString (c : char) : string;
constructor create (i : integer); overload;
constructor create (const s : string); overload;
function doubleValue : double; override;
function intValue : integer; override;
function toString () : string; override;
function clone :TZAbstractObject; override;
private
fvalue : integer;
end;
_String = class (TZAbstractObject)
constructor create (const s : string);
function equalsIgnoreCase (const s: string) : boolean;
function Equals(const Value: TZAbstractObject): Boolean; override;
function toString() : string; override;
function clone :TZAbstractObject; override;
private
fvalue : string;
end;
_NULL = class (TZAbstractObject)
function Equals(const Value: TZAbstractObject): Boolean; override;
function toString() : string; override;
end;
function IsConstJSON(Z: TObject):Boolean;
var
gcLista : TList;
CNULL : _NULL;
//Set this var to ture to force unicode char (eg: Chinese...) output in the form of \uXXXX
UnicodeOutput: Boolean=false;
implementation
{$D-}
const
CROTINA_NAO_IMPLEMENTADA :string = 'Not imp';
var
CONST_FALSE : _Boolean;
CONST_TRUE : _Boolean;
//By creation_zy
function IsSimpString(const Str:String):Boolean;
var
i:Integer;
begin
Result:=true;
for i:=1 to Length(Str) do
begin
Result:=Str[i] in ['0'..'9','a'..'z','A'..'Z','_'];
if not Result then exit;
end;
end;
//By creation_zy
function SingleHZToJSONCode(const HZ:String):String;
var
wstr:WideString;
begin
if HZ='' then
begin
Result:='';
exit;
end;
wstr:=WideString(HZ);
Result:='\u'+IntToHex(PWord(@wstr[1])^,4);
end;
//By creation_zy 2009-11-21
function IsConstJSON(Z: TObject):Boolean;
begin
Result:=(Z=CNULL) or (Z=CONST_FALSE) or (Z=CONST_TRUE);
end;
procedure newNotImplmentedFeature () ;
begin
raise NotImplmentedFeature.create (CROTINA_NAO_IMPLEMENTADA);
end;
function getFormatSettings : TFormatSettings ;
var
f : TFormatSettings;
begin
{$IFDEF MSWINDOWS}
//SysUtils.GetLocaleFormatSettings (Windows.GetThreadLocale,f);
F := SysUtils.TFormatSettings.Create();
{$ELSE}
//newNotImplmentedFeature();
F := SysUtils.TFormatSettings.Create();
{$ENDIF}
Result := f;
Result.DecimalSeparator := '.';
Result.ThousandSeparator := ',';
end;
function HexToInt(S: String): Integer;
var
I, E, F, G: Integer;
function DigitValue(C: Char): Integer;
begin
case C of
'A': Result := 10;
'B': Result := 11;
'C': Result := 12;
'D': Result := 13;
'E': Result := 14;
'F': Result := 15;
else
Result := StrToInt(C);
end;
end;
begin
S := UpperCase(S);
if S[1] = '$' then Delete(S, 1, 1);
if S[2] = 'X' then Delete(S, 1, 2);
E := -1; Result := 0;
for I := Length(S) downto 1 do begin
G := 1; for F := 0 to E do G := G*16;
Result := Result+(DigitValue(S[I])*G);
Inc(E);
end;
end;
{ JSONTokener }
(**
* Construct a JSONTokener from a string.
*
* @param s A source string.
*)
constructor JSONTokener.create(const s: string);
begin
self.myIndex := 1;
self.mySource := s;
end;
(**
* Back up one character. This provides a sort of lookahead capability,
* so that you can test for a digit or letter before attempting to parse
* the next number or identifier.
*)
procedure JSONTokener.back;
begin
if (self.myIndex > 1) then begin
self.myIndex := self.myIndex - 1;
end;
end;
(**
* Get the hex value of a character (base16).
* @param c A character between '0' and '9' or between 'A' and 'F' or
* between 'a' and 'f'.
* @return An int between 0 and 15, or -1 if c was not a hex digit.
*)
class function JSONTokener.dehexchar(c: char): integer;
begin
if ((c >= '0') and (c <= '9')) then begin
Result := (ord(c) - ord('0'));
exit;
end;
if ((c >= 'A') and (c <= 'F')) then begin
Result := (ord(c) + 10 - ord('A'));
exit;
end;
if ((c >= 'a') and (c <= 'f')) then begin
Result := ord(c) + 10 - ord('a');
exit;
end;
Result := -1;
end;
(**
* Determine if the source string still contains characters that next()
* can consume.
* @return true if not yet at the end of the source.
*)
function JSONTokener.more: boolean;
begin
Result := self.myIndex <= System.length(self.mySource)+1;
end;
function JSONTokener.next: char;
begin
if (more()) then
begin
Result := self.mySource[self.myIndex];
self.myIndex := self.myIndex + 1;
exit;
end;
Result := chr(0);
end;
(**
* Consume the next character, and check that it matches a specified
* character.
* @param c The character to match.
* @return The character.
* @throws ParseException if the character does not match.
*)
function JSONTokener.next(c: char): char;
begin
Result := next();
if (Result <> c) then
begin
raise syntaxError('Expected ' + c + ' and instead saw ' +
Result + '.');
end;
end;
(**
* Get the next n characters.
*
* @param n The number of characters to take.
* @return A string of n characters.
* @exception ParseException
* Substring bounds error if there are not
* n characters remaining in the source string.
*)
function JSONTokener.next(n: integer): string;
var
i,j : integer;
begin
i := self.myIndex;
j := i + n;
if (j > System.length(self.mySource)) then begin
raise syntaxError('Substring bounds error');
end;
self.myIndex := self.myIndex + n;
Result := copy (self.mySource,i,n); //substring(i, j)
end;
(**
* Get the next char in the string, skipping whitespace
* and comments (slashslash, slashstar, and hash).
* @throws ParseException
* @return A character, or 0 if there are no more characters.
*)
function JSONTokener.nextClean: char;
var
c: char;
begin
while (true) do begin
c := next();
if (c = '/') then begin
case (next()) of
'/': begin
repeat
c := next();
until (not ((c <> #10) and (c <> #13) and (c <> #0)));
end ;
'*': begin
while (true) do
begin
c := next();
if (c = #0) then
begin
raise syntaxError('Unclosed comment.');
end;
if (c = '*') then
begin
if (next() = '/') then
begin
break;
end;
back();
end;
end;
end
else begin
back();
Result := '/';
exit;
end;
end;
end else if (c = '#') then begin
repeat
c := next();
until (not ((c <> #10) and (c <> #13) and (c <> #0)));
end else if ((c = #0) or (c > ' ')) then begin
Result := c;
exit;
end;
end; //while
end;
(**
* Return the characters up to the next close quote character.
* Backslash processing is done. The formal JSON format does not
* allow strings in single quotes, but an implementation is allowed to
* accept them.
* @param quote The quoting character, either
* <code>"</code> <small>(double quote)</small> or
* <code>'</code> <small>(single quote)</small>.
* @return A String.
* @exception ParseException Unterminated string.
*)
function JSONTokener.nextString (quote : char): string;
var
c : char;
sb : string;
WCh:WideChar;
begin
sb := '';
while (true) do
begin
c := next();
case (c) of
#0, #10, #13:
begin
raise syntaxError('Unterminated string');
end;
'\':
begin
c := next();
case (c) of
{'b': // � o backspace = #8
sb.append('\b');
break;}
'b': //By creation_zy 2009-08-20
sb := sb + #8;
't':
sb := sb + #9;
'n':
sb := sb + #10;
'f':
sb := sb + #12;
'r':
sb := sb + #13;
{case 'u':
sb.append((char)Integer.parseInt(next(4), 16));
break;
case 'x' : \cx The control character corresponding to x
sb.append((char) Integer.parseInt(next(2), 16));
break;}
'u': //By creation_zy 2009-08-20
begin
PWord(@WCh)^:=Word(HexToInt(next(4)));
sb:=sb+WCh;
end;
else
sb := sb + c
end;
end
else begin
if (c = quote) then
begin
Result := sb;
exit;
end;
sb := sb + c
end;
end;
end;
end;
(**
* Get the text up but not including the specified character or the
* end of line, whichever comes first.
* @param d A delimiter character.
* @return A string.
*)
function JSONTokener.nextTo(d: char): string;
var
sb : string;
c : char;
begin
//c := #0;
sb := '';
while (true) do
begin
c := next();
if ((c = d) or (c = #0) or (c = #10) or (c = #13)) then
begin
if (c <> #0) then
begin
back();
end;
Result := trim (sb);
exit;
end;
sb := sb + c;
end;
end;
(**
* Get the text up but not including one of the specified delimeter
* characters or the end of line, whichever comes first.
* @param delimiters A set of delimiter characters.
* @return A string, trimmed.
*)
function JSONTokener.nextTo(const delimiters: string): char;
var
c : char;
sb : string;
begin
//c := #0;
Result:=#0; //By creation_zy
sb := '';
while (true) do
begin
c := next();
if ((pos (c,delimiters) > 0) or (c = #0) or
(c = #10) or (c = #13)) then
begin
if (c <> #0) then
begin
back();
end;
sb := trim(sb);
if (System.length(sb) > 0) then
Result := sb[1];
exit;
end;
sb := sb + c;
end;
end;
(**
* Get the next value. The value can be a Boolean, Double, Integer,
* JSONArray, JSONObject, or String, or the JSONObject.NULL object.
* @exception ParseException The source does not conform to JSON syntax.
*
* @return An object.
*)
function JSONTokener.nextValue: TZAbstractObject;
var
c, b : char;
s , sb: string;
n:Integer;
begin
c := nextClean();
case (c) of
'"', #39: begin
Result := _String.create (nextString(c));
exit;
end;
'{': begin
back();
Result := JSONObject.create(self);
exit;
end;
'[': begin
back();
Result := JSONArray.create(self);
exit;
end;
end;
(*
* Handle unquoted text. This could be the values true, false, or
* null, or it can be a number. An implementation (such as this one)
* is allowed to also accept non-standard forms.
*
* Accumulate characters until we reach the end of the text or a
* formatting character.
*)
sb := '';
b := c;
while ((ord(c) >= ord(' ')) and (pos (c,',:]}/\\\"[{;=#') = 0)) do begin
sb := sb + c;
c := next();
end;
back();
(*
* If it is true, false, or null, return the proper value.
*)
s := trim (sb);
n:=System.Length(s);
if n=0 then begin
raise syntaxError('Missing value.');
end;
if n in [4,5] then //2009-09-14 Length limit before AnsiLowerCase. By creation_zy
begin
sb:=AnsiLowerCase(s);
if (sb = 'true') then
begin
Result := _Boolean._TRUE;
exit;
end;
if (sb = 'false') then
begin
Result := _Boolean._FALSE;
exit;
end;
if (sb = 'null') then
begin
Result := JSONObject.NULL;
exit;
end;
end;
(*
* If it might be a number, try converting it. We support the 0- and 0x-
* conventions. If a number cannot be produced, then the value will just
* be a string. Note that the 0-, 0x-, plus, and implied string
* conventions are non-standard. A JSON parser is free to accept
* non-JSON forms as long as it accepts all correct JSON forms.
*)
if ( ((b >= '0') and (b <= '9')) or (b = '.')
or (b = '-') or (b = '+')) then
begin
if (b = '0') then begin
if ( (System.length(s) > 2) and
((s[2] = 'x') or (s[2] = 'X') ) ) then
begin
try
Result := _Integer.create(_Integer.parseInt(copy(s,3,System.length(s)),16));
exit;
Except
on e:Exception do begin
///* Ignore the error */
end;
end;
end else begin
try
if (System.length(s) >= 2) and (s[2]='.') then //2009-09-14 By creation_zy
Result := _Double.create(s)
else
Result := _Integer.create(_Integer.parseInt(s,8));
exit;
Except
on e:Exception do begin
///* Ignore the error */
end;
end;
end;
end;
if Pos('.',s)<0 then
try
Result := _Integer.create(s);
exit;
Except
on e:Exception do begin
///* Ignore the error */
end;
end;
try
Result := _Double.create(s);
exit;
Except
on e:Exception do begin
///* Ignore the error */
end;
end;
end;
Result := _String.create(s);
end;
(**
* Skip characters until the next character is the requested character.
* If the requested character is not found, no characters are skipped.
* @param to A character to skip to.
* @return The requested character, or zero if the requested character
* is not found.
*)
function JSONTokener.skipTo(_to: char): char;
var
c : char;
index : integer;
begin
index := self.myIndex;
repeat
c := next();
if (c = #0) then begin
self.myIndex := index;
Result := c;
exit;
end;
until (not (c <> _to));
back();
Result := c;
exit;
end;
(**
* Skip characters until past the requested string.
* If it is not found, we are left at the end of the source.
* @param to A string to skip past.
*)
procedure JSONTokener.skipPast(const _to: string);
begin
self.myIndex := pos (_to, copy(mySource, self.myIndex, System.length(mySource)));
if (self.myIndex < 0) then begin
self.myIndex := System.length(self.mySource)+1;
end else begin
self.myIndex := self.myIndex + System.length(_to);
end;
end;
(**
* Make a ParseException to signal a syntax error.
*
* @param message The error message.
* @return A ParseException object, suitable for throwing
*)
function JSONTokener.syntaxError(const _message: string): ParseException;
begin
Result := ParseException.create (_message + toString()+' postion : ' //' pr�imo a : '
+ copy (toString(),self.myIndex,10), self.myIndex);
end;
(**
* Make a printable string of this JSONTokener.
*
* @return " at character [this.myIndex] of [this.mySource]"
*)
function JSONTokener.toString: string;
begin
Result := ' at character ' + intToStr(self.myIndex) + ' of ' + self.mySource;
end;
(**
* Convert <code>%</code><i>hh</i> sequences to single characters, and
* convert plus to space.
* @param s A string that may contain
* <code>+</code> <small>(plus)</small> and
* <code>%</code><i>hh</i> sequences.
* @return The unescaped string.
*)
function JSONTokener.unescape(const s: string): string;
var
len, i,d,e : integer;
b : string;
c : char;
begin
len := System.length(s);
b := '';
i := 1;
while ( i <= len ) do begin
c := s[i];
if (c = '+') then begin
c := ' ';
end else if ((c = '%') and ((i + 2) <= len)) then begin
d := dehexchar(s[i + 1]);
e := dehexchar(s[i + 2]);
if ((d >= 0) and (e >= 0)) then begin
c := chr(d * 16 + e);
i := i + 2;
end;
end;
b := b + c;
i := i + 1;
end;
Result := b ;
end;
{ JSONObject }
(**
* Construct an empty JSONObject.
*)
constructor JSONObject.create;
begin
myHashMap := TStringList.create;
end;
(**
* Construct a JSONObject from a subset of another JSONObject.
* An array of strings is used to identify the keys that should be copied.
* Missing keys are ignored.
* @param jo A JSONObject.
* @param sa An array of strings.
*)
constructor JSONObject.create(jo: JSONObject; sa: array of string);
var
i : integer;
begin
create();
for i:=low(sa) to high(sa) do
putOpt(sa[i], jo.opt(sa[i]).Clone);
end;
(**
* Construct a JSONObject from a JSONTokener.
* @param x A JSONTokener object containing the source string.
* @throws ParseException if there is a syntax error in the source string.
*)
constructor JSONObject.create(x: JSONTokener);
begin
create ;
UpdateByTokener(x);
end;
(**
* Construct a JSONObject from a Map.
* @param map A map object that can be used to initialize the contents of
* the JSONObject.
*)
constructor JSONObject.create(map: TStringList);
var
i : integer;
begin
myHashMap := TStringlist.create;
for i := 0 to map.Count -1 do
myHashMap.AddObject(map[i],map.Objects[i]);
end;
(**
* Construct a JSONObject from a string.
* This is the most commonly used JSONObject constructor.
* @param string A string beginning
* with <code>{</code> <small>(left brace)</small> and ending
* with <code>}</code> <small>(right brace)</small>.
* @exception ParseException The string must be properly formatted.
*)
constructor JSONObject.create(const s: string);
var
token : JSOnTokener;
begin
if s='' then //Add by creation_zy 2008-10-21
begin
create();
exit;
end;
token := JSONTokener.create(s);
try
create(token);
finally
token.free;
end;
end;
(**
* Accumulate values under a key. It is similar to the put method except
* that if there is already an object stored under the key then a
* JSONArray is stored under the key to hold all of the accumulated values.
* If there is already a JSONArray, then the new value is appended to it.
* In contrast, the put method replaces the previous value.
* @param key A key string.
* @param value An object to be accumulated under the key.
* @return this.
* @throws NullPointerException if the key is null
*)
function JSONObject.accumulate(const key: string; value: TZAbstractObject): JSONObject;
var
a : JSONArray;
o : TZAbstractObject;
begin
o := opt(key);
if (o = nil) then
put(key, value)
else if (o is JSONArray) then
begin
a := JSONArray(o);
a.put(value);
end
else begin
a:=JSONArray.create;
a.put(o.clone);
a.put(value);
put(key, a);
end;
Result := self;
end;
(**
* Get the value object associated with a key.
*
* @param key A key string.
* @return The object associated with the key.
* @exception NoSuchElementException if the key is not found.
*)
function JSONObject.get(const key: string): TZAbstractObject;
var
o : TZAbstractObject;
begin
o := opt(key);
if (o = nil) then
raise NoSuchElementException.create('JSONObject['+quote(key)+'] not found.');
Result := o;
end;
(**
* Get the boolean value associated with a key.
*
* @param key A key string.
* @return The truth.
* @exception NoSuchElementException if the key is not found.
* @exception ClassCastException
* if the value is not a Boolean or the String "true" or "false".
*)
function JSONObject.getBoolean(const key: string): boolean;
var
o : TZAbstractObject;
begin
o := get(key);
if (o.equals(_Boolean._FALSE) or
((o is _String) and
(_String(o)).equalsIgnoreCase('false'))) then begin
Result := false;
exit;
end else if (o.equals(_Boolean._TRUE) or
((o is _String) and
(_String(o)).equalsIgnoreCase('true'))) then begin
Result := true;
exit;
end;
raise ClassCastException.create('JSONObject[' +
quote(key) + '] is not a Boolean.');
end;
function JSONObject.getDouble(const key: string): double;
var
o : TZAbstractObject;
begin
o := get(key);
if (o is _Number) then
begin
Result := _Number (o).doubleValue();
exit;
end ;
if (o is _String) then
begin
Result := StrToFloat (_String(o).toString(), getFormatSettings());
exit;
end;
raise NumberFormatException.create('JSONObject['+quote(key)+'] is not a number.');
end;
(**
* Get the int value associated with a key.
*
* @param key A key string.
* @return The integer value.
* @exception NoSuchElementException if the key is not found
* @exception NumberFormatException
* if the value cannot be converted to a number.
*)
function JSONObject.getInt(const key: string): integer;
var
o : TZAbstractObject;
begin
o := get(key);
if (o is _Number) then begin
Result := _Number(o).intValue();
end else begin
Result := Round(getDouble(key));
end;
end;
(**
* Get the JSONArray value associated with a key.
*
* @param key A key string.
* @return A JSONArray which is the value.
* @exception NoSuchElementException if the key is not found or
* if the value is not a JSONArray.
*)
function JSONObject.getJSONArray(const key: string): JSONArray;
var
o : TZAbstractObject;
begin
o := get(key);
if (o is JSONArray) then begin
Result := JSONArray(o);
end else begin
raise NoSuchElementException.create('JSONObject[' +
quote(key) + '] is not a JSONArray.');
end;
end;
(**
* Get the JSONObject value associated with a key.
*
* @param key A key string.
* @return A JSONObject which is the value.
* @exception NoSuchElementException if the key is not found or
* if the value is not a JSONObject.
*)
function JSONObject.getJSONObject(const key: string): JSONObject;
var
o : TZAbstractObject;
begin
o := get(key);
if (o is JSONObject) then begin
Result := JSONObject(o);
end else begin
raise NoSuchElementException.create('JSONObject[' +
quote(key) + '] is not a JSONObject.');
end;
end;
(**
* Get the string associated with a key.
*
* @param key A key string.
* @return A string which is the value.
* @exception NoSuchElementException if the key is not found.
*)
function JSONObject.getString(const key: string): string;
begin
Result := get(key).toString();
end;
(**
* Determine if the JSONObject contains a specific key.
* @param key A key string.
* @return true if the key exists in the JSONObject.
*)
function JSONObject.has(const key: string): boolean;
begin
Result := myHashMap.IndexOf(key)>=0;
end;
(**
* Determine if the value associated with the key is null or if there is
* no value.
* @param key A key string.
* @return true if there is no value associated with the key or if
* the value is the JSONObject.NULL object.
*)
function JSONObject.isNull(const key: string): boolean;
begin
Result := NULL.equals(opt(key));
end;
function JSONObject.keys: TStringList;
var
i : integer;
begin
Result := TStringList.Create;
for i := 0 to myHashMap.Count -1 do begin
Result.add (myHashMap[i]);
end;
end;
function JSONObject.length: integer;
begin
Result := myHashMap.Count;
end;
(**
* Produce a JSONArray containing the names of the elements of this
* JSONObject.
* @return A JSONArray containing the key strings, or null if the JSONObject
* is empty.
*)
function JSONObject.names: JSONArray;
var
ja :JSONArray;
i : integer;
k : TStringList;
begin
ja := JSONArray.create;
k := keys;
try
for i := 0 to k.Count -1 do begin
ja.put (_String.create (k[i]));
end;
if (ja.length = 0) then begin
Result := nil;
end else begin
Result := ja;
end;
finally
k.free;
end;
end;
class function JSONObject.numberToString(n: _Number): string;
begin
if (n = nil) then begin
Result := '';
end else if (n is _Integer) then begin
Result := IntToStr(n.intValue)
end else begin
Result := FloatToStr (n.doubleValue, getFormatSettings());
end;
end;
(**
* Get an optional value associated with a key.
* @param key A key string.
* @return An object which is the value, or null if there is no value.
* @exception NullPointerException The key must not be null.
*)
function JSONObject.opt(const key: string): TZAbstractObject;
var
i:Integer;
begin
{if (key = '') then
raise NullPointerException.create('Null key')
else begin}
i:=myHashMap.IndexOf(key);
if i<0 then
Result:=nil
else
Result:=TZAbstractObject(myHashMap.Objects[i]);
//end;
end;
function JSONObject.Opt2(key, key2: string): TZAbstractObject;
var
i:Integer;
begin
i:=myHashMap.IndexOf(key);
if i<0 then
i:=myHashMap.IndexOf(key2);
if i<0 then
Result:=nil
else
Result:=TZAbstractObject(myHashMap.Objects[i]);
end;
(**
* Get an optional boolean associated with a key.
* It returns false if there is no such key, or if the value is not
* Boolean.TRUE or the String "true".
*
* @param key A key string.
* @return The truth.
*)
function JSONObject.optBoolean(const key: string): boolean;
begin
Result := optBoolean (key, false);
end;
(**
* Get an optional boolean associated with a key.
* It returns the defaultValue if there is no such key, or if it is not
* a Boolean or the String "true" or "false" (case insensitive).
*
* @param key A key string.
* @param defaultValue The default.
* @return The truth.
*)
function JSONObject.optBoolean(const key: string;
defaultValue: boolean): boolean;
var
o : TZAbstractObject;
begin
o := opt(key);
if (o <> nil) then
begin
if o.ClassType=_Boolean then //2009-03-06 By creation_zy
begin
Result:=_Boolean(o).fvalue;
exit;
end
else if //o.equals(_Boolean._FALSE) or
((o is _String) and
(_String(o).equalsIgnoreCase('false'))) then begin
Result := false;
exit;
end
else if //o.equals(_Boolean._TRUE) or
((o is _String) and
(_String(o).equalsIgnoreCase('true'))) then begin
Result := true;
exit;
end;
end;
Result := defaultValue;
end;
(**
* Get an optional double associated with a key,
* or NaN if there is no such key or if its value is not a number.
* If the value is a string, an attempt will be made to evaluate it as
* a number.
*
* @param key A string which is the key.
* @return An object which is the value.
*)
function JSONObject.optDouble(const key: string): double;
begin
Result := optDouble(key, _Double.NaN);
end;
(**
* Get an optional double associated with a key, or the
* defaultValue if there is no such key or if its value is not a number.
* If the value is a string, an attempt will be made to evaluate it as
* a number.
*
* @param key A key string.
* @param defaultValue The default.
* @return An object which is the value.
*)
function JSONObject.optDouble(const key: string; defaultValue: double): double;
var
o : TZAbstractObject;
begin
o := opt(key);
if (o <> nil) then begin
if (o is _Number) then begin
Result := (_Number(o)).doubleValue();
exit;
end ;
try
Result := _Double.create(_String(o)).doubleValue();
exit;
except on e:Exception do begin
Result := defaultValue;
exit;
end;
end;
end;
Result := defaultValue;
end;
(**
* Get an optional int value associated with a key,
* or zero if there is no such key or if the value is not a number.
* If the value is a string, an attempt will be made to evaluate it as
* a number.
*
* @param key A key string.
* @return An object which is the value.
*)
function JSONObject.optInt(const key: string): integer;
begin
Result := optInt (key, 0);
end;
(**
* Get an optional int value associated with a key,
* or the default if there is no such key or if the value is not a number.
* If the value is a string, an attempt will be made to evaluate it as
* a number.
*
* @param key A key string.
* @param defaultValue The default.
* @return An object which is the value.
*)
function JSONObject.optInt(const key: string; defaultValue: integer): integer;
var
o : TZAbstractObject;
begin
o := opt(key);
if (o <> null) and ( o <> nil ) then //By creation_zy. Add compare to nil
begin
if (o is _Number) then
begin
Result := (_Number(o)).intValue();
exit;
end;
try
Result := _Integer.parseInt(_String(o));
except
on e:Exception do
begin
Result := defaultValue;
end;
end;
end
else //By creation_zy
Result := defaultValue;
end;
function JSONObject.OptInt2(key, key2: String; DefaultValue: Integer): Integer;
var
o:TZAbstractObject;
begin
o:=Opt2(key,key2);
if o<>nil then
Result:=TZAbstractObject.getInt(o,DefaultValue)
else
Result:=DefaultValue;
end;
(**
* Get an optional JSONArray associated with a key.
* It returns null if there is no such key, or if its value is not a
* JSONArray.
*
* @param key A key string.
* @return A JSONArray which is the value.
*)
function JSONObject.optJSONArray(const key: string): JSONArray;
var
o : TZAbstractObject ;
begin
o := opt(key);
if (o is JSONArray) then begin
Result := JSONArray(o);
end else begin
Result := nil;
end;
end;
(**
* Get an optional JSONObject associated with a key.
* It returns null if there is no such key, or if its value is not a
* JSONObject.
*
* @param key A key string.
* @return A JSONObject which is the value.
*)
function JSONObject.optJSONObject(const key: string): JSONObject;
var
o : TZAbstractObject ;
begin
o := opt(key);
if (o is JSONObject) then begin
Result := JSONObject(o);
end else begin
Result := nil;
end;
end;
(**
* Get an optional string associated with a key.
* It returns an empty string if there is no such key. If the value is not
* a string and is not null, then it is coverted to a string.
*
* @param key A key string.
* @return A string which is the value.
*)
function JSONObject.optString(const key: string): string;
begin
Result := optString(key, '');
end;
(**
* Get an optional string associated with a key.
* It returns the defaultValue if there is no such key.
*
* @param key A key string.
* @param defaultValue The default.
* @return A string which is the value.
*)
function JSONObject.optString(const key, defaultValue: string): string;
var
o : TZAbstractObject ;
begin
o := Opt(key);
if (o <> nil) then begin
Result := o.toString();
end else begin
Result := defaultValue;
end;
end;
function JSONObject.OptString2(key, key2: String; DefaultValue: String): String;
var
o:TZAbstractObject;
begin
o:=Opt2(key,key2);
if o<>nil then
Result:=o.toString()
else
Result:=DefaultValue;
end;
(**
* Put a key/boolean pair in the JSONObject.
*
* @param key A key string.
* @param value A boolean which is the value.
* @return this.
*)
function JSONObject.put(const key: string; value: boolean): JSONObject;
begin
put(key, _Boolean.valueOf(value));
Result := self;
end;
(**
* Put a key/double pair in the JSONObject.
*
* @param key A key string.
* @param value A double which is the value.
* @return this.
*)
function JSONObject.put(const key: string; value: double): JSONObject;
begin
put(key, _Double.create(value));
Result := self;
end;
(**
* Put a key/int pair in the JSONObject.
*
* @param key A key string.
* @param value An int which is the value.
* @return this.
*)
function JSONObject.put(const key: string; value: integer): JSONObject;
begin
put(key, _Integer.create(value));
Result := self;
end;
(**
* Put a key/value pair in the JSONObject. If the value is null,
* then the key will be removed from the JSONObject if it is present.
* @param key A key string.
* @param value An object which is the value. It should be of one of these
* types: Boolean, Double, Integer, JSONArray, JSONObject, String, or the
* JSONObject.NULL object.
* @return this.
* @exception NullPointerException The key must be non-null.
*)
function JSONObject.put(const key: string; value: TZAbstractObject): JSONObject;
var
temp : TObject;
i : integer;
begin
if (key = '') then
begin
raise NullPointerException.create('Null key.');
end ;
if (value <> nil) then
begin
i := myHashMap.IndexOf(key);
if ( i >= 0) then
begin
temp := myHashMap.Objects [i];
myHashMap.Objects[i] := value;
temp.free;
end
else
myHashMap.AddObject(key, value);
end
else begin
temp:=remove(key);
if temp<>nil then
begin
if not IsConstJSON(temp) then //Prevent to free const obj. By craetion_zy 2009-11-21
temp.free;
end;
end;
Result := self;
end;
function JSONObject.put(const key, value: string): JSONObject;
begin
put(key, _String.create(value));
Result := self;
end;
(**
* Put a key/value pair in the JSONObject, but only if the
* value is non-null.
* @param key A key string.
* @param value An object which is the value. It should be of one of these
* types: Boolean, Double, Integer, JSONArray, JSONObject, String, or the
* JSONObject.NULL object.
* @return this.
* @exception NullPointerException The key must be non-null.
*)
function JSONObject.putOpt(const key: string; value: TZAbstractObject): JSONObject;
begin
if (value <> nil) then
put(key, value);
Result := self;
end;
(**
* Produce a string in double quotes with backslash sequences in all the
* right places.
* @param string A String
* @return A String correctly formatted for insertion in a JSON message.
*)
class function JSONObject.quote(const s: string): string;
var
b,c : char;
i, len : integer;
sb, t : string;
begin
if ((s = '') or (System.Length(s) = 0)) then
begin
Result := '""';
exit;
end;
//b := #0;
c := #0;
len := System.length(s);
//SetLength (s, len+4);
t := '';
sb := sb +'"';
i := 1;
while i<=len do
begin
b := c;
c := s[i];
case (c) of
'\', '"':
begin
sb := sb + '\';
sb := sb + c;
end;
'/':
begin
if (b = '<') then
begin
sb := sb + '\';
end;
sb := sb + c;
end;
#8, #9, #10, #12, #13:
begin
sb := sb + c;
end;
else
begin
if (c < ' ') then
begin
t := '000' + _Integer.toHexString(c);
sb := sb + '\u' + copy (t,System.length(t)-3,4);
end
else if UnicodeOutput and (c>#128) and (i<len) then //Unicode output By creation_zy
begin
Inc(i);
sb:=sb+SingleHZToJSONCode(c+s[i]);
end
else begin
sb := sb + c;
end;
end;
end;
Inc(i);
end;
sb := sb + '"';
Result := sb;
end;
(**
* Remove a name and its value, if present.
* @param key The name to be removed.
* @return The value that was associated with the name,
* or null if there was no value.
*)
function JSONObject.Remove(const key: string): TZAbstractObject;
var
i:Integer;
begin
i:=myHashMap.IndexOf(key);
if i<0 then
Result:=nil
else begin
Result:=TZAbstractObject(myHashMap.Objects[i]);
myHashMap.delete(i);
end;
end;
(**
* Produce a JSONArray containing the values of the members of this
* JSONObject.
* @param names A JSONArray containing a list of key strings. This
* determines the sequence of the values in the Result.
* @return A JSONArray of values.
*)
function JSONObject.toJSONArray(names: JSONArray): JSONArray;
var
i : integer;
ja : JSONArray ;
begin
if ((names = nil) or (names.length() = 0)) then begin
Result := nil;
exit;
end;
ja := JSONArray.create;
for i := 0 to names.length -1 {; i < names.length(); i += 1)} do begin
ja.put(self.opt(names.getString(i)));
end;
Result := ja;
end;
(**
* Make an JSON external form string of this JSONObject. For compactness, no
* unnecessary whitespace is added.
* <p>
* Warning: This method assumes that the data structure is acyclical.
*
* @return a printable, displayable, portable, transmittable
* representation of the object, beginning
* with <code>{</code> <small>(left brace)</small> and ending
* with <code>}</code> <small>(right brace)</small>.
*)
function JSONObject.toString: string;
var
_keys : TStringList;
sb : string;
o : string;
i :integer;
begin
_keys := keys();
try
sb := '{';
for i := 0 to _keys.count -1 do
begin
if (System.length(sb) > 1) then
begin
sb:= sb + ',';
end;
o := _keys[i];
if IsSimpString(o) then //By creation_zy
sb := sb + o
else
sb := sb + quote(o);
sb := sb + ':';
sb:= sb + valueToString(TZAbstractObject(myHashMap.Objects[myHashMap.IndexOf(o)]));
end;
sb := sb + '}';
Result := sb;
finally
_keys.free;
end;
end;
(**
* Make a prettyprinted JSON external form string of this JSONObject.
* <p>
* Warning: This method assumes that the data structure is acyclical.
* @param indentFactor The number of spaces to add to each level of
* indentation.
* @return a printable, displayable, portable, transmittable
* representation of the object, beginning
* with <code>{</code> <small>(left brace)</small> and ending
* with <code>}</code> <small>(right brace)</small>.
*)
function JSONObject.toString2(indentFactor: integer): string;
begin
Result := toString3(indentFactor, 0);
end;
(**
* Make a prettyprinted JSON string of this JSONObject.
* <p>
* Warning: This method assumes that the data structure is acyclical.
* @param indentFactor The number of spaces to add to each level of
* indentation.
* @param indent The indentation of the top level.
* @return a printable, displayable, transmittable
* representation of the object, beginning
* with <code>{</code> <small>(left brace)</small> and ending
* with <code>}</code> <small>(right brace)</small>.
*)
function JSONObject.toString3(indentFactor, indent: integer): string;
var
j , i , n , newindent: integer;
_keys : TStringList;
o, sb : string;
begin
//i := 0;
n := length();
if (n = 0) then begin
Result := '{}';
exit;
end;
_keys := keys();
try
sb := sb + '{';
newindent := indent + indentFactor;
if (n = 1) then
begin
o := _keys[0];
sb:= sb + quote(o);
sb:= sb + ': ';
sb:= sb + valueToString(TZAbstractObject(myHashMap
.Objects[myHashMap.IndexOf(o)])
, indentFactor, indent);
end
else begin
for j := 0 to _keys.count -1 do
begin
o := _keys[j];
if (System.length(sb) > 1) then
begin
sb := sb + ','+ #10;
end
else begin
sb:= sb + #10;
end;
for i := 0 to newindent -1 do
begin
sb:= sb + ' ';
end;
sb:= sb + quote(o);
sb:= sb + ': ';
sb:= sb + valueToString(TZAbstractObject(myHashMap
.Objects[myHashMap.IndexOf(o)])
, indentFactor, newindent);
end;
if (System.length(sb) > 1) then
begin
sb := sb + #10;
for i := 0 to indent -1 do
begin
sb:= sb + ' ';
end;
end;
end;
sb:= sb + '}';
Result := sb;
finally
_keys.Free; //Memory leak fixed. By creation_zy 2009-08-03
end;
end;
class function JSONObject.NULL: _NULL;
begin
Result := CNULL;
end;
(**
* Make JSON string of an object value.
* <p>
* Warning: This method assumes that the data structure is acyclical.
* @param value The value to be serialized.
* @return a printable, displayable, transmittable
* representation of the object, beginning
* with <code>{</code> <small>(left brace)</small> and ending
* with <code>}</code> <small>(right brace)</small>.
*)
class function JSONObject.valueToString(value: TZAbstractObject): string;
begin
if ((value = nil) or (value.equals(null))) then begin
Result := 'null';
exit;
end;
if (value is _Number) then begin
Result := numberToString(_Number(value));
exit;
end;
if ((value is _Boolean) or (value is JSONObject) or
(value is JSONArray)) then begin
Result := value.toString();
exit;
end;
Result := quote(value.toString());
end;
(**
* Make a prettyprinted JSON string of an object value.
* <p>
* Warning: This method assumes that the data structure is acyclical.
* @param value The value to be serialized.
* @param indentFactor The number of spaces to add to each level of
* indentation.
* @param indent The indentation of the top level.
* @return a printable, displayable, transmittable
* representation of the object, beginning
* with <code>{</code> <small>(left brace)</small> and ending
* with <code>}</code> <small>(right brace)</small>.
*)
class function JSONObject.valueToString(value: TZAbstractObject;
indentFactor, indent: integer): string;
begin
if ((value = nil) or (value.equals(nil))) then begin
Result := 'null';
exit;
end;
if (value is _Number) then begin
Result := numberToString(_Number(value));
exit;
end;
if (value is _Boolean) then begin
Result := value.toString();
exit;
end;
if (value is JSONObject) then begin
Result := ((JSONObject(value)).toString3(indentFactor, indent));
exit;
end;
if (value is JSONArray) then begin
Result := ((JSONArray(value)).toString3(indentFactor, indent));
exit;
end;
Result := quote(value.toString());
end;
procedure JSONObject.clean;
var
i : integer;
MyObj:TObject;
begin
for i:=Pred(myHashMap.Count) downto 0 do
begin
MyObj:=myHashMap.Objects[i];
if (MyObj <> CONST_FALSE) and (MyObj <> CONST_TRUE) and (MyObj <> CNULL) then
MyObj.Free;
end;
myHashMap.Clear;
end;
(**
* Assign the values to other json Object.
* @param JSONObject objeto to assign Values
*)
procedure JSONObject.assignTo (json : JSONObject) ;
var
_keys : TStringList;
i : integer;
begin
_keys := keys;
try
for i := 0 to _keys.Count -1 do
begin
json.put (_keys[i],get(_keys[i]).clone);
end;
finally
_keys.free;
end;
end;
function JSONObject.clone: TZAbstractObject;
begin
Result := JSONObject.create (self.toString());
end;
function JSONObject.GetPropValues(const Key: String): String;
begin
Result:=OptString(Key);
end;
procedure JSONObject.SetPropValues(const Key: String; const Value: String);
begin
Put(Key, Value);
end;
function JSONObject.GetCascadeValue(const Keys: array of String): String;
var
i:Integer;
TmpProp:JSONObject;
begin
Result:='';
TmpProp:=Self;
for i:=Low(Keys) to High(Keys) do
begin
if i=High(Keys) then
begin
Result:=TmpProp.PropValues[Keys[i]];
exit;
end;
TmpProp:=TmpProp.OptJSONObject(Keys[i]);
if TmpProp=nil then exit;
end;
end;
function JSONObject.GetCascadeValObj(
const Keys: array of String): TZAbstractObject;
var
i:Integer;
TmpProp:JSONObject;
begin
Result:=nil;
TmpProp:=Self;
for i:=Low(Keys) to High(Keys) do
begin
if i=High(Keys) then
begin
Result:=TmpProp.Opt(Keys[i]);
exit;
end;
TmpProp:=TmpProp.OptJSONObject(Keys[i]);
if TmpProp=nil then exit;
end;
end;
procedure JSONObject.SetAsString(const Value: String);
var
token:JSOnTokener;
i :integer;
MyObj:TObject;
begin
for i:=Pred(myHashMap.Count) downto 0 do
begin
MyObj:=myHashMap.Objects[i];
if (MyObj <> CONST_FALSE) and (MyObj <> CONST_TRUE) and (MyObj <> CNULL) then
MyObj.Free;
end;
myHashMap.Clear;
if System.Length(Value)<=2 then exit;
token:=JSONTokener.create(Value);
try
UpdateByTokener(token);
finally
token.free;
end;
end;
function JSONObject.GetDiffFrom(Source: JSONObject): JSONObject;
var
i:Integer;
begin
Result:=JSONObject.Create;
with Source.Keys do
begin
for i:=0 to Pred(Count) do
begin
if Source.PropValues[Strings[i]]=PropValues[Strings[i]] then continue;
Result.PropValues[Strings[i]]:=Source.PropValues[Strings[i]];
end;
Free;
end;
end;
procedure JSONObject.Delete(index: Integer);
var
Obj:TObject;
begin
Obj:=TZAbstractObject(myHashMap.Objects [index]);
self.myHashMap.delete(index);
Obj.Free;
end;
procedure JSONObject.RemoveByKeyHeader(const Header: String);
var
i:Integer;
begin
with Keys do
begin
for i:=Pred(Count) downto 0 do
begin
if Pos(Header,Strings[i])=1 then
CleanKey(Strings[i]);
end;
Free;
end;
end;
function JSONObject.PropCount: Integer;
begin
Result:=myHashMap.Count;
end;
function JSONObject.KeyByVal(const Value: String): String;
var
i:Integer;
begin
for i:=0 to Pred(myHashMap.Count) do
begin
with TZAbstractObject(myHashMap.Objects[i]) do
begin
if toString=Value then
begin
Result:=myHashMap[i];
exit;
end;
end;
end;
Result:='';
end;
function JSONObject.PartExtract(KeyNames: TStrings;
DoRemove: Boolean): JSONObject;
var
i:Integer;
KeyName:String;
begin
Result:=nil;
if KeyNames=nil then exit;
Result:=JSONObject.Create;
for i:=Pred(Length) downto 0 do
begin
KeyName:=KeyByIndex[i];
if KeyNames.IndexOf(KeyName)<0 then continue;
if DoRemove then
Result.Put(KeyName,Remove(KeyByIndex[i]))
else
Result.Put(KeyName,ValObjByIndex[i].Clone);
end;
end;
function JSONObject.ExtractAll: JSONObject;
var
i:Integer;
KeyName:String;
begin
Result:=JSONObject.Create;
for i:=Pred(Length) downto 0 do
begin
KeyName:=KeyByIndex[i];
Result.Put(KeyName,Remove(KeyByIndex[i]))
end;
end;
function JSONObject.TryNewJSONArray(const Key: String): JSONArray;
begin
Result:=OptJSONArray(Key);
if Result=nil then
begin
Result:=JSONArray.create;
Put(Key,Result);
end;
end;
function JSONObject.TryNewJSONObject(const Key: String): JSONObject;
begin
Result:=OptJSONObject(Key);
if Result=nil then
begin
Result:=JSONObject.create;
Put(Key,Result);
end;
end;
procedure JSONObject.Assign(Source: JSONObject);
begin
if Source=nil then
Clean
else begin
AsString:=Source.AsString;
end;
end;
function JSONObject.GetKeyByIndex(index: Integer): String;
begin
Result:=myHashMap[index];
end;
procedure JSONObject.SetCascadeValue(const Value: String;
const Keys: array of String);
begin
SetCascadeValueEx(Value,Keys,0);
end;
procedure JSONObject.SetCascadeValueEx(const Value: String;
const Keys: array of String; StartIdx: Integer);
var
JObj:JSONObject;
begin
if High(Keys)<StartIdx then exit;
if High(Keys)=StartIdx then
begin
Self.Put(Keys[StartIdx],Value);
exit;
end;
JObj:=OptJSONObject(Keys[StartIdx]);
if JObj=nil then
begin
JObj:=JSONObject.Create;
Self.Put(Keys[StartIdx],JObj);
end;
JObj.SetCascadeValueEx(Value,Keys,StartIdx+1);
end;
function JSONObject.GetValByIndex(index: Integer): String;
begin
Result:=TZAbstractObject(myHashMap.Objects[index]).toString;
end;
function JSONObject.GetValObjByIndex(index: Integer): TZAbstractObject;
begin
Result:=TZAbstractObject(myHashMap.Objects[index]);
end;
procedure JSONObject.CleanKey(const Key: String);
var
i:Integer;
begin
i:=myHashMap.IndexOf(key);
if i<0 then exit;
TZAbstractObject(myHashMap.Objects[i]).Free;
myHashMap.delete(i);
end;
procedure JSONObject.UpdateByTokener(x: JSONTokener);
var
c : char;
key : string;
begin
key := '';
if (x.nextClean() <> '{') then begin
raise x.syntaxError('A JSONObject must begin with "{"');
end;
while (true) do
begin
c := x.nextClean();
case (c) of
#0:
raise x.syntaxError('A JSONObject must end with "}"');
'}': begin
exit;
end
else begin
x.back();
//key := x.nextValue().toString();
with x.nextValue() do
begin
key := toString();
Free; //Fix memory leak. By creation_zy 2008-08-07
end;
end
end; //fim do case
(*
* The key is followed by ':'. We will also tolerate '=' or '=>'.
*)
c := x.nextClean();
if (c = '=') then begin
if (x.next() <> '>') then begin
x.back();
end;
end else if (c <> ':') then begin
raise x.syntaxError('Expected a ":" after a key');
end;
self.myHashMap.AddObject(key, x.nextValue());
(*
* Pairs are separated by ','. We will also tolerate ';'.
*)
case (x.nextClean()) of
';', ',': begin
if (x.nextClean() = '}') then begin
exit;
end;
x.back();
end;
'}': begin
exit;
end
else begin
raise x.syntaxError('Expected a "," or "}"');
end
end;
end; //while
end;
{ _Boolean }
function _Boolean.boolValue: Boolean;
begin
Result := fvalue;
end;
function _Boolean.clone: TZAbstractObject;
begin
Result := _Boolean.create(Self.fvalue);
end;
constructor _Boolean.create(b: boolean);
begin
fvalue := b;
end;
function _Boolean.toString: string;
begin
if fvalue then begin
Result := 'true';
end else begin
Result := 'false';
end;
end;
class function _Boolean.valueOf(b: boolean): _Boolean;
begin
if (b) then begin
Result := _TRUE;
end else begin
Result := _FALSE;
end;
end;
class function _Boolean._FALSE: _Boolean;
begin
Result := CONST_FALSE;
end;
class function _Boolean._TRUE: _Boolean;
begin
Result := CONST_TRUE;
end;
{ _String }
function _String.clone: TZAbstractObject;
begin
Result := _String.create (self.fvalue);
end;
constructor _String.create(const s: string);
begin
fvalue := s;
end;
function _String.equals(const Value: TZAbstractObject): Boolean;
begin
Result := (value is _String) and (_String (value).fvalue = fvalue);
end;
function _String.equalsIgnoreCase(const s: string): boolean;
begin
Result := AnsiLowerCase (s) = AnsiLowerCase (fvalue);
end;
function _String.toString: string;
begin
Result := fvalue;
end;
{ ParseException }
constructor ParseException.create(_message: string; index: integer);
begin
inherited createFmt(_message+#10#13' erro no caracter : %d',[index]);
end;
{ _Integer }
constructor _Integer.create(i: integer);
begin
fvalue := i;
end;
function _Integer.clone: TZAbstractObject;
begin
Result := _Integer.create (self.fvalue);
end;
constructor _Integer.create(const s: string);
begin
fvalue := strToInt (s);
end;
function _Integer.doubleValue: double;
begin
Result := fvalue;
end;
function _Integer.intValue: integer;
begin
Result := fvalue;
end;
class function _Integer.parseInt(const s: string; i: integer): integer;
begin
Result:=0; //By creation_zy
case i of
10: Result := strToInt (s);
16: Result := hexToInt (s);
8:
begin
if s='0' then exit; //By creation_zy
newNotImplmentedFeature () ;
end;
else newNotImplmentedFeature () ; //By creation_zy
end;
end;
class function _Integer.parseInt(s: _String): integer;
begin
Result := _Integer.parseInt (s.toString, 10);
end;
class function _Integer.toHexString(c: char): string;
begin
Result := IntToHex(ord(c),2);
end;
function _Integer.toString: string;
begin
Result := intToStr (fvalue);
end;
{ _Double }
constructor _Double.create(const s: string);
begin
fvalue := StrToFloat (s, getFormatSettings);
end;
constructor _Double.create(s: _String);
begin
create (s.toString);
end;
function _Double.clone: TZAbstractObject;
begin
Result := _Double.create (Self.fvalue);
end;
constructor _Double.create(d: double);
begin
fvalue := d;
end;
function _Double.doubleValue: double;
begin
Result := fvalue;
end;
function _Double.intValue: integer;
begin
Result := trunc (fvalue);
end;
class function _Double.NaN: double;
begin
Result := 3.6e-4951;
end;
function _Double.toString: string;
begin
Result := floatToStr (fvalue, getFormatSettings);
end;
{ JSONArray }
(**
* Construct a JSONArray from a JSONTokener.
* @param x A JSONTokener
* @exception ParseException A JSONArray must start with '['
* @exception ParseException Expected a ',' or ']'
*)
constructor JSONArray.create(x: JSONTokener);
begin
create;
if (x.nextClean() <> '[') then begin
raise x.syntaxError('A JSONArray must start with "["');
end;
if (x.nextClean() = ']') then begin
exit;
end;
x.back();
while (true) do begin
if (x.nextClean() = ',') then begin
x.back();
myArrayList.add(nil);
end else begin
x.back();
myArrayList.add(x.nextValue());
end;
case (x.nextClean()) of
';',',': begin
if (x.nextClean() = ']') then begin
exit;
end;
x.back();
end;
']': begin
exit;
end else begin
raise x.syntaxError('Expected a "," or "]"');
end
end;
end;
end;
destructor JSONObject.destroy;
var
i :integer;
MyObj:TObject;
begin
for i:=Pred(myHashMap.Count) downto 0 do
begin
MyObj:=myHashMap.Objects[i];
if (MyObj <> CONST_FALSE) and (MyObj <> CONST_TRUE) and (MyObj <> CNULL) then
MyObj.Free;
end;
{
while myHashMap.Count > 0 do begin
if (myHashMap.Objects [0] <> CONST_FALSE)
and (myHashMap.Objects [0] <> CONST_TRUE)
and (myHashMap.Objects [0] <> CNULL) then begin
myHashMap.Objects [0].Free;
end;
myHashMap.Objects [0] := nil;
myHashMap.Delete(0);
end;}
myHashMap.Free;
inherited;
end;
(**
* Construct a JSONArray from a Collection.
* @param collection A Collection.
*)
constructor JSONArray.create(collection: TList);
var
i : integer;
begin
myArrayList := TList.create ();
for i := 0 to collection.count -1 do begin
myArrayList.add (collection[i]);
end;
end;
(**
* Construct an empty JSONArray.
*)
constructor JSONArray.create;
begin
myArrayList := TList.create;
end;
(**
* Construct a JSONArray from a source string.
* @param string A string that begins with
* <code>[</code> <small>(left bracket)</small>
* and ends with <code>]</code> <small>(right bracket)</small>.
* @exception ParseException The string must conform to JSON syntax.
*)
constructor JSONArray.create(const s: string);
var
token:JSOnTokener;
begin
token:=JSONTokener.create(s);
try
create(token);
finally
token.free;
end;
end;
destructor JSONArray.destroy;
var
i : integer;
obj : TObject;
begin
for i:=Pred(myArrayList.Count) downto 0 do
begin
obj:=myArrayList[i];
if (obj <> CONST_FALSE) and (obj <> CONST_TRUE) and (obj <> CNULL) then
obj.Free;
end;
{
while myArrayList.Count > 0 do begin
obj := myArrayList [0];
myArrayList [0] := nil;
if (obj <> CONST_FALSE)
and (obj <> CONST_TRUE)
and (obj <> CNULL) then begin
obj.Free;
end;
myArrayList.Delete(0);
end;
}
myArrayList.Free;
inherited;
end;
procedure JSONArray.Clean;
var
i : integer;
obj : TObject;
begin
for i:=Pred(myArrayList.Count) downto 0 do
begin
obj:=myArrayList[i];
if (obj <> CONST_FALSE) and (obj <> CONST_TRUE) and (obj <> CNULL) then
obj.Free;
end;
end;
function JSONArray.Clone: TZAbstractObject;
begin
Result:=JSONArray.create(Self.toString);
end;
function JSONArray.appendJSONArray(value: JSONArray): Integer;
var
i:Integer;
begin
if value=nil then
begin
Result:=0;
exit;
end;
Result:=value.length;
for i:=0 to Pred(Result) do
put(value.get(i).Clone);
end;
(**
* Get the object value associated with an index.
* @param index
* The index must be between 0 and length() - 1.
* @return An object value.
* @exception NoSuchElementException
*)
function JSONArray.get(index: integer): TZAbstractObject;
var
o : TZAbstractObject;
begin
o := opt(index);
if (o = nil) then begin
raise NoSuchElementException.create('JSONArray[' + intToStr(index)
+ '] not found.');
end ;
Result := o;
end;
(**
* Get the boolean value associated with an index.
* The string values "true" and "false" are converted to boolean.
*
* @param index The index must be between 0 and length() - 1.
* @return The truth.
* @exception NoSuchElementException if the index is not found
* @exception ClassCastException
*)
function JSONArray.getBoolean(index: integer): boolean;
var
o : TZAbstractObject;
begin
o := get(index);
if ((o.equals(_Boolean._FALSE) or
((o is _String) and
(_String(o)).equalsIgnoreCase('false')))) then begin
Result := false;
exit;
end else if ((o.equals(_Boolean._TRUE) or
((o is _String) and
(_String(o)).equalsIgnoreCase('true')))) then begin
Result := true;
exit;
end;
raise ClassCastException.create('JSONArray[' + intToStr(index) +
'] not a Boolean.');
end;
(**
* Get the double value associated with an index.
*
* @param index The index must be between 0 and length() - 1.
* @return The value.
* @exception NoSuchElementException if the key is not found
* @exception NumberFormatException
* if the value cannot be converted to a number.
*)
function JSONArray.getDouble(index: integer): double;
var
o : TZAbstractObject;
d : _Double;
begin
o := get(index);
if (o is _Number) then begin
Result := (_Number(o)).doubleValue();
exit;
end;
if (o is _String) then begin
d := _Double.create(_String(o));
try
Result := d.doubleValue();
exit;
finally
d.Free;
end;
end;
raise NumberFormatException.create('JSONObject['
+ intToStr(index) + '] is not a number.');
end;
(**
* Get the int value associated with an index.
*
* @param index The index must be between 0 and length() - 1.
* @return The value.
* @exception NoSuchElementException if the key is not found
* @exception NumberFormatException
* if the value cannot be converted to a number.
*)
function JSONArray.getInt(index: integer): integer;
var
o : TZAbstractObject;
begin
o := get(index);
if (o is _Number) then begin
Result := _Number(o).intValue();
end else begin
Result := trunc (getDouble (index));
end;
end;
(**
* Get the JSONArray associated with an index.
* @param index The index must be between 0 and length() - 1.
* @return A JSONArray value.
* @exception NoSuchElementException if the index is not found or if the
* value is not a JSONArray
*)
function JSONArray.getJSONArray(index: integer): JSONArray;
var
o : TZAbstractObject;
begin
o := get(index);
if (o is JSONArray) then begin
Result := JSONArray(o);
exit;
end;
raise NoSuchElementException.create('JSONArray[' + intToStr(index) +
'] is not a JSONArray.');
end;
(**
* Get the JSONObject associated with an index.
* @param index subscript
* @return A JSONObject value.
* @exception NoSuchElementException if the index is not found or if the
* value is not a JSONObject
*)
function JSONArray.getJSONObject(index: integer): JSONObject;
var
o : TZAbstractObject;
s : string;
begin
o := get(index);
if (o is JSONObject) then begin
Result := JSONObject(o);
end else begin
if o <> nil then begin
s := o.ClassName;
end else begin
s := 'nil';
end;
raise NoSuchElementException.create('JSONArray[' + intToStr(index) +
'] is not a JSONObject is ' + s);
end;
end;
(**
* Get the string associated with an index.
* @param index The index must be between 0 and length() - 1.
* @return A string value.
* @exception NoSuchElementException
*)
function JSONArray.getString(index: integer): string;
begin
Result := get(index).toString();
end;
(**
* Determine if the value is null.
* @param index The index must be between 0 and length() - 1.
* @return true if the value at the index is null, or if there is no value.
*)
function JSONArray.isNull(index: integer): boolean;
var
o : TZAbstractObject;
begin
o := opt(index);
Result := (o = nil) or (o.equals(nil));
end;
(**
* Make a string from the contents of this JSONArray. The separator string
* is inserted between each element.
* Warning: This method assumes that the data structure is acyclical.
* @param separator A string that will be inserted between the elements.
* @return a string.
*)
function JSONArray.join(separator: string): string;
var
len, i : integer;
sb : string ;
begin
len := length();
sb := '';
for i := 0 to len -1 do begin
if (i > 0) then begin
sb := sb + separator;
end;
sb:= sb + JSONObject.valueToString(TZAbstractObject( myArrayList[i]));
end;
Result := sb;
end;
(**
* Get the length of the JSONArray.
*
* @return The length (or size).
*)
function JSONArray.length: integer;
begin
Result := myArrayList.Count ;
end;
(**
* Get the optional object value associated with an index.
* @param index The index must be between 0 and length() - 1.
* @return An object value, or null if there is no
* object at that index.
*)
function JSONArray.opt(index: integer): TZAbstractObject;
begin
if ((index < 0) or (index >= length()) ) then begin
Result := nil;
end else begin
Result := TZAbstractObject (myArrayList[index]);
end;
end;
(**
* Get the optional boolean value associated with an index.
* It returns false if there is no value at that index,
* or if the value is not Boolean.TRUE or the String "true".
*
* @param index The index must be between 0 and length() - 1.
* @return The truth.
*)
function JSONArray.optBoolean(index: integer): boolean;
begin
Result := optBoolean(index, false);
end;
(**
* Get the optional boolean value associated with an index.
* It returns the defaultValue if there is no value at that index or if it is not
* a Boolean or the String "true" or "false" (case insensitive).
*
* @param index The index must be between 0 and length() - 1.
* @param defaultValue A boolean default.
* @return The truth.
*)
function JSONArray.optBoolean(index: integer;
defaultValue: boolean): boolean;
var
o : TZAbstractObject;
begin
o := opt(index);
if (o <> nil) then begin
if ((o.equals(_Boolean._FALSE) or
((o is _String) and
(_String(o)).equalsIgnoreCase('false')))) then begin
Result := false;
exit;
end else if ((o.equals(_Boolean._TRUE) or
((o is _String) and
(_String(o)).equalsIgnoreCase('true')))) then begin
Result := true;
exit;
end;
end;
Result := defaultValue;
end;
(**
* Get the optional double value associated with an index.
* NaN is returned if the index is not found,
* or if the value is not a number and cannot be converted to a number.
*
* @param index The index must be between 0 and length() - 1.
* @return The value.
*)
function JSONArray.optDouble(index: integer): double;
begin
Result := optDouble(index, _Double.NaN);
end;
(**
* Get the optional double value associated with an index.
* The defaultValue is returned if the index is not found,
* or if the value is not a number and cannot be converted to a number.
*
* @param index subscript
* @param defaultValue The default value.
* @return The value.
*)
function JSONArray.optDouble(index: integer; defaultValue :double): double;
var
o : TZAbstractObject;
d : _Double;
begin
o := opt(index);
if (o <> nil) then
begin
if (o is _Number) then
begin
Result := (_Number(o)).doubleValue();
exit;
end;
try
d := _Double.create (_String (o));
Result := d.doubleValue ;
d.Free;
exit;
except
on e:Exception do
begin
Result := defaultValue;
exit;
end;
end;
end;
Result := defaultValue;
end;
(**
* Get the optional int value associated with an index.
* Zero is returned if the index is not found,
* or if the value is not a number and cannot be converted to a number.
*
* @param index The index must be between 0 and length() - 1.
* @return The value.
*)
function JSONArray.optInt(index: integer): integer;
begin
Result := optInt(index, 0);
end;
(**
* Get the optional int value associated with an index.
* The defaultValue is returned if the index is not found,
* or if the value is not a number and cannot be converted to a number.
* @param index The index must be between 0 and length() - 1.
* @param defaultValue The default value.
* @return The value.
*)
function JSONArray.optInt(index, defaultValue: integer): integer;
var
o : TZAbstractObject;
begin
o := opt(index);
if (o <> nil) then
begin
if (o is _Number) then
begin
Result := (_Number(o)).intValue();
exit; //By creation_zy
end;
try
Result := _Integer.parseInt(_String(o));
exit;
except
on e: exception do
begin
Result := defaultValue;
exit;
end;
end;
end;
Result := defaultValue;
end;
(**
* Get the optional JSONArray associated with an index.
* @param index subscript
* @return A JSONArray value, or null if the index has no value,
* or if the value is not a JSONArray.
*)
function JSONArray.optJSONArray(index: integer): JSONArray;
var
o : TZAbstractObject;
begin
o := opt(index);
if (o is JSONArray) then begin
Result := JSONArray (o) ;
end else begin
Result := nil;
end;
end;
(**
* Get the optional JSONObject associated with an index.
* Null is returned if the key is not found, or null if the index has
* no value, or if the value is not a JSONObject.
*
* @param index The index must be between 0 and length() - 1.
* @return A JSONObject value.
*)
function JSONArray.optJSONObject(index: integer): JSONObject;
var
o : TZAbstractObject;
begin
o := opt(index);
if (o is JSONObject) then begin
Result := JSONObject (o);
end else begin
Result := nil;
end;
end;
(**
* Get the optional string value associated with an index. It returns an
* empty string if there is no value at that index. If the value
* is not a string and is not null, then it is coverted to a string.
*
* @param index The index must be between 0 and length() - 1.
* @return A String value.
*)
function JSONArray.optString(index: integer): string;
begin
Result := optString(index, '');
end;
(**
* Get the optional string associated with an index.
* The defaultValue is returned if the key is not found.
*
* @param index The index must be between 0 and length() - 1.
* @param defaultValue The default value.
* @return A String value.
*)
function JSONArray.optString(index: integer; defaultValue: string): string;
var
o : TZAbstractObject;
begin
o := opt(index);
if (o <> nil) then begin
Result := o.toString();
end else begin
Result := defaultValue;
end;
end;
(**
* Append a boolean value.
*
* @param value A boolean value.
* @return this.
*)
function JSONArray.put(value: boolean): JSONArray;
begin
put(_Boolean.valueOf(value));
Result := self;
end;
(**
* Append a double value.
*
* @param value A double value.
* @return this.
*)
function JSONArray.put(value: double): JSONArray;
begin
put(_Double.create(value));
Result := self;
end;
(**
* Append an int value.
*
* @param value An int value.
* @return this.
*)
function JSONArray.put(value: integer): JSONArray;
begin
put(_Integer.create(value));
Result := self;
end;
function JSONArray.put(value: string): JSONArray;
begin
put (_String.create (value));
Result := self;
end;
(**
* Append an object value.
* @param value An object value. The value should be a
* Boolean, Double, Integer, JSONArray, JSObject, or String, or the
* JSONObject.NULL object.
* @return this.
*)
function JSONArray.put(value: TZAbstractObject): JSONArray;
begin
myArrayList.add(value);
Result := self;
end;
(**
* Put or replace a boolean value in the JSONArray.
* @param index subscript The subscript. If the index is greater than the length of
* the JSONArray, then null elements will be added as necessary to pad
* it out.
* @param value A boolean value.
* @return this.
* @exception NoSuchElementException The index must not be negative.
*)
function JSONArray.put(index: integer; value: boolean): JSONArray;
begin
put(index, _Boolean.valueOf(value));
Result := self;
end;
function JSONArray.put(index, value: integer): JSONArray;
begin
put(index, _Integer.create(value));
Result := self;
end;
function JSONArray.put(index: integer; value: double): JSONArray;
begin
put(index, _Double.create(value));
Result := self;
end;
function JSONArray.put(index: integer; value: string): JSONArray;
begin
put (index,_String.create (value));
Result := self;
end;
(**
* Put or replace an object value in the JSONArray.
* @param index The subscript. If the index is greater than the length of
* the JSONArray, then null elements will be added as necessary to pad
* it out.
* @param value An object value.
* @return this.
* @exception NoSuchElementException The index must not be negative.
* @exception NullPointerException The index must not be null.
*)
function JSONArray.put(index: integer; value: TZAbstractObject): JSONArray;
begin
if (index < 0) then
raise NoSuchElementException.create('JSONArray['+intToStr(index)+'] not found.')
else if (value = nil) then
raise NullPointerException.create('')
else if (index < length()) then
myArrayList[index] := value
else begin
while (index<>length()) do put(nil);
put(value);
end;
Result := self;
end;
(**
* Produce a JSONObject by combining a JSONArray of names with the values
* of this JSONArray.
* @param names A JSONArray containing a list of key strings. These will be
* paired with the values.
* @return A JSONObject, or null if there are no names or if this JSONArray
* has no values.
*)
function JSONArray.toJSONObject(names :JSONArray): JSONObject;
var
jo : JSONObject ;
i : integer;
begin
if ((names = nil) or (names.length() = 0) or (length() = 0)) then
begin
Result := nil;
exit; //By creation_zy
end;
jo := JSONObject.create();
for i := 0 to names.length() do begin
jo.put(names.getString(i), self.opt(i));
end;
Result := jo;
end;
(**
* Make an JSON external form string of this JSONArray. For compactness, no
* unnecessary whitespace is added.
* Warning: This method assumes that the data structure is acyclical.
*
* @return a printable, displayable, transmittable
* representation of the array.
*)
function JSONArray.toString: string;
begin
Result := '[' + join(',') + ']';
end;
(**
* Make a prettyprinted JSON string of this JSONArray.
* Warning: This method assumes that the data structure is non-cyclical.
* @param indentFactor The number of spaces to add to each level of
* indentation.
* @return a printable, displayable, transmittable
* representation of the object, beginning
* with <code>[</code> <small>(left bracket)</small> and ending
* with <code>]</code> <small>(right bracket)</small>.
*)
function JSONArray.toString2(indentFactor: integer): string;
begin
Result := toString3(indentFactor, 0);
end;
(**
* Make a prettyprinted string of this JSONArray.
* Warning: This method assumes that the data structure is non-cyclical.
* @param indentFactor The number of spaces to add to each level of
* indentation.
* @param indent The indention of the top level.
* @return a printable, displayable, transmittable
* representation of the array.
*)
function JSONArray.toList: TList;
begin
Result := TList.create ;
Result.Assign(myArrayList,laCopy);
end;
function JSONArray.toString3(indentFactor, indent: integer): string;
var
len, i, j, newindent : integer;
sb : string;
begin
len := length();
if (len = 0) then
begin
Result := '[]';
exit;
end;
sb := '[';
if (len = 1) then
begin
sb := sb + JSONObject
.valueToString(TZAbstractObject( myArrayList[0]),indentFactor, indent);
end
else
begin
newindent := indent + indentFactor;
sb := sb + #10 ;
for i := 0 to len -1 do
begin
if (i > 0) then begin
sb := sb +',' + #10;
end;
for j := 0 to newindent-1 do begin
sb := sb + ' ';
end;
sb := sb + (JSONObject.valueToString(TZAbstractObject(myArrayList[i]),
indentFactor, newindent));
end;
sb := sb + #10;
for i := 0 to indent-1 do begin
sb := sb + ' ';
end;
end;
sb := sb + ']';
Result := sb;
end;
{ _NULL }
function _NULL.Equals(const Value: TZAbstractObject): Boolean;
begin
if (value = nil) then begin
Result := true;
end else begin
Result := (value is _NULL) ;
end;
end;
function _NULL.toString: string;
begin
Result := 'null';
end;
{ TZAbstractObject }
function TZAbstractObject.Clone: TZAbstractObject;
begin
Result:=nil;
newNotImplmentedFeature();
end;
function TZAbstractObject.Equals(const Value: TZAbstractObject): Boolean;
begin
Result := (value <> nil) and (value = self);
end;
class function TZAbstractObject.getBoolean(o: TZAbstractObject; DefaultValue: Boolean): Boolean;
begin
if (o<>CNULL) and (o<>nil) then
begin
if o.ClassType=_Boolean then //2009-03-06 By creation_zy
begin
Result:=_Boolean(o).fvalue;
exit;
end
else if ((o is _String) and (_String(o).equalsIgnoreCase('false'))) then
begin
Result := false;
exit;
end
else if ((o is _String) and (_String(o).equalsIgnoreCase('true'))) then
begin
Result := true;
exit;
end;
end;
Result := DefaultValue;
end;
class function TZAbstractObject.getDouble(o: TZAbstractObject; DefaultValue: Double): Double;
begin
if (o<>CNULL) and ( o <> nil ) then
begin
if (o is _Number) then
begin
Result := _Number(o).doubleValue();
exit;
end;
if o.ClassType=_String then
Result:=StrToFloatDef(o.toString,DefaultValue)
else
Result:=defaultValue;
end
else //By creation_zy
Result := defaultValue;
end;
class function TZAbstractObject.getInt(o: TZAbstractObject; DefaultValue: Integer): Integer;
begin
if (o<>CNULL) and ( o <> nil ) then
begin
if (o is _Number) then
begin
Result := _Number(o).intValue();
exit;
end;
if o.ClassType<>_String then
Result := defaultValue
else
try
Result := _Integer.parseInt(_String(o));
except
Result := defaultValue;
end;
end
else //By creation_zy
Result := defaultValue;
end;
function TZAbstractObject.Hash: LongInt;
begin
Result := integer(addr(self));
end;
function TZAbstractObject.InstanceOf(
const Value: TZAbstractObject): Boolean;
begin
Result := value is TZAbstractObject;
end;
function TZAbstractObject.ToString: string;
begin
Result := Format('%s <%p>', [ClassName, addr(Self)]);
end;
initialization
CONST_FALSE := _Boolean.create (false);
CONST_TRUE := _Boolean.create (true);
CNULL := _NULL.create;
finalization
CONST_FALSE.free;
CONST_TRUE.Free;
CNULL.free;
end.
|
unit uDbUsuario;
interface
uses uDbObject, Data.Db, System.SysUtils, System.Classes;
type TDbUsuario = class(TDbObject)
private
public
property codigo: TDbField;
property nomeusuario: TDbField;
property login: TDbField;
property senha: TDbField;
property valor: TDbField;
property datacadastro: TDbField;
function Insert: Boolean;
constructor create;
end;
implementation
{ TDbUsuario }
constructor TDbUsuario.create;
begin
inherited create(Self);
Fcodigo:= CreateDbField('CODIGO', ftInteger, True, True, False, True, 'codigo');
Fnomeusuario:= CreateDbField('NOMEUSUARIO', ftString, True, False, False, True, 'nomeusuario');
Flogin:= CreateDbField('LOGIN', ftString, True, False, False, True, 'login');
Fsenha:= CreateDbField('SENHA', ftString, True, False, False, True, 'senha');
Fvalor:= CreateDbField('VALOR', ftFloat, False, False, False, True, 'valor');
Fdatacadastro:= CreateDbField('DATACADASTRO', ftDateTime, False, False, False, True, 'datacadastro');
TableName := 'USUARIO';
end;
function TDbUsuario.Insert: Boolean;
begin
Fcodigo.AsInteger := GetSequence(TableName, Fcodigo.ColumnName);
result := inherited Insert;
end;
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.