blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 4
201
| content_id
stringlengths 40
40
| detected_licenses
sequencelengths 0
85
| license_type
stringclasses 2
values | repo_name
stringlengths 7
100
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringclasses 260
values | visit_date
timestamp[us] | revision_date
timestamp[us] | committer_date
timestamp[us] | github_id
int64 11.4k
681M
⌀ | star_events_count
int64 0
209k
| fork_events_count
int64 0
110k
| gha_license_id
stringclasses 17
values | gha_event_created_at
timestamp[us] | gha_created_at
timestamp[us] | gha_language
stringclasses 80
values | src_encoding
stringclasses 28
values | language
stringclasses 1
value | is_vendor
bool 1
class | is_generated
bool 2
classes | length_bytes
int64 8
9.86M
| extension
stringclasses 52
values | content
stringlengths 8
9.86M
| authors
sequencelengths 1
1
| author
stringlengths 0
119
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
7b3d38d26eb865d17766926b12e72b2dd79bc01a | f56bf4d2087b2a7f13ba8cec5a06ae85c37cef57 | /Node.hpp | 307bc97ac3b73d2373e9c74147674044d00821d1 | [] | no_license | sherlock6147/templates | 72282d6244d7fc9d30926b66fd566d4a31c9a10f | 61226b88afa97cfe4c704923f1ef0014007a8483 | refs/heads/master | 2022-08-20T01:49:49.620036 | 2020-05-23T12:00:31 | 2020-05-23T12:00:31 | 262,821,023 | 1 | 0 | null | 2020-05-10T15:58:30 | 2020-05-10T15:48:02 | C++ | UTF-8 | C++ | false | false | 871 | hpp | #include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
template <typename T>
class Node
{
public:
Node<T> *next=NULL;
T data;
int location;
void get_data()
{
cout<<"enter data: ";
cin>>data;
}
void disp_data()
{
cout<<data;
}
void display()
{
cout<<"element info: ";
disp_data();
cout<<" location :"<<location<<'\n';
}
};
template <typename T=char[]>
class Node
{
public:
T data;
Node<T> *next=NULL;
int location;
void get_data()
{
cout<<"enter data: ";
cin.getline(data,200,'\n');
}
void disp_data()
{
int len=strlen(data);
cout.write(data,len);
}
void display()
{
cout<<"element info: ";
disp_data();
cout<<" location :"<<location<<'\n';
}
}; | [
"[email protected]"
] | |
deb50aa2db090d284c6a4a1b4372503f1fc74162 | cf8ddfc720bf6451c4ef4fa01684327431db1919 | /SDK/ARKSurvivalEvolved_ProjMekSwarm_classes.hpp | 7de340bd3587d08de967ac2931888f62930e39f8 | [
"MIT"
] | permissive | git-Charlie/ARK-SDK | 75337684b11e7b9f668da1f15e8054052a3b600f | c38ca9925309516b2093ad8c3a70ed9489e1d573 | refs/heads/master | 2023-06-20T06:30:33.550123 | 2021-07-11T13:41:45 | 2021-07-11T13:41:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,789 | hpp | #pragma once
// ARKSurvivalEvolved (329.9) SDK
#ifdef _MSC_VER
#pragma pack(push, 0x8)
#endif
#include "ARKSurvivalEvolved_ProjMekSwarm_structs.hpp"
namespace sdk
{
//---------------------------------------------------------------------------
//Classes
//---------------------------------------------------------------------------
// BlueprintGeneratedClass ProjMekSwarm.ProjMekSwarm_C
// 0x0161 (0x0981 - 0x0820)
class AProjMekSwarm_C : public AShooterProjectile_Swarm
{
public:
struct FVector SwarmStartLoc; // 0x0820(0x000C) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
struct FRotator SwarmStartRot; // 0x082C(0x000C) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
bool SwarmStarted; // 0x0838(0x0001) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance, IsPlainOldData)
unsigned char UnknownData00[0x7]; // 0x0839(0x0007) MISSED OFFSET
class UParticleSystem* MissileSpawnParticleSystem; // 0x0840(0x0008) (Edit, BlueprintVisible, ZeroConstructor, IsPlainOldData)
TArray<struct FName> FireSockets; // 0x0848(0x0010) (Edit, BlueprintVisible, ZeroConstructor)
class UParticleSystemComponent* K2Node_CustomEvent_Comp; // 0x0858(0x0008) (ZeroConstructor, Transient, DuplicateTransient, IsPlainOldData)
int K2Node_Event_BoidIndex; // 0x0860(0x0004) (ZeroConstructor, Transient, DuplicateTransient, IsPlainOldData)
unsigned char UnknownData01[0x4]; // 0x0864(0x0004) MISSED OFFSET
class UParticleSystemComponent* K2Node_Event_BoidParticles; // 0x0868(0x0008) (ZeroConstructor, Transient, DuplicateTransient, IsPlainOldData)
struct FHitResult K2Node_Event_Hit; // 0x0870(0x0088) (OutParm, Transient, DuplicateTransient, ReferenceParm)
struct FHitResult K2Node_Event_Result; // 0x08F8(0x0088) (OutParm, Transient, DuplicateTransient, ReferenceParm)
bool CallFunc_IsValid_ReturnValue; // 0x0980(0x0001) (ZeroConstructor, Transient, DuplicateTransient, IsPlainOldData)
static UClass* StaticClass()
{
static auto ptr = UObject::FindClass("BlueprintGeneratedClass ProjMekSwarm.ProjMekSwarm_C");
return ptr;
}
void SetupMissileSpawnParticles(class USkeletalMeshComponent* MekMesh, const struct FName& BoneName);
struct FVector2D PointOnGrid(int ThisIndex, int Width, int Height, float HorizScale, float VertScale);
void ReceiveTick(float* DeltaSeconds);
void BPGetBoidSpawnLocationAndVelocity(int* BoidIndex, struct FBoid* BoidData, struct FVector* SpawnLocation, struct FVector* SpawnVelocity);
void UserConstructionScript();
void BPOnBoidExplode(int* BoidIndex, class UParticleSystemComponent** BoidParticles, struct FHitResult* Hit);
void OnExplode(struct FHitResult* Result);
void DisableMissleParticles(class UParticleSystemComponent* Comp);
void ExecuteUbergraph_ProjMekSwarm(int EntryPoint);
};
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"[email protected]"
] | |
6bc0160474998e4b1a369f1160aa33edc5ee371f | 5ca1c8bee4fb4decde14e4bc92034086add8130d | /Test/Arduino/Skin_temp/Skin_temp.ino | 4472ff0871d15da05bce27c3f79d5d05856d48ea | [] | no_license | BlackBerryPi/Attentiveness-Parameter | f5a72a695efebbf3174825482ab13d2ddda6ecf6 | 49e3669ea48601ae1c6c4189c5cf19b2850ccb19 | refs/heads/master | 2021-09-11T19:43:08.249838 | 2018-04-02T12:54:19 | 2018-04-02T12:54:19 | 125,729,787 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,419 | ino | int tempPin = A0;
int gyroXPin = A1;
int gyroYPin = A2;
int gyroZPin = A3;
// outside leads to ground and +5V
int val = 0; // variable to store the value read
int gyroX = 0;
int gyroY = 0;
int gyroZ = 0;
int sum = 0;
double lastVal = 0;
double vault = 0;
double result = 0;
double divide = 20;
bool flag = true;
int gyroCount = 0;
void setup()
{
Serial.begin(9600); // setup serial
}
void loop()
{
for(int i=0; i<200; i++) {
sum += analogRead(tempPin);
if(gyroCount == 20) {
gyroX = analogRead(gyroXPin);
gyroY = analogRead(gyroYPin);
gyroZ = analogRead(gyroZPin);
Serial.print(";X"+String(gyroX)+";Y"+String(gyroY)+";Z"+String(gyroZ)+";");
gyroCount = 0;
}
//delay(5);
gyroCount++;
}
if(flag) {
lastVal = sum;
}
if(abs((sum-lastVal)/lastVal) > 0.3) {
sum = lastVal;
}
//Serial.println(String(-sum/100));
Serial.print(";T"+String(-sum/100)+";");
Serial.print("R"+String(-sum/100)+";");
Serial.flush();
lastVal = sum;
sum = 0;
}
double doubleMap(double val, double dmax, double dmin, double toMax, double toMin) {
return (val-dmin)/(dmax-dmin)*(toMax-toMin)+toMin;
}
double antiAlias(double val, double lastVal, double pro) {
if(lastVal == 0) {
lastVal = 540;
}
return val > lastVal*(1+pro) ? lastVal*(1*pro) : val < lastVal*(1-pro) ? lastVal*(1-pro) : val;
}
| [
"[email protected]"
] | |
1be2ddbdc722a032f1a5087adb5b589e01e5af56 | 444d3d21f23de84826c1de287f1bb598e76838b2 | /SerialLED/SerialLED.ino | cd1fcc52f1a9530a2499f7a1d5e6332582600e2e | [] | no_license | Error57nk/Ardiuno_project | 244992386a3be410f973b7005a85046df7dcf734 | e5e6c26a8524e33a4d93758b05d5f69b80c511d8 | refs/heads/master | 2021-05-11T02:09:52.376057 | 2019-01-22T17:32:04 | 2019-01-22T17:32:04 | 118,351,638 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 262 | ino | void setup() {
pinMode(13, OUTPUT);
Serial.begin(9600);
digitalWrite(13,LOW);
}
void loop() {
if(Serial.available()>0)
{char letter = Serial.read();
if(letter == '1')
{
digitalWrite(13,HIGH);
}
if(letter == '2')
{
digitalWrite(13,LOW);
}
}}
| [
"[email protected]"
] | |
0fe389e4ef3627bdf203ae8f2e785aec42080a21 | 675743ef3e6ecf17cfcefcbf3356787dc3e298eb | /DeleteLinkedList.cpp | f8408b7c412d425bb42b8635ad6bdad80497998d | [] | no_license | VijayDachepally897/DataStructuresPractice | 6a6fca973445b80122b7c38beef470c0915268d7 | b0c6e95caa6faa31a00817c8d87b8a421257c060 | refs/heads/master | 2023-06-09T12:24:25.026806 | 2021-06-15T22:42:44 | 2021-06-15T22:42:44 | 376,374,487 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,314 | cpp | #include <iostream>
using namespace std;
class Node
{
public:
int data;
Node *next;
Node(int data)
{
this->data = data;
this->next = NULL;
}
};
Node *takeinput()
{
int data;
cin >> data;
Node *head = NULL, *tail = NULL;
while (data != -1)
{
Node *newNode = new Node(data);
if (head == NULL)
{
head = newNode;
tail = newNode;
}
else
{
tail->next = newNode;
tail = newNode;
}
cin >> data;
}
return head;
}
void print(Node *head)
{
Node *temp = head;
while (temp != NULL)
{
cout << temp->data << " ";
temp = temp->next;
}
cout << endl;
}
Node *deleteNode(Node *head, int i)
{
//Write your code here
if(head==NULL)
{
return NULL;
}
Node *temp = head;
Node *prev = NULL;
int count = 0;
if(i == 0){
head = temp -> next;
delete(temp);
}
//temp = head;
else{
while( i != count && temp){
prev = temp;
temp = temp -> next;
count++;
}
if(temp != NULL){
prev -> next = temp -> next;
delete (temp);
}
}
return head;
}
int main()
{
int t;
cin >> t;
while (t--)
{
Node *head = takeinput();
int pos;
cin >> pos;
head = deleteNode(head, pos);
print(head);
}
return 0;
} | [
"[email protected]"
] | |
d27baf03b2cadb823bb54128c5b54d9ef7ac882c | e8198fa744f5b3005457931172ebe822a47b3dea | /doodoowareV2/SourceSDK/Misc/SurfaceData.h | bd1c7300c201a5f340912ddbd89664fa6c1cc9c4 | [] | no_license | kwheatle/CSGO-Internal-Hack-v2 | b7df13b4038e0054621384e5ad95b61d1dd25a9b | b659d2e325f98a70887a5a6ef6175b2942383849 | refs/heads/master | 2021-06-26T07:56:18.865201 | 2021-02-04T02:25:58 | 2021-02-04T02:25:58 | 200,172,095 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,105 | h | #pragma once
#include "../../Interfaces.h"
struct surfacephysicsparams_t
{
float friction;
float elasticity;
float density;
float thickness;
float dampening;
};
struct surfaceaudioparams_t
{
float reflectivity; // like elasticity, but how much sound should be reflected by this surface
float hardnessFactor; // like elasticity, but only affects impact sound choices
float roughnessFactor; // like friction, but only affects scrape sound choices
float roughThreshold; // surface roughness > this causes "rough" scrapes, < this causes "smooth" scrapes
float hardThreshold; // surface hardness > this causes "hard" impacts, < this causes "soft" impacts
float hardVelocityThreshold; // collision velocity > this causes "hard" impacts, < this causes "soft" impacts
float highPitchOcclusion; //a value betweeen 0 and 100 where 0 is not occluded at all and 100 is silent (except for any additional reflected sound)
float midPitchOcclusion;
float lowPitchOcclusion;
};
struct surfacesoundnames_t
{
unsigned short walkStepLeft;
unsigned short walkStepRight;
unsigned short runStepLeft;
unsigned short runStepRight;
unsigned short impactSoft;
unsigned short impactHard;
unsigned short scrapeSmooth;
unsigned short scrapeRough;
unsigned short bulletImpact;
unsigned short rolling;
unsigned short breakSound;
unsigned short strainSound;
};
struct surfacegameprops_t
{
public:
float maxSpeedFactor;
float jumpFactor;
float flPenetrationModifier;
float flDamageModifier;
unsigned short material;
byte climbable;
char pad00[0x4];
};
struct surfacedata_t
{
surfacephysicsparams_t physics;
surfaceaudioparams_t audio;
surfacesoundnames_t sounds;
surfacegameprops_t game;
};
class IPhysicsProps
{
public:
surfacedata_t *GetSurfaceData(int surfaceDataIndex)
{
//typedef surfacedata_t*(__thiscall* fnGetSurfaceData)(void*, int);
return gInterface.CallVirtualFunction<surfacedata_t*>(this, 5, surfaceDataIndex);
}
};
| [
"[email protected]"
] | |
67a9e73f17033cbd9da742d3befa85c6fd789e3a | f0f4ba3a647721b697211021e8c6b93e04d0ad1f | /consecutiveSum/consecutiveSum.cpp | 26ad144ce598f90a4a27978a72b5446d2c543e67 | [] | no_license | mariobeaulieu/LunchChallenges | 7bfd1b4544bc779df9c8adfdafd3fa89f1743620 | 3ee1e327ea24346a4abce26eed9ab7e5fe5550c3 | refs/heads/master | 2023-03-16T13:39:23.122489 | 2023-03-12T21:30:08 | 2023-03-12T21:30:08 | 161,501,370 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 723 | cpp | #include <iostream>
using namespace std;
void findConsecutive(int myValues[], int myLen, int mySum) {
for (int i=0; i<myLen; i++) {
int total = 0;
for (int j=i; j<myLen; j++) {
total += myValues[j];
if ( total == mySum ) {
cout << "Sequence found!" << endl;
for (int k=i; k<j; k++)
cout << myValues[k] << " + ";
cout << myValues[j] << " = " << mySum << endl;
return;
}
}
}
cout << "No solution found" << endl;
}
int main() {
int values[] = {1,2,3,4,5,6,7,8,9};
int mySum = 22;
int myLen = end(values) - begin(values);
findConsecutive(values, myLen, mySum);
}
| [
"[email protected]"
] | |
56b2837fe86e28e6ff635a218562b0d80f69c1bb | fc056b2e63f559087240fed1a77461eb72b2bf8e | /src/server/gameserver/skill/EffectRapidFreeze.cpp | 88e2af39dd0e2f9e831fb0c16f5561a308d3782c | [] | no_license | opendarkeden/server | 0bd3c59b837b1bd6e8c52c32ed6199ceb9fbee38 | 3c2054f5d9e16196fc32db70b237141d4a9738d1 | refs/heads/master | 2023-02-18T20:21:30.398896 | 2023-02-15T16:42:07 | 2023-02-15T16:42:07 | 42,562,951 | 48 | 37 | null | 2023-02-15T16:42:10 | 2015-09-16T03:42:35 | C++ | UHC | C++ | false | false | 7,024 | cpp | //////////////////////////////////////////////////////////////////////////////
// Filename : EffectRapidFreeze.cpp
// Written by : rallser
// Description :
//////////////////////////////////////////////////////////////////////////////
#include "Effect.h"
#include "EffectRapidFreeze.h"
#include "Slayer.h"
#include "Vampire.h"
#include "Ousters.h"
#include "Monster.h"
#include "GamePlayer.h"
#include "SkillUtil.h"
#include "ZoneUtil.h"
#include "GCModifyInformation.h"
#include "GCStatusCurrentHP.h"
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
EffectRapidFreeze::EffectRapidFreeze(Zone* pZone, ZoneCoord_t zoneX, ZoneCoord_t zoneY)
{
__BEGIN_TRY
m_pZone = pZone;
m_X = zoneX;
m_Y = zoneY;
m_UserObjectID = 0;
m_Damage = 0;
__END_CATCH
}
void EffectRapidFreeze::checkPosition()
{
__BEGIN_TRY
for ( int i=-2; i<=2; ++i )
for ( int j=-2; j<=2; ++j )
{
int tx = m_X + i;
int ty = m_Y + j;
if ( !isValidZoneCoord( m_pZone, tx, ty ) ) continue;
Tile& tile = m_pZone->getTile(tx, ty);
// 타일 안에 존재하는 오브젝트들을 검색한다.
const forward_list<Object*>& oList = tile.getObjectList();
forward_list<Object*>::const_iterator itr = oList.begin();
for (; itr != oList.end(); itr++)
{
Assert(*itr != NULL);
Object* pObject = *itr;
Assert(pObject != NULL);
if (pObject->getObjectClass() == Object::OBJECT_CLASS_CREATURE)
{
Creature* pCreature = dynamic_cast<Creature*>(pObject);
Assert(pCreature != NULL);
m_TargetPositions[pCreature->getObjectID()].x = tx;
m_TargetPositions[pCreature->getObjectID()].y = ty;
}
}
}
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
void EffectRapidFreeze::affect()
{
__BEGIN_TRY
//cout << "EffectRapidFreeze" << "affect BEGIN" << endl;
Assert(m_pZone != NULL);
// 이펙트 사용자를 가져온다.
// 존에 없을 수 있으므로 NULL 이 될 수 있다.
Creature * pCastCreature = m_pZone->getCreature( m_UserObjectID );
for ( int i=-2; i<=2; ++i )
for ( int j=-2; j<=2; ++j )
{
int tx = m_X + i;
int ty = m_Y + j;
if ( !isValidZoneCoord( m_pZone, tx, ty ) ) continue;
// 현재 이펙트가 붙어있는 타일을 받아온다.
Tile& tile = m_pZone->getTile(tx, ty);
// 타일 안에 존재하는 오브젝트들을 검색한다.
const forward_list<Object*>& oList = tile.getObjectList();
forward_list<Object*>::const_iterator itr = oList.begin();
for (; itr != oList.end(); itr++)
{
Assert(*itr != NULL);
Object* pObject = *itr;
Assert(pObject != NULL);
if (pObject->getObjectClass() == Object::OBJECT_CLASS_CREATURE)
{
Creature* pCreature = dynamic_cast<Creature*>(pObject);
Assert(pCreature != NULL);
// 무적상태 체크. by sigi. 2002.9.5
// 산 면역. by sigi. 2002.9.13
if ( pCastCreature != NULL &&
( !canAttack( pCastCreature, pCreature )
|| pCreature->isFlag(Effect::EFFECT_CLASS_COMA)
|| !canHit( pCastCreature, pCreature, SKILL_Rapid_Freeze ) )
)
{
continue;
}
// 2003.1.10 by Sequoia
// 안전지대 체크
if( !checkZoneLevelToHitTarget( pCreature ) ) continue;
if (pCreature->getMoveMode() != Creature::MOVE_MODE_FLYING)
{
GCModifyInformation gcAttackerMI;
GCModifyInformation gcDefenderMI;
Damage_t damage = m_Damage;
unordered_map<ObjectID_t, TPOINT>::iterator itr = m_TargetPositions.find( pCreature->getObjectID() );
if ( itr == m_TargetPositions.end() )
{
// damage = m_Damage;
m_TargetPositions[pCreature->getObjectID()].x = pCreature->getX();
m_TargetPositions[pCreature->getObjectID()].y = pCreature->getY();
}
else
{
if ( itr->second.x == pCreature->getX() && itr->second.y == pCreature->getY() )
{
// damage = m_Damage;
}
else
{
m_TargetPositions[pCreature->getObjectID()].x = pCreature->getX();
m_TargetPositions[pCreature->getObjectID()].y = pCreature->getY();
damage /= 2;
}
}
if (pCreature->isSlayer())
{
Slayer* pSlayer = dynamic_cast<Slayer*>(pCreature);
::setDamage( pSlayer, damage, pCastCreature, SKILL_Rapid_Freeze, &gcDefenderMI, &gcAttackerMI, true, false );
Player* pPlayer = pSlayer->getPlayer();
Assert(pPlayer != NULL);
pPlayer->sendPacket(&gcDefenderMI);
}
else if (pCreature->isVampire())
{
Vampire* pVampire = dynamic_cast<Vampire*>(pCreature);
::setDamage( pVampire, damage, pCastCreature, SKILL_Rapid_Freeze, &gcDefenderMI, &gcAttackerMI, true, false );
Player* pPlayer = pVampire->getPlayer();
Assert(pPlayer != NULL);
pPlayer->sendPacket(&gcDefenderMI);
}
else if (pCreature->isMonster())
{
Monster* pMonster = dynamic_cast<Monster*>(pCreature);
::setDamage( pMonster, damage, pCastCreature, SKILL_Rapid_Freeze, NULL, &gcAttackerMI, true, false );
}
else continue; // 아우스터즈나 NPC 상대로... -_-
// 죽었으면 경험치준다. 음.....
if ( pCastCreature != NULL )
{
if (pCreature->isDead() && pCastCreature->isOusters())
{
Ousters* pCastOusters = dynamic_cast<Ousters*>( pCastCreature );
Assert( pCastOusters != NULL );
// int exp = computeCreatureExp(pCreature, 100, pCastOusters);
int exp = computeCreatureExp(pCreature, 70, pCastOusters);
shareOustersExp(pCastOusters, exp, gcAttackerMI);
}
}
// 성향 계산하기
/* if ( pCastCreature != NULL
&& pCastCreature->isPC()
&& pCreature->isPC()
)
{
computeAlignmentChange( pCreature, m_Damage, pCastCreature, &gcDefenderMI, &gcAttackerMI );
modifiedAttacker = true;
}*/
if ( gcAttackerMI.getShortCount() != 0 || gcAttackerMI.getLongCount() != 0 ) pCastCreature->getPlayer()->sendPacket(&gcAttackerMI);
}
}
}
}
setNextTime(10);
//cout << "EffectRapidFreeze" << "affect END" << endl;
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
void EffectRapidFreeze::unaffect()
{
__BEGIN_TRY
//cout << "EffectRapidFreeze" << "unaffect BEGIN" << endl;
Tile& tile = m_pZone->getTile(m_X, m_Y);
tile.deleteEffect(m_ObjectID);
//cout << "EffectRapidFreeze" << "unaffect END" << endl;
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
string EffectRapidFreeze::toString()
const throw()
{
__BEGIN_TRY
StringStream msg;
msg << "EffectRapidFreeze("
<< "ObjectID:" << getObjectID()
<< ")";
return msg.toString();
__END_CATCH
}
| [
"[email protected]"
] | |
6a20c90a55eccae226053d8bde824bef9241283d | 31aa5bc77f08ddc512672bcacba657fa32ab1bbd | /include/level/lvl_shotsBK.cpp | 19eb9e864dad136e617be9bdbbeaf38aa490d654 | [] | no_license | DerekSlagle/collide_scroll | 5fef6b1e98a6d24236a7b8a355ebc72ff0dd1bb2 | b50bbb6b5941f5129170c1836f23863c627ba909 | refs/heads/master | 2020-11-25T13:45:21.363357 | 2019-12-17T20:22:34 | 2019-12-17T20:22:34 | 228,693,962 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 29,166 | cpp | #include "lvl_shots.h"
//const size_t lvl_shots::bodyCntDigits = 3;
bool lvl_shots::init( )
{
// Level::usingMapView = true;
std::ifstream fin( "include/images/shipsFlapWedgeUfo_SSdata.txt" );
if( !fin ) { std::cout << "no shipSS data\n"; return false; }
ship_SS.init(fin);
ship_SS.img.createMaskFromColor( sf::Color::Black );
ship_SS.txt.update( ship_SS.img );
fin.close();
// mvHit::windowTopOpen = true;
fin.open("include/level/lvl_shots_data/gun_shot_data.txt");
if( !fin ) { std::cout << "\nNo gun_shot data"; return false; }
// load the gun and shots
theGun.init(fin);
shot shotTmp(fin);
shotTmp.init2( &ship_SS, 7, 1.0f );
fin >> shot::minVelSq;
fin >> floorDrag;
pGuidedShot = new guidedShot;
pGuidedShot->init(fin);
pGuidedShot->init2( &ship_SS, 7, 1.0f );
pGuidedShot->pTgt = nullptr;
clusterShot* pCS = new clusterShot;
pCS->init(fin);
pCS->init2( &ship_SS, 7, 1.0f );
pCS->p_FireFunc = [this](vec2d pos, vec2d dir, float speed) { return shot::fireShot(pRegShotVec,pos,dir,speed); };
fin.close();
theLaser.init( theGun.pos + theGun.wDir*theGun.W/2.0f, theGun.wDir, 1.0f, sf::Color::Red );
size_t numShots = 20;
pRegShotVec.reserve(numShots);
pBadShotVec.reserve(numShots);
pShotVec.reserve(numShots+2);
for( size_t i=0; i< numShots; ++i )
{
shot* pShot = new shot(shotTmp);
pShot->init2( &ship_SS, 7, 1.0f );
pRegShotVec.push_back( pShot );
pShotVec.push_back( pShot );
pBadShotVec.push_back( new shot(shotTmp) );
pBadShotVec.back()->img.setFillColor( sf::Color::Red );
// p_mhVec.push_back( static_cast<mvHit*>(pShot) );
}
pShotVec.push_back( pGuidedShot );
pXtraShotVec.push_back( pGuidedShot );
pShotVec.push_back( pCS );
pXtraShotVec.push_back( pCS );
XtraShotIdx = pXtraShotVec.size();
theGun.p_FireFunc = [this](vec2d pos, vec2d dir, float speed)
{
if( pXtraShotVec.size() > XtraShotIdx )
{
if( pXtraShotVec[XtraShotIdx]->onFire() )
{
pXtraShotVec[XtraShotIdx]->v = speed*dir;
pXtraShotVec[XtraShotIdx]->setPosition( pos + pXtraShotVec[XtraShotIdx]->project(dir)*dir );
return static_cast<mvHit*>( pXtraShotVec[XtraShotIdx] );
}
}
else if( pXtraShotVec.size() == XtraShotIdx ) return shot::fireShot(pRegShotVec,pos,dir,speed);
else if( pXtraShotVec.size()+1 == XtraShotIdx ) { theLaser.state = true; }
return static_cast<mvHit*>(nullptr);
};
joyButton* pJoyStk = ctUtil::init_gunControl( gunControl, theGun, 30.0f, 30.0f, theGun.bulletSpeed );
if( pJoyStk )
{
pJoyStk->pFunc_v2d = [this](vec2d r) { if( theGun.is_free ) theGun.v = 0.2f*r; };
}
gunControl.pHitFunc = [this](){ ship::pFireMh = gunControl.sel ? &theGun : nullptr; Level::pMHfling = ship::pFireMh; };
button::RegisteredButtVec.push_back( &gunControl );
numLoops = (size_t)( 1.0f + theGun.bulletSpeed/(0.8f*pShotVec[0]->r) );
std::cout << "\n init: numLoops = " << numLoops;
sf::Text label("shot type", *button::pFont, 12);
label.setColor( sf::Color(0,255,0) );
shotTypeList.init( 30.0f, 80.0f, 80.0f, 17.0f, 2+(size_t)pXtraShotVec.size(), label, (size_t)pXtraShotVec.size() );
shotTypeList.pFuncIdx = std::bind( [this](size_t i) { XtraShotIdx = i; }, std::placeholders::_1 );
button::RegisteredButtVec.push_back( &shotTypeList );
Level::pMHfling = nullptr;//&theGun;
target::pKillCount = &numFlips;
// an image
gun::pTxtr = new sf::Texture;
if( gun::pTxtr->loadFromFile( "include/images/guns/assaultRifle1.png" ) )
{
std::cout << "\n gun::Txtr loaded";
float szx = (float)gun::pTxtr->getSize().x, szy = (float)gun::pTxtr->getSize().y;
theGun.vtxVec[0].texCoords.x = szx-1.0f; theGun.vtxVec[0].texCoords.y = 1.0f;// up lt
theGun.vtxVec[1].texCoords.x = 1.0f; theGun.vtxVec[1].texCoords.y = 1.0f;// up rt
theGun.vtxVec[2].texCoords.x = 1.0f; theGun.vtxVec[2].texCoords.y = szy-1.0f;// dn rt
theGun.vtxVec[3].texCoords.x = szx-1.0f; theGun.vtxVec[3].texCoords.y = szy-1.0f;// dn lt
for( auto& vtx : theGun.vtxVec ) vtx.color = sf::Color::White;
}
else
{
delete gun::pTxtr;
gun::pTxtr = nullptr;
}
// fire pattern
fin.open("include/level/lvl_shots_data/firePattern_1.txt");
if( !fin ) { std::cout << "\nNo fire pattern data"; return false; }
firePatt1.init(fin);
fin.close();
int retVal = initTargetPath();
if( retVal != 0 ){ std::cout << "pathMover init fail..\n"; return false; }
std::vector<sf::Text> TitleVec;
std::vector< std::function<void(void)> > pFuncVec;
label.setColor( sf::Color(0,0,0) );
label.setString("path select"); TitleVec.push_back( label );
// label.setString("oval"); TitleVec.push_back( label );
// label.setString("fig8"); TitleVec.push_back( label );
// label.setString("fig8sm"); TitleVec.push_back( label );
// label.setString("fly 1"); TitleVec.push_back( label );
// label.setString("fly 2"); TitleVec.push_back( label );
for( const auto& str : pathNameVec ) { label.setString( str.c_str() ); TitleVec.push_back( label ); }
for( size_t i=0; i<velPathVec.size(); ++i) { label.setString("velPer"); TitleVec.push_back( label ); }
// pFuncVec.push_back( [](void) { std::cout << "\n path selector"; } );
pFuncVec.push_back( nullptr );
std::function<void(size_t)> pFuncAll = [this](size_t i)// regular paths
{
float s_st = 0.0f;
if( pathVec.size() > i && pathVec[i] )
{
float dt = pathLength(*pathVec[i])/(pTargetVec[0]->v*NshipsVec[i]);
size_t j = 0;// loop counter
for( auto& pTgt : pTargetVec )
{
if( !pTgt->inUse && pTgt->tLaunch < 0.0f )// target is avail
{
pTgt->pVelPer = nullptr;// path only
pTgt->reset( pathVec[i], s_st );
s_st+=dt;
if( ++j >= NshipsVec[i] ) break;// all ships found
}
}
if( button::registerUnique( &pathControl ) ) pathControl.setSel(false);
pathVtxVec.clear();
tracePath( *pathVec[i], 5.0f, pathVtxVec, sf::Color::Blue, sf::Color::Red );
// lastTgtCnt = 0;
}
};
for( size_t i=0; i<pathVec.size(); ++i) pFuncVec.push_back( [pFuncAll, i](void){ pFuncAll(i); } );
pFuncAll = [this](size_t i)// velPeriod paths
{
if( velPathVec.size() < i+1 ) return;
if( linLegVec.size() < 1 ) return;
button::unRegisterMe( &pathControl );
float t0 = 0.0f;
// lastTgtCnt = 0;
size_t j = 0;// loop counter
for( auto& pTgt : pTargetVec )
{
if( !pTgt->inUse && pTgt->tLaunch < 0.0f )// target is avail
{
pTgt->reset( &linLegVec[i], velPathVec[i], vec2d( 200.0f, 400.0f ), t0+=50.0f );
if( ++j >= 4 ) break;// all ships found
}
}
};
for( size_t i=0; i<velPathVec.size(); ++i) pFuncVec.push_back( [pFuncAll, i](void){ pFuncAll(i); } );
// block path
label.setString("block"); TitleVec.push_back( label );
pFuncVec.push_back( [this](void)
{
size_t j=0;
float s_st = 0.0f, dt = 30.0f;
size_t iPath = 0, rows = blockPathVec.size();
Leg* pLeg = blockPathVec[iPath];
for( auto& pTgt : pTargetVec )
{
if( !pTgt->inUse && pTgt->tLaunch < 0.0f )// target is avail
{
pTgt->pVelPer = nullptr;// path only
pTgt->reset( pLeg, s_st );
s_st+=dt;
if( ++j >= 9 ) break;// all ships found
iPath = (iPath+1)%rows;
pLeg = blockPathVec[iPath];
}
}
if( button::registerUnique( &pathControl ) ) pathControl.setSel(false);
} );
// free targets
label.setString("free"); TitleVec.push_back( label );
pFuncVec.push_back( [this](void)
{
// lastTgtCnt = 0;
float x0 = 0.0f;
size_t j=0;
for( auto& pTgt : pTargetVec )
{
// if( ++i > 4 ){ pTgt->inUse = false; continue; }
// pTgt->pVelPer=nullptr; pTgt->pLeg=nullptr;
// pTgt->reset( nullptr, nullptr, vec2d(x0+=250.0f,300.0f) );
if( !pTgt->inUse && pTgt->tLaunch < 0.0f )// target is avail
{
pTgt->pVelPer=nullptr; pTgt->pLeg=nullptr;
pTgt->reset( nullptr, nullptr, vec2d(x0+=250.0f,300.0f) );
if( ++j >= 4 ) break;// all ships found
}
}
button::unRegisterMe( &pathControl );
} );
pathSelect.init( 30.0f, 120.0f, 70.0f, 30.0f, 32.0f, TitleVec, pFuncVec );
pathSelect.persist = 2;
button::RegisteredButtVec.push_back( &pathSelect );
// fire pattern reset
label.setString("FP reset");
firePattButt.init( 50.0f, 600.0f, 50.0f, 25.0f, label );
firePattButt.mode = 'I';
firePattButt.pHitFunc = [this](void)
{
std::ifstream finFP("include/level/lvl_shots_data/firePattern_1b.txt");
if( !finFP ) { std::cout << "\nNo fire pattern data"; return; }
firePatt1b.velVec.clear();
firePatt1b.delayVec.clear();
firePatt1b.init(finFP);
finFP.close();
for( auto& s : pTargetVec )
{
ship* pShip = dynamic_cast<ship*>(s);
if( pShip ){ pShip->pFirePat = &firePatt1b; pShip->fp_time = 0.0f; pShip->fp_idx = 0; break; }// 1st ship only
}
};
button::RegisteredButtVec.push_back( &firePattButt );
// circular fire pattern
label.setString("FP circle");
circFPButt.init( 50.0f, 640.0f, 50.0f, 25.0f, label );
circFPButt.mode = 'I';
circFPButt.pHitFunc = [this](void)
{
std::ifstream finFP("include/level/lvl_shots_data/firePattern_1circ.txt");
if( !finFP ) { std::cout << "\nNo fire pattern data"; return; }
size_t Nshots; float vMag, dt, dtLong;
finFP >> Nshots >> vMag >> dt >> dtLong;
finFP.close();
makeCircleFP( firePatt1b, Nshots, vMag, dt, dtLong );
for( auto& s : pTargetVec )
{
ship* pShip = dynamic_cast<ship*>(s);
if( pShip ){ pShip->pFirePat = &firePatt1b; pShip->fp_time = 0.0f; pShip->fp_idx = 0; break; }// 1st ship only
}
};
button::RegisteredButtVec.push_back( &circFPButt );
// star field
starArea.left = starArea.top = 0.0f;
starArea.width = Level::winW;
starArea.height = Level::winH;
fin.open("include/level/lvl_shots_data/starField_1.txt");
if( !fin ) { std::cout << "\nNo star field data"; return false; }
fin >> starLayerPop[0] >> starLayerPop[1] >> starLayerPop[2];
fin >> starLayerVel[0] >> starLayerVel[1] >> starLayerVel[2];
fin.close();
starFieldInit( starLayerVec, 3, starLayerPop, starArea );
label.setString("STARS");
starButt.init( 50.0f, 680.0f, 50.0f, 25.0f, label );
starButt.setSel(true);
button::RegisteredButtVec.push_back( &starButt );
// floor drag
label.setString("floor drag");
dragStrip.init( 150.0f, 680.0f, 150.0f, 20.0f, label, 0.0f, 3.0f, floorDrag, &floorDrag );
button::RegisteredButtVec.push_back( &dragStrip );
// body cont
fin.open( "include/images/flipDigitsSS_data.txt" );
if( !fin ) { std::cout << "\nNo flipDigit SS data"; return false; }
flipDigit_SS.init(fin);
for( auto& bc : bodyCnt ) { bc.scale = 0.4f; bc.callRecursive = true; }
initFlipArray( bodyCnt, bodyCntDigits, flipDigit_SS, 0, sf::Vector2f(1050.0f,640.0f), 5.0f, 0.1f, 0.01f );
// goto main menu button
button::RegisteredButtVec.push_back( &Level::goto_MMButt );
return true;
}
bool lvl_shots::handleEvent( sf::Event& rEvent )
{
if ( rEvent.type == sf::Event::KeyPressed )
{
sf::Keyboard::Key K = rEvent.key.code;
if ( K == sf::Keyboard::F6 )// cycle target designated for guidedShot
{
if( pTargetVec.size() > 0 && pGuidedShot )
{
static size_t tgtIdx = 0;
// if( pTargetVec[tgtIdx]->inUse ) { pGuidedShot->pTgt = pTargetVec[tgtIdx]; pGuidedShot->pTgt->onHit(0.1f); }
// else pGuidedShot->pTgt = nullptr;
// tgtIdx = (1+tgtIdx)%pTargetVec.size();
// xcode
pGuidedShot->pTgt = nullptr;
size_t tgtIdx_curr = tgtIdx;
tgtIdx = (1+tgtIdx)%pTargetVec.size();
// try until wrap around on tgtIdx value
while( tgtIdx != tgtIdx_curr && !pTargetVec[tgtIdx]->inUse ) tgtIdx = (1+tgtIdx)%pTargetVec.size();
// if( tgtIdx != tgtIdx_curr ) { pGuidedShot->pTgt = pTargetVec[tgtIdx]; pGuidedShot->pTgt->onHit(0.1f); }
if( pTargetVec[tgtIdx]->inUse ) { pGuidedShot->pTgt = pTargetVec[tgtIdx]; pGuidedShot->pTgt->onHit(0.1f); }
}
}
else if ( K == sf::Keyboard::K )// kill all
{
for( auto& pTgt : pTargetVec ) pTgt->inUse = false;
}
else if( K == sf::Keyboard::Num1 ) numFlips += 1;
else if( K == sf::Keyboard::Num5 ) numFlips += 5;
}
return true;
}
void lvl_shots::update( float dt )
{
if( starButt.sel ) starFieldUpdate( starLayerVec, starLayerVel, starArea );
// v based numReps!
static float shotVelLast = theGun.bulletSpeed;
if( gunControl.sel && (theGun.bulletSpeed - shotVelLast)*(theGun.bulletSpeed - shotVelLast) > 1.0f )
{
numLoops = (size_t)( 1.0f + theGun.bulletSpeed/(0.8f*pShotVec[0]->r) );
std::cout << "\n init: numLoops = " << numLoops;
shotVelLast = theGun.bulletSpeed;
}
bool anyAliveNow = false;
static bool anyAliveLast = false;
for( auto& pTgt : pTargetVec )// pTgt->update();
{
if( !( pTgt->pLeg || pTgt->pVelPer ) )// apply drag
{
float magVel = pTgt->pMH->v.mag();
if( magVel > dt*floorDrag )
pTgt->pMH->v -= dt*floorDrag*pTgt->pMH->v/magVel;
else// just stop
pTgt->pMH->v *= 0.0f;
}
pTgt->update(dt);
if( pTgt->inUse ) anyAliveNow = true;
}
if( anyAliveLast && !anyAliveNow ) pathVtxVec.clear();// last Tgt just died
anyAliveLast = anyAliveNow;// maintain last value
if( gunControl.sel )
{
if( theGun.is_free )
{
float magVel = theGun.v.mag();
if( magVel > dt*floorDrag )
theGun.v -= dt*floorDrag*theGun.v/magVel;
else// just stop
theGun.v *= 0.0f;
}
theGun.update(dt);
theLaser.update( theGun.pos + theGun.wDir*theGun.W/2.0f, theGun.wDir );
if( pXtraShotVec.size()+1 == XtraShotIdx ) theLaser.state = theGun.is_firing;
}
// collision testing and response
// theLaser vs all targets
if( theLaser.state )
for( auto& pTgt : pTargetVec ) theLaser.hit( *pTgt );
for( size_t i=0; i+1< pTargetVec.size(); ++i )
for( size_t j=i+1; j< pTargetVec.size(); ++j )
if( pTargetVec[i]->inUse && pTargetVec[j]->inUse )
pTargetVec[i]->pMH->hit( *pTargetVec[j]->pMH );
// targets vs theGun
if( gunControl.sel ) for( auto& pTgt : pTargetVec ) if( pTgt->inUse ) pTgt->pMH->hit( theGun );
// xcode. Targets vs shots
if( pTargetVec.size() > 0 )
for( auto& pShot : pShotVec )
{
if( pShot->inUse ) update_hit_shot( pShot, dt );
else pShot->update(dt);// run death animation
}
// bad shots vs theGun
for( auto& pShot : pBadShotVec )
{
if( pShot->inUse )
{
float step = 2.0f;
if( gunControl.sel && willHitMvHit( pShot, &theGun, step ) )
{
vec2d vRel = pShot->v - theGun.v;
float vRelMag = vRel.mag();
float babyStepNum = vRelMag/(0.8f*pShot->r);
float i = step*vRelMag;
float dt_lo = dt/babyStepNum;
pShot->update( i*dt_lo );// big step
// baby steps
for( ; i<vRelMag; i += vRelMag/babyStepNum )
{
pShot->update(dt_lo);
if( pShot->hit(theGun) ) break;
}
if( i < vRelMag ) pShot->update( (vRelMag-i)*dt_lo );
}
else pShot->update(dt);
}
else pShot->update(dt);
}
// body count
// int currCnt = 0;
// for( const auto& pTgt : pTargetVec ) if( pTgt->inUse ) ++currCnt;
// if( currCnt < lastTgtCnt ) numFlips += lastTgtCnt - currCnt;
// lastTgtCnt = currCnt;
if( numFlips > 0 ) if( !bodyCnt->flipping ) { bodyCnt->initFlip(); --numFlips; }
// updateFlipArray( bodyCnt, bodyCntDigits );
bodyCnt->updateFlipDisplay();
return;
}
// used by update() above
void lvl_shots::update_hit_shot( shot* pShot, float dt )
{
// find how many steps to the nearest target the shot is moving towards
float stepsMin = 2.0f;
target* pNearTgt = nullptr;// this may remain true. shot may then full step. No collision will ocurr
for( auto& pTgt : pTargetVec )// find stepsMin
{
if( !pTgt->inUse ) continue;
// new
float steps = 1.0f;
if( willHitMvHit( pShot, pTgt->pMH, steps ) )
{
if( !pNearTgt ) { stepsMin = steps; pNearTgt = pTgt; }// no initial value yet
else if( steps < stepsMin ) { stepsMin = steps; pNearTgt = pTgt; }
}
}
// hit test against a lineSeg
/* if( !Lseg.is_bulletProof )
{
vec2d sepSeg = Lseg.getNearestPoint( pShot->pos );
float sepSegMag = sepSeg.mag();
sepSegMag -= pShot->r;
vec2d sep_u = sepSeg/sepSegMag;// unit vector toward target
float vt = sep_u.dot( pShot->v );// velocity component toward target
if( vt > 0.0f )// shot is moving towards target
{
if( vt < 0.1f ) vt = 0.1f;// reasonable minimum. Avoid div by 0 on line below
float steps = sepSegMag/vt;
if( !pNearTgt || steps < stepsMin )
{
if( steps < 1.0f )// baby step
{
float dt_lo = dt/(float)numLoops;
for( size_t i=0; i< numLoops; ++i )
{
pShot->update(dt_lo);
Lseg.hit( *pShot );// test against only the nearest target
}
return;// next shot
}
}
}
}// end vs non bullet proof Lseg */
// some data collection. How often do shots full step vs baby step?
static int fullStepCnt = 0, babyStepCnt = 0;
if( stepsMin > 1.0f || !pNearTgt ) { pShot->update(dt); ++fullStepCnt; }// full step OK
else
{
// baby step it
float dt_lo = dt/(float)numLoops;
size_t i = (size_t)(numLoops*stepsMin);// big initial step
pShot->update(dt_lo*(float)i);
for( ; i< numLoops; ++i )// baby steps until hit occurs
{
pShot->update(dt_lo);
if( pShot->hit( *pNearTgt ) ) break;// test against only the nearest target
}
if( numLoops > i ) pShot->update( dt_lo*(float)(numLoops-i) );// remainder of step
// stats out
if( ++babyStepCnt%10 == 0 ) std::cout << "\n fullSteps: " << fullStepCnt << " babySteps: " << babyStepCnt << " F/B = " << fullStepCnt/babyStepCnt;
}
return;
}
// non member
bool willHitMvHit( shot* pShot, mvHit* pMh, float& stepFrac )
{
vec2d sep = pMh->pos - pShot->pos;
float sepMag = sep.mag();
sepMag -= pMh->r + pShot->r;// now distance between surfaces not centers
if( sepMag < 0.0f ) { stepFrac = 0.0f; return true; }// hit test this one right away! Already overlapped
vec2d sep_u = sep/sepMag;// unit vector toward target
vec2d vRel = pShot->v - pMh->v;
float vt = sep_u.dot( vRel );// velocity component toward target
if( vt > 0.0f )// shot is moving towards target
{
if( vt < 0.1f ) vt = 0.1f;// reasonable minimum. Avoid div by 0 on line below
float steps = sepMag/vt;
if( steps < 1.0f )
{
vec2d vRelu = vRel/vRel.mag();
float miss = sep.cross( vRelu );
if( miss < pShot->r+pMh->r && miss > -(pShot->r+pMh->r) )// will hit
{
stepFrac = steps;
return true;
}
}
}
return false;
}
void lvl_shots::draw( sf::RenderTarget& RT ) const
{
if( starButt.sel ) starFieldDraw( starLayerVec, RT );
if( pathVtxVec.size() > 1 ) RT.draw( &pathVtxVec[0], pathVtxVec.size(), sf::LinesStrip );
for( auto& pTgt : pTargetVec ) pTgt->draw(RT);
for( auto& pShot : pShotVec ) pShot->draw(RT);
for( auto& pShot : pBadShotVec ) pShot->draw(RT);
if( gunControl.sel ) { theGun.draw(RT); theLaser.draw(RT); }
// drawFlipArray( bodyCnt, bodyCntDigits, RT );
bodyCnt->draw(RT);
return;
}
void lvl_shots::cleanup()
{
std::cout << "\nlvl_shots: deleting " << pRegShotVec.size() << " regular shots";
for( auto& x : pRegShotVec ) delete x;
pRegShotVec.clear();
std::cout << "\nlvl_shots: deleting " << pXtraShotVec.size() << " extra shots";
for( auto& x : pXtraShotVec ) delete x;
pXtraShotVec.clear();
std::cout << "\nlvl_shots: deleting " << pRegShotVec.size() << " baddie shots";
for( auto& x : pBadShotVec ) delete x;
pBadShotVec.clear();
std::cout << "\nlvl_shots: deleting " << pTargetVec.size() << " targets from path";
for( auto& x : pTargetVec ) { if( x->pMH ) delete x->pMH; delete x; }
pTargetVec.clear();
for( auto& x : pathVec ) { if( x ) std::cout << "\ndestroying " << destroyPath( x ) << " Legs"; }
pathVec.clear();
for( auto& x : velPathVec ) { if( x ) std::cout << "\ndestroying " << destroyVelPath( x ) << " velPeriods\n"; }
velPathVec.clear();
for( auto& x : blockPathVec ) { if( x ) std::cout << "\ndestroying " << destroyPath( x ) << "block paths\n"; }
velPathVec.clear();
if( gun::pTxtr )// see init() and pGun
{
delete gun::pTxtr;
gun::pTxtr = nullptr;
std::cout << "\nlvl1 cleanup: gun::Txtr deleted";
}
return;
}
int lvl_shots::initTargetPath()
{
std::ifstream fin("include/level/lvl_shots_data/velPeriod_list.txt");
if( !fin ) { std::cout << "\nNo velPeriod data"; return 17; }
std::string pathFname;
std::ifstream finPath;
while( fin >> pathFname )
{
pathFname = "include/level/lvl_shots_data/velPeriodData/" + pathFname + ".txt";
finPath.open( pathFname.c_str() );
if( !finPath ) continue;
velPathVec.push_back( makeVelPath(finPath) );
finPath.close();
}
fin.close();
// load pPath, load targets
fin.open( "include/level/lvl_shots_data/path_data1.txt" );
if( !fin ) return 3;
size_t numRegPaths = 0;
fin >> numRegPaths;
pathVec.reserve(numRegPaths+5);// extra for 2 flyPaths + 3*func path
pathNameVec.reserve(numRegPaths+5);// extra for 2 flyPaths + 3*func path
for( size_t i=0; i<numRegPaths; ++i )
{
fin >> pathFname;
pathNameVec.push_back( pathFname );
pathFname = "include/Leg_types/paths/" + pathFname + ".txt";
finPath.open( pathFname.c_str() );
if( !finPath ) return 4;
pathVec.push_back(nullptr);
makePath( finPath, pathVec.back() );
finPath.close();
}
// spiral path
fin >> pathFname;
pathNameVec.push_back( pathFname );
pathFname = "include/Leg_types/paths/" + pathFname + ".txt";
finPath.open( pathFname.c_str() );
if( !finPath ) return 5;
pathVec.push_back(nullptr);
makeFuncPath( finPath, pathVec.back() );
finPath.close();
// cubic path
fin >> pathFname;
pathNameVec.push_back( pathFname );
pathFname = "include/Leg_types/paths/" + pathFname + ".txt";
finPath.open( pathFname.c_str() );
if( !finPath ) return 5;
pathVec.push_back(nullptr);
makeFuncPath( finPath, pathVec.back() );
finPath.close();
// heart path
fin >> pathFname;
pathNameVec.push_back( pathFname );
pathFname = "include/Leg_types/paths/" + pathFname + ".txt";
finPath.open( pathFname.c_str() );
if( !finPath ) return 5;
pathVec.push_back(nullptr);
makeFuncPath( finPath, pathVec.back() );
finPath.close();
// the 2 fly paths
fin >> pathFname;
pathNameVec.push_back( pathFname );
pathFname = "include/Leg_types/paths/" + pathFname + ".txt";
finPath.open( pathFname.c_str() );
if( !finPath ) return 6;
pathVec.push_back(nullptr);
makeFlyPath_lin( finPath, pathVec.back() );
finPath.close();
fin >> pathFname;
pathNameVec.push_back( pathFname );
pathFname = "include/Leg_types/paths/" + pathFname + ".txt";
finPath.open( pathFname.c_str() );
if( !finPath ) return 7;
pathVec.push_back(nullptr);
makeFlyPath_cir( finPath, pathVec.back() );
finPath.close();
NshipsVec.reserve( pathVec.size() );
for(size_t i=0; i<pathVec.size(); ++i)
{
float Nships = 0;
fin >> Nships;
NshipsVec.push_back( Nships );
}
std::vector< mvHit* > pMH_pathVec;
if( !load_mvHits( fin, pMH_pathVec ) ) return 8;
size_t numMvHits = pMH_pathVec.size();
for( size_t i=0; i<velPathVec.size(); ++i ) linLegVec.push_back( linLeg( 200.0f*(i+1), 40.0f, 200.0f*(i+1), 300.0f ) );
size_t iPathIdx = 0;
Leg* pLeg = pathVec[iPathIdx];
float v = 4.0f;
// size_t Nships = 3;
float dt = pathLength(*pLeg)/(v*NshipsVec[iPathIdx]);
float s_st = 0.0f;
pTargetVec.reserve( 2*numMvHits );
for( size_t i=0; i < numMvHits; ++i )
{
size_t setnum = 0;
fin >> setnum;
char tgtType = 't';// or 's' for ship
fin >> tgtType;
ship* pShip = nullptr;
target* pTgt = nullptr;
if( tgtType == 's' )// ship
{
pShip = new ship( pLeg, pMH_pathVec[i], v, 0.0f );//s_st );
pTgt = static_cast<target*>(pShip);
pShip->shotOfst = vec2d( 0.0f, pShip->pMH->r + 5.0f );
pShip->pFirePat = &firePatt1;
pShip->fp_time = -100.0f;
fin >> pShip->fireOnTarget;
pShip->pFireFunc = [this](vec2d pos, vec2d dir, float speed) { return shot::fireShot(pBadShotVec,pos,dir,speed); };
}
else // target
pTgt = new target( pLeg, pMH_pathVec[i], 4.0f, 0.0f );//s_st );
if( pTgt )
{
pTargetVec.push_back( pTgt );
pTgt->pVelPer = velPathVec.size() > 0 ? velPathVec[0] : nullptr;
if( !pLeg && pTgt->pVelPer ) pTgt->oldPos = pTgt->pVelPer->v0;
pTgt->mode = 'd';
pTgt->init2( &ship_SS, setnum );
pTgt->setH = 1 + setnum;
pTgt->setK = 8;
// if( i < NshipsVec[iPathIdx] ) pTgt->tLaunch = s_st;
// else pTgt->tLaunch = -1.0f;
pTgt->tLaunch = -1.0f;
pTgt->inUse = false;
pTgt->frIdx = pTgt->pSS->getFrCount( setnum );
s_st += dt;
}
}
fin.close();
for( size_t i=0; i < numMvHits; ++i )
pTargetVec.push_back( pTargetVec[i]->clone() );
// block path
fin.open( "include/level/lvl_shots_data/blockPath1.txt" );
if( !fin ) { std::cout << "\nNo block path data"; return 17; }
makeBlockPath( fin, blockPathVec );
fin.close();
// init control
fin.open("include/level/lvl_shots_data/control_data.txt");
if( !fin ) return 9;
char mvMode = 'd';
fin >> mvMode;
float Fk_min, Fk_max;
fin >> Fk_min >> pathMover::Fk >> Fk_max;
float Fd_min, Fd_max;
fin >> Fd_min >> pathMover::Fd >> Fd_max;
float v_min, v_0, v_max;
fin >> v_min >> v_0 >> v_max;
fin.close();
vec2d Cpos;
sf::Text label("Path", *button::pFont, 12);
label.setColor( sf::Color(0,0,0) );
Cpos.x = 50.0f; Cpos.y = 560.0f;
pathControl.init( Cpos.x, Cpos.y, 50.0f, 25.0f, label );
pathControl.persist = 3;
pathControl.ownButts = true;
// pathControl.inDefView = false;
label.setString("path speed");
pathControl.pButtVec.push_back( new slideBar( Cpos.x+70, Cpos.y-50, 150, 20, label, v_min, v_max, v_0, std::bind( [this](float v) { for( auto& x : this->pTargetVec ) x->v = v; }, std::placeholders::_1 ) ) );
label.setString("spring K");
pathControl.pButtVec.push_back( new buttonValOnHit( Cpos.x+70, Cpos.y, 150, 20, label, Fk_min, Fk_max, pathMover::Fk, &pathMover::Fk ) );
label.setString("damping");
pathControl.pButtVec.push_back( new buttonValOnHit( Cpos.x+70, Cpos.y+50, 150, 20, label, Fd_min, Fd_max, pathMover::Fd, &pathMover::Fd ) );
button::RegisteredButtVec.push_back( &pathControl );
return 0;// all good!
}
| [
"[email protected]"
] | |
7aefabaeab15ca48a9352347934f738a96e65e0e | efae7ce5a62469f4189288add3bc2d5939f9ff40 | /【图】Dijistra算法.cpp | 4775fb46eb08b2d7f170251a360e44c72e227eb1 | [] | no_license | Eziotic/learngit | 46fb79fe115d4d12d19b9cf8e6ea74588e15e6c3 | 65c8b535c8f172ccba63a492c3903be7731441be | refs/heads/master | 2021-05-22T13:36:41.302724 | 2021-02-01T00:52:56 | 2021-02-01T00:52:56 | 252,948,780 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 3,219 | cpp | //prim算法求最小生成树
//参考资料：https://blog.csdn.net/u011068702/article/details/79155571
/*
①除了v0顶点外权值初始化到D[v]
②一次循环：w1→k→w2 ,parent[w] = k
③
*/
#include<stdio.h>
#include<stdlib.h>
#define MAX 65500
#define MAX_VERTEX_NUM 20
#define OK 1
#define ERROR 0
typedef enum {DG,DN,UDG,UDN}GraphKind;
typedef char VertexData;
typedef struct ArcNode{
int adj;
}ArcNode;
typedef struct{
VertexData vertex[MAX_VERTEX_NUM];
ArcNode arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
int vexnum,arcnum;
}AdjMatrix;
int LocateVertex(AdjMatrix *G, VertexData v)
{
int j=ERROR,k;
for( k=0; k<G->vexnum; k++)
{
if(G->vertex[k] == v)
{
j=k;break;
}
}
return j;
}
//创建有向图
int CreateDN(AdjMatrix *G)
{
int i,j,k,w;
VertexData v1,v2;
printf("请输入图的顶点数和弧数，用空格隔开\n");
scanf("%d %d",&G->vexnum, &G->arcnum);
getchar();
for(i=0; i<G->vexnum; i++)
for(j=0; j<G->vexnum; j++)
{
G->arcs[i][j].adj = MAX;
}
printf("请输入图的顶点,用空格隔开\n");
for(i=0; i<G->vexnum; i++)
{
scanf("%c",&G->vertex[i]);
getchar(); //在输入字符后，我们通常回输出空格或者回车符，在向
//字符变量输入字符时，我们要将之前输入的空格或者回
//车符从缓冲区中清楚，这也就是程序中getchar()的用处
}
printf("请输入一条边的两个顶点，用空格隔开\n");
for(k=0; k<G->arcnum; k++)
{
scanf("%c %c %d",&v1, &v2, &w);
getchar();
i = LocateVertex(G, v1);
j = LocateVertex(G, v2);
G->arcs[i][j].adj = w;
}
/* for(i=0; i<G->vexnum; i++)
{
for(j=0; j<G->vexnum; j++)
{
printf("%d ",G->arcs[i][j].adj);
}
printf("\n");
}*/
return OK;
}
void Dijkstra(AdjMatrix G,int v0)
{
int v,k,w,min;
int final[100];
int parent[100];
int D[v];
for(v=0; v<G.vexnum; v++)
{
final[v] = 0; //全部顶点初始化为未找到最短路径
D[v] = G.arcs[v0][v].adj; //将与v0点有连线的顶点加上权值
parent[v] = 0; //初始化路径数组p为 0
}
D[v0] = 0;
final[v0] = 1;
//开始主循环，每次求得v0到某个v顶点的最短路径
for(v=0; v<G.vexnum; v++)
{
min = MAX;
for(w=0; w<G.vexnum; w++)
{
if( !final[w] && D[w]<min )
{
k = w;
min = D[w];
}
}
final[k] = 1; //将目前找到的最近的顶点置1
//修正当前最短路径及距离
for(w=0; w<G.vexnum; w++)
{
if( !final[w] && (min+G.arcs[k][w].adj < D[w]))
{
D[w] = min + G.arcs[k][w].adj;
parent[w] = k;
}
}
}
for(int i=1; i<=G.vexnum; i++)
{
printf("当前位置到%d点距离为：%d\n",i,D[i-1]);
}
}
main()
{
AdjMatrix G; //注意这里不要建立指针
CreateDN(&G);
int n;
printf("请输入当前位置编号：");
scanf("%d",&n);
n-=1;
Dijkstra(G,n);
return OK;
}
/*
7 9
1 2 3 4 5 6 7
1 2 28
1 6 10
2 3 16
2 7 14
3 4 12
4 5 22
4 7 18
5 6 25
5 7 24
*/
| [
"[email protected]"
] | |
076fba7d8deb06569ec7a87374b7298ce27db7d4 | 116f7c27281333b8f14b5f55953bd55a4a101b4a | /linked_stack.cpp | 541de1ca222d6930eadb2a6cf5e88f8d2cc0db2b | [] | no_license | Laha988017/c-pro | 56aa393a6b6a19b563f36105ae2133fe912c019f | 25cd1466bd56b9fca0b8c414bc34ee1068d6518c | refs/heads/master | 2020-09-13T08:14:39.459880 | 2019-11-19T13:53:38 | 2019-11-19T13:53:38 | 222,707,269 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,477 | cpp | #include<iostream>
#include<stdlib.h>
using namespace std;
class stack{
int ele;
struct stack *link;
public:
stack *Push(stack *);
stack *Pop(stack *);
void Display(stack *);
}*top=NULL,*ptr=NULL;
stack * stack::Push(struct stack * top){
ptr=new stack;
if(ptr==NULL){
cout<<"\nSpace not allocated";
return top;
}
ptr->link=NULL;
cout<<"\nEnter the element:";
cin>>ptr->ele;
if(top==NULL)
top=ptr;
else{
ptr->link=top;
top=ptr;
}
return top;
}
stack * stack::Pop(struct stack * top){
if(top==NULL){
cout<<"\nUnderflow";
return top;
}
cout<<endl<< top->ele <<" deleted from stack\n";
ptr=top;
top=top->link;
delete ptr;
return top;
}
void stack:: Display(struct stack * top){
for(ptr=top;ptr!=NULL;ptr=ptr->link)
cout<< ptr->ele <<" ";
}
int main(){
int choice;
stack ob;
cout<<"\nMenu:\n1.Push in stack\n2.Pop from stack\n3.Display stack\n4.Exit\n";
do{
cout<<"\nEnter your choice:";
cin>>choice;
switch(choice){
case 1: top=ob.Push(top);
ob.Display(top);
break;
case 2: top=ob.Pop(top);
ob.Display(top);
break;
case 3: ob.Display(top);
break;
case 4: exit(0);
default: cout<<"\nWrong choice";
}
}while(choice!=4);
return 0;
}
| [
"[email protected]"
] | |
ac0a0853347304211e1f5c4fbbc0fecf2fc6c114 | 982d8a928afef8b38235571cdf1853c0b5569c6d | /src/hid/input.h | 8788b5fc0c882a6ef45498cdfcd0fdc6ff6c7fd6 | [] | no_license | siquel/VisualEffect | 2dd57edb475e5bc343534e28853e67228dafe8df | be889ef4fe5f78639be928ddba151024db790d80 | refs/heads/master | 2020-05-22T01:45:50.451508 | 2017-01-18T18:23:29 | 2017-01-18T18:23:29 | 64,849,266 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,445 | h | #pragma once
#include <stdint.h>
namespace visef
{
struct InputDeviceType
{
enum Enum
{
Keyboard,
Mouse,
Gamepad,
Count
};
};
struct Key
{
enum Enum {
KeyA = 0, ///< The A key
KeyB, ///< The B key
KeyC, ///< The C key
KeyD, ///< The D key
KeyE, ///< The E key
KeyF, ///< The F key
KeyG, ///< The G key
KeyH, ///< The H key
KeyI, ///< The I key
KeyJ, ///< The J key
KeyK, ///< The K key
KeyL, ///< The L key
KeyM, ///< The M key
KeyN, ///< The N key
KeyO, ///< The O key
KeyP, ///< The P key
KeyQ, ///< The Q key
KeyR, ///< The R key
KeyS, ///< The S key
KeyT, ///< The T key
KeyU, ///< The U key
KeyV, ///< The V key
KeyW, ///< The W key
KeyX, ///< The X key
KeyY, ///< The Y key
KeyZ, ///< The Z key
Key0, ///< The 0 key
Key1, ///< The 1 key
Key2, ///< The 2 key
Key3, ///< The 3 key
Key4, ///< The 4 key
Key5, ///< The 5 key
Key6, ///< The 6 key
Key7, ///< The 7 key
Key8, ///< The 8 key
Key9, ///< The 9 key
F1, ///< The F1 key
F2, ///< The F2 key
F3, ///< The F3 key
F4, ///< The F4 key
F5, ///< The F5 key
F6, ///< The F6 key
F7, ///< The F7 key
F8, ///< The F8 key
F9, ///< The F9 key
F10, ///< The F10 key
F11, ///< The F11 key
F12, ///< The F12 key
F13, ///< The F13 key
F14, ///< The F14 key
F15, ///< The F15 key
F16, ///< The F16 key
F17, ///< The F17 key
F18, ///< The F18 key
F19, ///< The F19 key
F20, ///< The F20 key
F21, ///< The F21 key
F22, ///< The F22 key
F23, ///< The F23 key
F24, ///< The F24 key
NumPad0, ///< The numpad 0 key
NumPad1, ///< The numpad 1 key
NumPad2, ///< The numpad 2 key
NumPad3, ///< The numpad 3 key
NumPad4, ///< The numpad 4 key
NumPad5, ///< The numpad 5 key
NumPad6, ///< The numpad 6 key
NumPad7, ///< The numpad 7 key
NumPad8, ///< The numpad 8 key
NumPad9, ///< The numpad 9 key
Escape, ///< The Escape key
LControl, ///< The left Control key
LShift, ///< The left Shift key
LAlt, ///< The left Alt key
LSystem, ///< The left OS specific key
RControl, ///< The right Control key
RShift, ///< The right Shift key
RAlt, ///< The right Alt key
RSystem, ///< The right OS specific key
Menu, ///< The Menu key
Return, ///< The Enter key
Tab, ///< The Tab key
Backspace, ///< The backspace key
Space, ///< The Space key
Up,
Down,
Left,
Right,
Insert,
Delete,
Home,
End,
PageUp,
PageDown,
Print,
Plus,
Minus,
LeftBracket,
RightBracket,
Semicolon,
Quote,
Comma,
Period,
Slash,
Backslash,
Tilde,
CapsLock,
ScrollLock,
Multiply, ///< The numpad multiply key
Divide, ///< The numpad divide key
Pause,
Add, ///< The numpad add key
Subtract, ///< The numpad subtract key
Numlock,
Application, ///< The applications key
Count
};
};
const char* getKeyName(uint8_t key);
struct InputDevice
{
const static uint32_t MaxKeys = 256;
InputDevice(uint8_t numKeys);
~InputDevice();
bool isPressed(uint8_t key) const;
bool isReleased(uint8_t key) const;
void setKeyState(uint8_t key, bool state);
void update();
uint8_t m_numButtons;
uint8_t m_lastState[MaxKeys];
uint8_t m_state[MaxKeys];
};
} | [
"[email protected]"
] | |
1b3ba4a526aa68a933449379ce8693f114f0af0c | b41ad12268cb55c2a710f88dc54b91a2c85b0b35 | /Envelope/cadsrcontrol.h | 55925fc71fe1234345bd4717e6586a164d1e600a | [] | no_license | JoelDreaver/Object-Studio | 3c5401d0d7e853835298a4d2b22d2d855bcbebce | c59559dac73b924b738197a1f6e8654e647979b5 | refs/heads/master | 2021-12-02T13:52:06.839234 | 2013-07-09T00:13:39 | 2013-07-09T00:13:39 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,168 | h | #ifndef CADSRCONTROL_H
#define CADSRCONTROL_H
#include "qcanvas.h"
#include "cadsr.h"
namespace ADSRControl
{
const int ADSR_MaxTime=2000;
const int ADSR_ReleaseStart=ADSR_MaxTime*3;
const int ADSR_MaxWidth=ADSR_MaxTime*4;
}
namespace Ui {
class CADSRControl;
}
class CADSRControl : public QCanvas
{
Q_OBJECT
public:
enum SplitterValuesADSR
{svADSRNone,svAttack,svDecay,svSustain,svRelease};
explicit CADSRControl(QWidget *parent = 0);
~CADSRControl();
public slots:
void Draw(CADSR::ADSRParams ADSRParams);
protected:
void mousePressEvent(QMouseEvent *event);
void mouseMoveEvent(QMouseEvent *event);
void mouseReleaseEvent(QMouseEvent *event);
void resizeEvent(QResizeEvent *event);
signals:
void Changed(CADSR::ADSRParams ADSRParams);
private:
Ui::CADSRControl *ui;
int inline Time2X(int Time);
int inline Vol2Y(int Vol);
int inline X2Time(int X);
int inline Y2Vol(int Y);
void inline MoveLines(QPoint P);
void inline PutPoint(QPoint P,SplitterValuesADSR SV);
bool MD;
QPoint OldPoint;
SplitterValuesADSR SplitValue;
CADSR::ADSRParams AP;
};
#endif // CADSRCONTROL_H
| [
"[email protected]"
] | |
30d5da65d2c45a2019a336db4eb3a2d875f46f6e | 5aa8a54280f446fa38b841922e1cd9c99e8e862f | /Math/2SAT/prog.cpp | c749b3d2e3b13ca6283efeeebbdb752b3573e004 | [] | no_license | lucasturci/Competitive_Programming | 72a458f8ed11a434d067f9cdf749b934da369339 | 8323aa16bcded05d2de83d057c51ace5fd63cfca | refs/heads/master | 2021-06-15T02:17:14.141431 | 2021-02-02T00:50:53 | 2021-02-02T00:50:53 | 130,897,029 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,856 | cpp | /*
Esse programa recebe como entrada uma formula booleana f, por exemplo:
f = (x1 | x2) & (x3 | x1) & (x3 | x5) & (x2 | x4),
em que x_i (1 <= i <= 5) sao as variaveis booleanas, e o objetivo do programa eh encontrar
valores para essas variaveis de modo que f seja true.
Para que f seja true, cada termo entre parenteses deve ser true, logo temos que satisfazer cada termo.
Cada termo entre parenteses pode ser escrito como uma implicacao, pelo seguinte lema:
[ ~a => b ] <=> [ a | b ]
Logo [ x1 | x2 ] pode ser escrito como [ ~x1 => x2 ], [ x3 | x1 ] pode ser escrito como [ ~x1 => x3 ] etc.
As implicacoes sao transitivas, entao se a => b e b => c, entao a => c. Vamos denotar as implicacoes derivadas de transitividade por '==>'.
Entao nesse caso a ==> c
Solucao:
Se existir alguma serie de implicacoes tal que [ a ==> ~a & ~a ==> a ], entao isso eh equivalente a [ (~a | ~a) & (a | a) ] <=> [a & ~a] <=> 0
Logo, podemos dizer que f nao tem solucao. Com outras palavras, se a e ~a estiverem no mesmo componente conexo (formarem um ciclo)
entao f nao tem solucao
Caso contrario, em uma ordenacao topologica das arestas de implicacao, temos ou a ==> ~a, ou ~a ==> a.
O primeiro caso equivale a [ ~a | ~a ]. Escolhemos a = 0
O segundo caso equivale a [a | a]. Escolhemos a = 1
Fazendo isso para todas as variaveis, encontramos uma solucao possivel para f
*/
#include <bits/stdc++.h>
using namespace std;
int n, m;
const int N = 100007;
int vis[N+N], col[N+N], cnt[N+N], tim[N+N];
vector<int> topo, e[N+N], rev[N+N];
void dfs(int u) {
vis[u] = 1;
for(int v : e[u])
if(vis[v] == 0) dfs(v);
topo.push_back(u);
}
void colorfy(int u, int c) {
col[u] = c;
cnt[c]++;
for(int v : rev[u])
if(col[v] == 0) colorfy(v, c);
}
int t;
void dfs2(int u) {
vis[u] = 1;
cnt[col[u]]--;
for(int v : e[u])
if(vis[v] == 0) dfs2(v);
if(cnt[col[u]] == 0) tim[col[u]] = ++t;
}
int main() {
ios::sync_with_stdio(0); cin.tie(0);
// n = numero de variaveis m = numero de termos da formula de f
cin >> n >> m;
for(int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
int na = a < 0, nb = b < 0;
if(na) a = -a;
if(nb) b = -b;
e[2 * a + !na].push_back(2 * b + nb);
rev[2 * b + nb].push_back(2 * a + !na);
e[2 * b + !nb].push_back(2 * a + na);
rev[2 * a + na].push_back(2 * b + !nb);
}
for(int u = 2; u <= 2*n+1; ++u)
if(vis[u] == 0)
dfs(u);
reverse(topo.begin(), topo.end());
int c = 0;
for(int u : topo)
if(col[u] == 0)
colorfy(u, ++c);
for(int i = 1; i <= n; ++i) {
if(col[2*i] == col[2*i+1]) {
cout << "NO\n";
return 0;
}
}
topo.clear();
memset(vis, 0, sizeof vis);
for(int u = 2; u <= 2 * n + 1; ++u)
if(vis[u] == 0) dfs2(u);
for(int u = 1; u <= n; ++u) {
if(tim[col[2*u+1]] < tim[col[2*u]]) cout << 0 << " ";
else cout << 1 << " ";
}
cout << '\n';
}
| [
"[email protected]"
] | |
0235a722dacc43a1e0edc023d109f809985e0583 | 77a08ec51aa16191986a739267fd9d4379bbb208 | /vj/kb18B.cpp | 0d9a679f358079ecbfa3e326be24d85312ff1979 | [] | no_license | cenariusxz/ACM-Coding | 8f698203db802f79578921b311b38346950ef0ca | dc09ac9adfb4b80d463bdc93f52b479a957154e6 | refs/heads/master | 2023-06-24T13:12:13.279255 | 2021-07-26T01:24:36 | 2021-07-26T01:24:36 | 185,567,471 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,258 | cpp | #include<stdio.h>
#include<string.h>
#include<algorithm>
#include<math.h>
using namespace std;
const int maxn=2e4+5;
const int INF=0x3f3f3f3f;
#define F(x) ((x)/3+((x)%3==1?0:tb))
#define G(x) ((x)<tb?(x)*3+1:((x)-tb)*3+2)
int wa[maxn*3],wb[maxn*3],wv[maxn*3],wss[maxn*3];
int str[maxn*3],sa[maxn*3],rank[maxn*3],height[maxn*3];
int n,k;
int c0(int *r,int a,int b){
return r[a]==r[b]&&r[a+1]==r[b+1]&&r[a+2]==r[b+2];
}
int c12(int k,int *r,int a,int b){
if(k==2)return r[a]<r[b]||(r[a]==r[b]&&c12(1,r,a+1,b+1));
else return r[a]<r[b]||(r[a]==r[b]&&wv[a+1]<wv[b+1]);
}
void sort(int *r,int *a,int *b,int n,int m){
for(int i=0;i<n;++i)wv[i]=r[a[i]];
for(int i=0;i<m;++i)wss[i]=0;
for(int i=0;i<n;++i)wss[wv[i]]++;
for(int i=1;i<m;++i)wss[i]+=wss[i-1];
for(int i=n-1;i>=0;--i)b[--wss[wv[i]]]=a[i];
}
void dc3(int *r,int *sa,int n,int m){
int i,j,*rn=r+n;
int *san=sa+n,ta=0,tb=(n+1)/3,tbc=0,p;
r[n]=r[n+1]=0;
for(i=0;i<n;++i)if(i%3)wa[tbc++]=i;
sort(r+2,wa,wb,tbc,m);
sort(r+1,wb,wa,tbc,m);
sort(r,wa,wb,tbc,m);
for(p=1,rn[F(wb[0])]=0,i=1;i<tbc;++i)rn[F(wb[i])]=c0(r,wb[i-1],wb[i])?p-1:p++;
if(p<tbc)dc3(rn,san,tbc,p);
else for(i=0;i<tbc;++i)san[rn[i]]=i;
for(i=0;i<tbc;++i)if(san[i]<tb)wb[ta++]=san[i]*3;
if(n%3==1)wb[ta++]=n-1;
sort(r,wb,wa,ta,m);
for(i=0;i<tbc;++i)wv[wb[i]=G(san[i])]=i;
for(i=0,j=0,p=0;i<ta&&j<tbc;++p)sa[p]=c12(wb[j]%3,r,wa[i],wb[j])?wa[i++]:wb[j++];
for(;i<ta;++p)sa[p]=wa[i++];
for(;j<tbc;++p)sa[p]=wb[j++];
}
void da(int n,int m){
for(int i=n;i<n*3;++i)str[i]=0;
dc3(str,sa,n+1,m);
int i,j,k=0;
for(int i=0;i<=n;++i)rank[sa[i]]=i;
for(int i=0;i<n;++i){
if(k)--k;
j=sa[rank[i]-1];
while(str[i+k]==str[j+k])++k;
height[rank[i]]=k;
}
}
bool check(int mid){
int cnt=1;
for(int i=2;i<=n;++i){
if(height[i]>=mid)cnt++;
else{
if(cnt>=k)return 1;
cnt=1;
}
}
if(cnt>=k)return 1;
return 0;
}
int main(){
scanf("%d%d",&n,&k);
for(int i=0;i<n;++i)scanf("%d",&str[i]);
for(int i=0;i<n;++i)str[i]++;
int maxx=-INF;
for(int i=0;i<n;++i)if(str[i]>maxx)maxx=str[i];
maxx++;
da(n,maxx);
int left=1,right=n;
int ans=-1;
while(left<=right){
int mid=(left+right)>>1;
if(check(mid)){
if(mid>ans)ans=mid;
left=mid+1;
}
else right=mid-1;
}
printf("%d\n",ans);
return 0;
}
| [
"[email protected]"
] | |
0e5a49122814ed8480f3531b697b0ed29100f466 | 0678af0ebe0be6e775ab7d86b2e6ecb7cb5de1ff | /include/CFairy.h | ece21ed5bec5179cccbdf55df921f990cfcd3c26 | [] | no_license | whztt07/CookieStealingOgre | 0a2be9354c1a7ce01917b9300f1eadc39fdf5b47 | 6a5b96e42ac56948b0acdea9211fdf8ace1e7b89 | refs/heads/master | 2021-01-18T00:25:08.455863 | 2014-04-12T01:02:59 | 2014-04-12T01:02:59 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 319 | h | #ifndef FAIRY_H
#define FAIRY_H
#include "CObject.h"
class CFairy : public CObject{
public:
CFairy();
~CFairy();
//void initialize();
void Update(double timeDifference);
//CLandscape& CLandscape::operator =(const CLandscape& rhs);
void UpdatePlayerPosition(float x, float y);
};
#endif | [
"[email protected]"
] | |
bed540ca84411860d3d694694a7930f66eec0a11 | e0b7b4d82ed1286b6099cb882e2c397d23ffa4b0 | /GameEngineFightProject/Adventure.h | d81138b3c9878e4daf6b69b59c478cc00a858dbb | [] | no_license | windywyll/GameEngineFightProject | b0be08f3ed89b7ae3b7b0032296ce19a8c8c34c8 | 6b0c6048127faf80e63f9e946bfb392c4ccf26ec | refs/heads/master | 2021-01-10T02:18:46.809769 | 2016-01-12T22:08:17 | 2016-01-12T22:08:17 | 49,412,963 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 167 | h | #ifndef ADVENTURE
#define ADVENTURE
#include "GameMode.h"
class Adventure : public GameMode
{
public:
Adventure();
~Adventure();
void selectMode();
};
#endif
| [
"[email protected]"
] | |
0e7d6b6d3b0e30de88525e2d56fb898f25fa34b0 | e5655151d8673b00cc7eda76b1a897a46ec4e591 | /be/src/exprs/decimal-functions.h | c03286646d6f6bdc2d157611c7f3c2d55893c6f5 | [
"Apache-2.0"
] | permissive | mapr/impala | 870229dbfcb7e790e1571018d269d6a1e87259b4 | 2b626c8e9f4c666d23872c228cf43daae4c9acbb | refs/heads/v1.4.1-mapr | 2020-04-05T07:51:33.026765 | 2015-01-14T13:37:12 | 2015-01-14T13:37:12 | 12,654,740 | 2 | 6 | null | 2016-03-10T16:34:10 | 2013-09-06T21:13:27 | C++ | UTF-8 | C++ | false | false | 1,196 | h | // Copyright 2012 Cloudera Inc.
//
// 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.
#ifndef IMPALA_EXPRS_DECIMAL_FUNCTIONS_H
#define IMPALA_EXPRS_DECIMAL_FUNCTIONS_H
namespace impala {
class Expr;
class TupleRow;
class DecimalFunctions {
public:
static void* Precision(Expr* e, TupleRow* row);
static void* Scale(Expr* e, TupleRow* row);
static void* Abs(Expr* e, TupleRow* row);
static void* Ceil(Expr* e, TupleRow* row);
static void* Floor(Expr* e, TupleRow* row);
static void* Round(Expr* e, TupleRow* row);
static void* RoundTo(Expr* e, TupleRow* row);
static void* Truncate(Expr* e, TupleRow* row);
static void* TruncateTo(Expr* e, TupleRow* row);
};
}
#endif
| [
"[email protected]"
] | |
97590667e69357960dbcfb764a933edd4dc29001 | 3bcf133b6e693787a053848b23284a6f1615a6f5 | /QTUI/tmp/moc/moc_OutputWindowImpl.cpp | 36a5f9369ffb2dd6065210f275c0aa3d778610ed | [] | no_license | sam1018/Skeleton | 10db8ad9251f0417b9d53246c138230a5e6e102e | da4efbd32bed8abffae4926c2deb6bee7ff8e6df | refs/heads/master | 2021-01-19T14:33:43.611329 | 2015-12-27T07:27:23 | 2015-12-27T07:27:23 | 40,446,181 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,096 | cpp | /****************************************************************************
** Meta object code from reading C++ file 'OutputWindowImpl.h'
**
** Created by: The Qt Meta Object Compiler version 67 (Qt 5.5.1)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include "../../OutputWindowImpl.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'OutputWindowImpl.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.5.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif
QT_BEGIN_MOC_NAMESPACE
struct qt_meta_stringdata_OutputWindowImpl_t {
QByteArrayData data[10];
char stringdata0[127];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
qptrdiff(offsetof(qt_meta_stringdata_OutputWindowImpl_t, stringdata0) + ofs \
- idx * sizeof(QByteArrayData)) \
)
static const qt_meta_stringdata_OutputWindowImpl_t qt_meta_stringdata_OutputWindowImpl = {
{
QT_MOC_LITERAL(0, 0, 16), // "OutputWindowImpl"
QT_MOC_LITERAL(1, 17, 17), // "AddCategorySignal"
QT_MOC_LITERAL(2, 35, 0), // ""
QT_MOC_LITERAL(3, 36, 12), // "categoryName"
QT_MOC_LITERAL(4, 49, 13), // "RefreshSignal"
QT_MOC_LITERAL(5, 63, 4), // "text"
QT_MOC_LITERAL(6, 68, 18), // "AddCategoryHandler"
QT_MOC_LITERAL(7, 87, 14), // "RefreshHandler"
QT_MOC_LITERAL(8, 102, 20), // "ComboCategoryChanged"
QT_MOC_LITERAL(9, 123, 3) // "cat"
},
"OutputWindowImpl\0AddCategorySignal\0\0"
"categoryName\0RefreshSignal\0text\0"
"AddCategoryHandler\0RefreshHandler\0"
"ComboCategoryChanged\0cat"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_OutputWindowImpl[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
5, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
2, // signalCount
// signals: name, argc, parameters, tag, flags
1, 1, 39, 2, 0x06 /* Public */,
4, 2, 42, 2, 0x06 /* Public */,
// slots: name, argc, parameters, tag, flags
6, 1, 47, 2, 0x0a /* Public */,
7, 2, 50, 2, 0x0a /* Public */,
8, 1, 55, 2, 0x0a /* Public */,
// signals: parameters
QMetaType::Void, QMetaType::QString, 3,
QMetaType::Void, QMetaType::QString, QMetaType::QString, 3, 5,
// slots: parameters
QMetaType::Void, QMetaType::QString, 3,
QMetaType::Void, QMetaType::QString, QMetaType::QString, 3, 5,
QMetaType::Void, QMetaType::QString, 9,
0 // eod
};
void OutputWindowImpl::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
OutputWindowImpl *_t = static_cast<OutputWindowImpl *>(_o);
Q_UNUSED(_t)
switch (_id) {
case 0: _t->AddCategorySignal((*reinterpret_cast< const QString(*)>(_a[1]))); break;
case 1: _t->RefreshSignal((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2]))); break;
case 2: _t->AddCategoryHandler((*reinterpret_cast< const QString(*)>(_a[1]))); break;
case 3: _t->RefreshHandler((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2]))); break;
case 4: _t->ComboCategoryChanged((*reinterpret_cast< const QString(*)>(_a[1]))); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
void **func = reinterpret_cast<void **>(_a[1]);
{
typedef void (OutputWindowImpl::*_t)(const QString & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&OutputWindowImpl::AddCategorySignal)) {
*result = 0;
}
}
{
typedef void (OutputWindowImpl::*_t)(const QString & , const QString & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&OutputWindowImpl::RefreshSignal)) {
*result = 1;
}
}
}
}
const QMetaObject OutputWindowImpl::staticMetaObject = {
{ &QDockWidget::staticMetaObject, qt_meta_stringdata_OutputWindowImpl.data,
qt_meta_data_OutputWindowImpl, qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};
const QMetaObject *OutputWindowImpl::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *OutputWindowImpl::qt_metacast(const char *_clname)
{
if (!_clname) return Q_NULLPTR;
if (!strcmp(_clname, qt_meta_stringdata_OutputWindowImpl.stringdata0))
return static_cast<void*>(const_cast< OutputWindowImpl*>(this));
return QDockWidget::qt_metacast(_clname);
}
int OutputWindowImpl::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QDockWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 5)
qt_static_metacall(this, _c, _id, _a);
_id -= 5;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 5)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 5;
}
return _id;
}
// SIGNAL 0
void OutputWindowImpl::AddCategorySignal(const QString & _t1)
{
void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
// SIGNAL 1
void OutputWindowImpl::RefreshSignal(const QString & _t1, const QString & _t2)
{
void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)), const_cast<void*>(reinterpret_cast<const void*>(&_t2)) };
QMetaObject::activate(this, &staticMetaObject, 1, _a);
}
QT_END_MOC_NAMESPACE
| [
"[email protected]"
] | |
8db46f664a29e6eb9806f007fb55561cf5b260b8 | 43a525edb1d27419c104638b98c91eb5cc381971 | /libs/src/vtdata/Fence.h | 474f9cbcc3774175b546c9c9214eacabf2f18bdc | [] | no_license | prash471/ofxVTerrain | ac1ca0bff99cf504a0f7e757bdc12d1cf16ae0a8 | c10ae051579bdb6693c5cdbb0b6247d3d0e1aa25 | refs/heads/master | 2021-01-16T21:14:33.585563 | 2013-04-17T19:06:45 | 2013-04-17T19:06:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,598 | h | //
// Fences.h
//
// Copyright (c) 2001-2011 Virtual Terrain Project
// Free for all uses, see license.txt for details.
//
#ifndef FENCESH
#define FENCESH
#include <stdio.h>
#include "MathTypes.h"
#include "Structure.h"
enum vtLinearStyle
{
FS_WOOD_POSTS_WIRE,
FS_METAL_POSTS_WIRE,
FS_METAL_POSTS_HOGWIRE,
FS_CHAINLINK,
FS_SECURITY,
FS_DRYSTONE,
FS_STONE,
FS_PRIVET,
FS_BERM,
FS_RAILING_ROW,
FS_RAILING_CABLE,
FS_RAILING_EU,
FS_TOTAL
};
#define FENCE_DEFAULT_HEIGHT 1.2f
#define FENCE_DEFAULT_SPACING 2.5f
class vtLinearParams
{
public:
void Defaults();
void Blank();
void ApplyStyle(vtLinearStyle style);
void WriteXML(GZOutput &out) const;
bool operator==(const vtLinearParams &rhs) const;
// Posts
vtString m_PostType; // wood, steel, none
float m_fPostHeight;
float m_fPostSpacing;
float m_fPostWidth;
float m_fPostDepth;
vtString m_PostExtension; // left, right, double, none
// Connect
int m_iConnectType; // 0=none, 1=wire, 2=simple, 3=profile
vtString m_ConnectMaterial; // chain-link, privet, drystone, etc.
float m_fConnectTop;
float m_fConnectBottom;
float m_fConnectWidth;
short m_iConnectSlope; // slope on the sides of the connector
bool m_bConstantTop; // top of connector is constant height
vtString m_ConnectProfile; // filename of profile
};
/**
* The vtFence class represents any linear structure. This can be a fence,
* a wall, a railing, or any other kind of build structure which follows
* a line on the ground.
*/
class vtFence : public vtStructure
{
public:
vtFence();
// copy operator
vtFence &operator=(const vtFence &v);
// geometry methods
void AddPoint(const DPoint2 &epos);
DLine2 &GetFencePoints() { return m_pFencePts; }
void GetClosestPoint(const DPoint2 &point, DPoint2 &closest);
double GetDistanceToLine(const DPoint2 &point);
int GetNearestPointIndex(const DPoint2 &point, double &fDist);
bool IsContainedBy(const DRECT &rect) const;
bool GetExtents(DRECT &rect) const;
// IO
void WriteXML(GZOutput &out, bool bDegrees) const;
// style
void ApplyStyle(vtLinearStyle style);
vtLinearParams &GetParams() { return m_Params; }
virtual void SetParams(const vtLinearParams ¶ms) { m_Params = params; }
virtual void ProfileChanged() {}
protected:
DLine2 m_pFencePts; // in earth coordinates
vtLinearParams m_Params;
};
// Helpers
bool LoadFLine2FromSHP(const char *fname, FLine2 &prof);
bool SaveFLine2ToSHP(const char *fname, const FLine2 &prof);
#endif // FENCESH
| [
"[email protected]"
] | |
05240e653d555f8a874bf084856faa049ab7b5f2 | c17b67cf383bb3694dec85289285a872f6735a85 | /Study20200330/11722_가장 긴 감소하는 부분 수열.cpp | 2c98f5725812815ffbc165ecc3903a28f71297a1 | [] | no_license | batherit/Algorithm | fa51e453d3126b7ec4dc8d9dfc0f8ab5874e7c34 | 0fe282d6f22773b3f0be72c0d0deba1209bacf1f | refs/heads/master | 2021-05-18T12:35:18.546036 | 2020-06-22T16:10:06 | 2020-06-22T16:10:06 | 251,237,493 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 406 | cpp | #include<iostream>
#include<algorithm>
using namespace std;
int arr[1001];
int dp[1001];
int main(void) {
int n;
cin >> n;
int res = 0;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
dp[i] = 1;
int mx = 0;
for (int j = i - 1; j >= 1; j--) {
if (arr[j] > arr[i]) {
if (dp[j] > mx) {
mx = dp[j];
}
}
}
dp[i] += mx;
res = max(res, dp[i]);
}
cout << res;
return 0;
} | [
"[email protected]"
] | |
94264ef726bfc371bad589a87dc277975e923e2c | 4110496fb8b6cf7fbdabf9682f07255b6dab53f3 | /Sort/2191. Sort the Jumbled Numbers.cpp | 552263d21ed7c83707747afd65a7497a421deadb | [] | no_license | louisfghbvc/Leetcode | 4cbfd0c8ad5513f60242759d04a067f198351805 | 1772036510638ae85b2d5a1a9e0a8c25725f03bd | refs/heads/master | 2023-08-22T19:20:30.466651 | 2023-08-13T14:34:58 | 2023-08-13T14:34:58 | 227,853,839 | 4 | 0 | null | 2020-11-20T14:02:18 | 2019-12-13T14:09:25 | C++ | UTF-8 | C++ | false | false | 754 | cpp | // preprocessing.
// O(NlogN).
class Solution {
public:
vector<int> sortJumbled(vector<int>& mapping, vector<int>& nums) {
auto conv = [&](int x){
if(!x) return mapping[0];
int num = 0, f = 1;
while(x){
num += mapping[x%10]*f;
f *= 10;
x /= 10;
}
return num;
};
vector<pair<int, int>> arr;
for(auto &x: nums)
arr.push_back({conv(x), x});
sort(arr.begin(), arr.end(), [&](auto &a, auto &b){
return a.first < b.first;
});
for(int i = 0; i < nums.size(); ++i)
nums[i] = arr[i].second;
return nums;
}
};
| [
"[email protected]"
] | |
f1df40edf79a803f3b77fc6e810c1ebd0a425de1 | 0eff74b05b60098333ad66cf801bdd93becc9ea4 | /second/download/CMake/CMake-gumtree/Kitware_CMake_repos_basic_block_block_20984.cpp | efdba0c4c7c17aa7f0eba3aa9060dd1ddacb2c85 | [] | no_license | niuxu18/logTracker-old | 97543445ea7e414ed40bdc681239365d33418975 | f2b060f13a0295387fe02187543db124916eb446 | refs/heads/master | 2021-09-13T21:39:37.686481 | 2017-12-11T03:36:34 | 2017-12-11T03:36:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 29 | cpp | rwlock->state_.num_readers_++ | [
"[email protected]"
] | |
4181d4d19925071037f30b30ca709795419af599 | 38d4495215f682412ecea7184a00183f446a3eb3 | /plugins/robots/common/iotikKit/src/blocks/details/matrix.h | 937e0c092069fb0b686a77e3cc6b90b032366244 | [
"Apache-2.0",
"BSD-3-Clause",
"MIT",
"CC-BY-4.0",
"GPL-3.0-only",
"GPL-1.0-or-later",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | Victor-Y-Fadeev/qreal | 5e2e006e7f9bbe1fc84ee60324ddec693320c11b | c926e5640c96d74e45bc14fb83a2f57b5c535bae | refs/heads/iotik-v1-0 | 2020-12-03T03:41:58.006247 | 2020-04-16T18:14:28 | 2020-04-16T18:14:28 | 95,751,064 | 6 | 1 | Apache-2.0 | 2019-08-08T18:06:31 | 2017-06-29T07:33:42 | C++ | UTF-8 | C++ | false | false | 879 | h | /* Copyright 2019 QReal Research Group
*
* 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. */
#pragma once
#include <qrutils/interpreter/block.h>
namespace iotik {
namespace blocks {
namespace details {
/// Interpreter implementation for "Matrix" block.
class MatrixBlock : public qReal::interpretation::Block
{
public:
MatrixBlock();
void run() override;
};
}
}
}
| [
"[email protected]"
] | |
4dc8bdd74540bc0c706b454d355262bb97f67c5a | ca42fab925ccb21cde54f3893ebea81d82e38afe | /ScrabbleManiaProject/ScrabbleMania/trim.cpp | 2e1fa16c361dd0e244235d619b233969c48b94d4 | [
"LicenseRef-scancode-public-domain",
"LicenseRef-scancode-mit-old-style"
] | permissive | partone/ScrabbleMania | b9e988333480bb7ebcef62ab1941b1b79b0589cd | 6bd2d984bc9740206e74a817a020dede0b690044 | refs/heads/master | 2020-09-05T06:54:11.593818 | 2019-12-09T04:35:51 | 2019-12-09T04:35:51 | 220,017,993 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 469 | cpp |
#include "trim.h"
void trimRight( std::string& str, const std::string& trimChars)
{
std::string::size_type pos = str.find_last_not_of( trimChars );
str.erase( pos + 1 );
}
void trimLeft( std::string& str, const std::string& trimChars)
{
std::string::size_type pos = str.find_first_not_of( trimChars );
str.erase( 0, pos );
}
void trim( std::string& str, const std::string& trimChars)
{
trimRight( str, trimChars );
trimLeft( str, trimChars );
}
| [
"[email protected]"
] | |
0574695d12c0f64765a878dcae90eb6cbd1ee7f0 | ae4682dce1da219690d79416cfed8894b12d4334 | /Arduino Projects/autoclave_mega32/submenu_min_sec.ino | 56fa0357bc9beb892cccdfbb04178b6e90096b50 | [
"LicenseRef-scancode-warranty-disclaimer"
] | no_license | asim97/CV_Projects | e58e2fbcc089e5ae4fb8297934a7ae4b96c925b4 | ae977163c5d2859ba42d5165a8ba53a99843a4fe | refs/heads/master | 2022-12-16T23:01:50.734352 | 2020-09-12T20:52:03 | 2020-09-12T20:52:03 | 294,965,812 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,474 | ino | void submenu_settings_min_sec() {
//Third page of the menu settings (setting 1 ,.....)
if (submenu == menu_min_sec_index)
{
if (counter == 0)
{
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("=>");
lcd.print("Edit minutes");
lcd.setCursor(0, 1);
lcd.print(" Edit seconds");
page = 1;
pushed = 0;
}
if (counter == 1)
{
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(" Edit minutes");
lcd.setCursor(0, 1);
lcd.print("=>");
lcd.print("Edit seconds");
page = 2;
pushed = 0;
}
if (counter == 2)
{
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("=>");
lcd.print("Back");
lcd.setCursor(0, 1);
lcd.print(" ");
page = 3;
pushed = 0;
}
}//submenu = 2;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void buttons_action_min_sec() {
if (submenu == menu_min_sec_index)
{
if (page == 1 || page == 2)
{
submenu = menu_prog_set_val_index;
counter = 0;
pushed = 1;
Ready = 0;
if (page == 1) min_prog_set = true;
if (page == 2) min_prog_set = false;
page = 0;
}
if (page == 3) //back selected
{
submenu = menu_prog_settings_index;
counter = setting_no - 1;
pushed = 1;
Ready = 0;
page = 0;
}
}//end of submenu 1
}
| [
"[email protected]"
] | |
07176f33214ad043d7532aaa2cd854699a688f27 | 3ae80dbc18ed3e89bedf846d098b2a98d8e4b776 | /main/Data/DateTimeTest.cpp | 42892a2391a34d55b9eee2c9f774f5492ba3d8d2 | [] | no_license | sswroom/SClass | deee467349ca249a7401f5d3c177cdf763a253ca | 9a403ec67c6c4dfd2402f19d44c6573e25d4b347 | refs/heads/main | 2023-09-01T07:24:58.907606 | 2023-08-31T11:24:34 | 2023-08-31T11:24:34 | 329,970,172 | 10 | 7 | null | null | null | null | UTF-8 | C++ | false | false | 3,116 | cpp | #include "Stdafx.h"
#include "MyMemory.h"
#include "Core/Core.h"
#include "Data/DateTime.h"
#include "Data/Timestamp.h"
#include "IO/ConsoleWriter.h"
#if defined(_WIN32) || defined(_WIN32_WCE)
#include <windows.h>
#elif !defined(CPU_AVR)
#include <sys/time.h>
#endif
#if !defined(CPU_AVR)
#include <time.h>
#include <stdio.h>
#endif
Int32 MyMain(NotNullPtr<Core::IProgControl> progCtrl)
{
UTF8Char sbuff[128];
UTF8Char *sptr;
IO::ConsoleWriter console;
Data::DateTime dt;
dt.SetCurrTimeUTC();
sptr = dt.ToString(Text::StrConcatC(sbuff, UTF8STRC("Curr Time (UTC):")), "yyyy-MM-dd HH:mm:ss.fffzzzz");
console.WriteLineCStr(CSTRP(sbuff, sptr));
dt.ToLocalTime();
sptr = dt.ToString(Text::StrConcatC(sbuff, UTF8STRC("Curr Time (ToLocal):")), "yyyy-MM-dd HH:mm:ss.fffzzzz");
console.WriteLineCStr(CSTRP(sbuff, sptr));
dt.SetCurrTime();
sptr = dt.ToString(Text::StrConcatC(sbuff, UTF8STRC("Curr Time (Local):")), "yyyy-MM-dd HH:mm:ss.fffzzzz");
console.WriteLineCStr(CSTRP(sbuff, sptr));
#if !defined(_WIN32) && !defined(_WIN32_WCE) && !defined(CPU_AVR)
struct timeval tv;
struct timezone tz;
if (gettimeofday(&tv, &tz) == 0)
{
dt.SetTicks(1000 * (Int64)tv.tv_sec + tv.tv_usec / 1000);
dt.SetTimeZoneQHR((Int8)(-tz.tz_minuteswest / 15));
sptr = dt.ToString(Text::StrConcatC(sbuff, UTF8STRC("gettimeofday: ")), "yyyy-MM-dd HH:mm:ss.fffzzzz");
console.WriteLineCStr(CSTRP(sbuff, sptr));
}
#endif
Int32 newTZ;
#if defined(_WIN32) || defined(_WIN32_WCE)
TIME_ZONE_INFORMATION tz;
tz.Bias = 0;
GetTimeZoneInformation(&tz);
newTZ = tz.Bias / -15;
#else
time_t now = time(0);
tm *t = localtime(&now);
newTZ = (Int32)(t->tm_gmtoff / 900);
#endif
dt.SetTimeZoneQHR((Int8)newTZ);
#if !defined(_WIN32) && !defined(_WIN32_WCE)
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
dt.SetUnixTimestamp(ts.tv_sec);
dt.SetTicks(dt.ToTicks() + (UInt16)(ts.tv_nsec / 1000000));
sptr = dt.ToString(Text::StrConcatC(sbuff, UTF8STRC("clock_gettime: ")), "yyyy-MM-dd HH:mm:ss.fffzzzz");
console.WriteLineCStr(CSTRP(sbuff, sptr));
#endif
sptr = Text::StrInt64(Text::StrConcatC(sbuff, UTF8STRC("GetCurrTimeMillis: ")), Data::DateTimeUtil::GetCurrTimeMillis());
console.WriteLineCStr(CSTRP(sbuff, sptr));
Data::Timestamp newts = Data::Timestamp::Now();
sptr = Text::StrUInt32(Text::StrConcatC(Text::StrInt64(Text::StrConcatC(sbuff, UTF8STRC("Timestamp values: ")), newts.inst.sec), UTF8STRC(".")), newts.inst.nanosec);
console.WriteLineCStr(CSTRP(sbuff, sptr));
sptr = newts.ToString(Text::StrConcatC(sbuff, UTF8STRC("Timestamp.Now: ")), "yyyy-MM-dd HH:mm:ss.fffzzzz");
console.WriteLineCStr(CSTRP(sbuff, sptr));
newts = newts.AddDay(1);
sptr = newts.ToString(Text::StrConcatC(sbuff, UTF8STRC("Timestamp.AddDay(1): ")), "yyyy-MM-dd HH:mm:ss.fffzzzz");
console.WriteLineCStr(CSTRP(sbuff, sptr));
newts = Data::Timestamp::FromStr(CSTR("2022-11-07 15:02:31"), Data::DateTimeUtil::GetLocalTzQhr());
sptr = newts.ToString(Text::StrConcatC(sbuff, UTF8STRC("Timestamp.FromStr.SetTimeZoneQHR: ")), "yyyy-MM-dd HH:mm:ss.fffzzzz");
console.WriteLineCStr(CSTRP(sbuff, sptr));
return 0;
}
| [
"[email protected]"
] | |
da85b2466dbf01ced964a76bc1f222b6aa84745f | b1008277f3c9103de6b434e4f3f62d6206e6873e | /Editor/source/MathLib/Line2D.h | 50bef5934d2c5b6d53e23317c9d0c265d4d423da | [] | no_license | manojyerra/OpenGL | b8bd9af9d3a63f74d810593d9608ca38c397187b | d241d6c2a6b245592b3a611f6880101e360a83b0 | refs/heads/master | 2022-12-10T12:34:48.137998 | 2019-11-10T05:40:53 | 2019-11-10T05:40:53 | 88,062,264 | 0 | 1 | null | 2022-12-09T19:28:30 | 2017-04-12T14:37:51 | C | UTF-8 | C++ | false | false | 840 | h | #pragma once
#include "Def.h"
#include "Point.h"
class Line2D
{
private:
public:
Point P1;
Point P2;
float A;
float B;
float C;
//Line2D(float xCoffient, float yCoffient, float constant);
Line2D( Point p1, Point p2 );
Line2D( Point* p1, Point* p2 );
Line2D( float x1, float y1, float x2, float y2 );
//float Slope();
//float AngleInDegrees();
bool AtSameSide(Point* p1, Point* p2);
Point IntersectionPoint(Line2D* line);
float PerpendicularDist(Point* p);
float PerpendicularDist(float x, float y);
Point FootOfPerpendicular(Point* p);
//Line2D GetPerpendicularLine(Point* p);
//Point GetAnyPoint();
//float GetY(float x);
//float GetX(float y);
static float PerpendicularDist( Point* p1, Point* p2, Point* p );
static Point FootOfPerpendicular( Point* p1, Point* p2, Point* p );
void Draw();
~Line2D();
};
| [
"[email protected]"
] | |
db646f4f5ab6fb99846e68f59d82cf5fb197159f | dd80a584130ef1a0333429ba76c1cee0eb40df73 | /external/chromium_org/chrome/browser/predictors/resource_prefetch_predictor_unittest.cc | 1a509376f284857a1ed409b0a8052c7302f3f590 | [
"MIT",
"BSD-3-Clause"
] | permissive | karunmatharu/Android-4.4-Pay-by-Data | 466f4e169ede13c5835424c78e8c30ce58f885c1 | fcb778e92d4aad525ef7a995660580f948d40bc9 | refs/heads/master | 2021-03-24T13:33:01.721868 | 2017-02-18T17:48:49 | 2017-02-18T17:48:49 | 81,847,777 | 0 | 2 | MIT | 2020-03-09T00:02:12 | 2017-02-13T16:47:00 | null | UTF-8 | C++ | false | false | 42,907 | cc | // Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <iostream>
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/message_loop/message_loop.h"
#include "base/run_loop.h"
#include "base/time/time.h"
#include "chrome/browser/history/history_service.h"
#include "chrome/browser/history/history_service_factory.h"
#include "chrome/browser/history/history_types.h"
#include "chrome/browser/history/in_memory_database.h"
#include "chrome/browser/history/url_database.h"
#include "chrome/browser/predictors/resource_prefetch_predictor.h"
#include "chrome/browser/predictors/resource_prefetch_predictor_tables.h"
#include "chrome/test/base/testing_profile.h"
#include "content/public/test/test_browser_thread.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
using testing::ContainerEq;
using testing::Pointee;
using testing::SetArgPointee;
using testing::StrictMock;
namespace predictors {
typedef ResourcePrefetchPredictor::URLRequestSummary URLRequestSummary;
typedef ResourcePrefetchPredictorTables::ResourceRow ResourceRow;
typedef std::vector<ResourceRow> ResourceRows;
typedef ResourcePrefetchPredictorTables::PrefetchData PrefetchData;
typedef ResourcePrefetchPredictorTables::PrefetchDataMap PrefetchDataMap;
// For printing failures nicely.
void PrintTo(const ResourceRow& row, ::std::ostream* os) {
*os << "[" << row.primary_key << "," << row.resource_url
<< "," << row.resource_type << "," << row.number_of_hits
<< "," << row.number_of_misses << "," << row.consecutive_misses
<< "," << row.average_position << "," << row.score << "]";
}
void PrintTo(const PrefetchData& data, ::std::ostream* os) {
*os << "[" << data.key_type << "," << data.primary_key
<< "," << data.last_visit.ToInternalValue() << "]\n";
for (ResourceRows::const_iterator it = data.resources.begin();
it != data.resources.end(); ++it) {
*os << "\t\t";
PrintTo(*it, os);
*os << "\n";
}
}
class MockResourcePrefetchPredictorTables
: public ResourcePrefetchPredictorTables {
public:
MockResourcePrefetchPredictorTables() { }
MOCK_METHOD2(GetAllData, void(PrefetchDataMap* url_data_map,
PrefetchDataMap* host_data_map));
MOCK_METHOD2(UpdateData, void(const PrefetchData& url_data,
const PrefetchData& host_data));
MOCK_METHOD2(DeleteData, void(const std::vector<std::string>& urls,
const std::vector<std::string>& hosts));
MOCK_METHOD2(DeleteSingleDataPoint, void(const std::string& key,
PrefetchKeyType key_type));
MOCK_METHOD0(DeleteAllData, void());
protected:
~MockResourcePrefetchPredictorTables() { }
};
class ResourcePrefetchPredictorTest : public testing::Test {
public:
ResourcePrefetchPredictorTest();
virtual ~ResourcePrefetchPredictorTest();
virtual void SetUp() OVERRIDE;
virtual void TearDown() OVERRIDE;
protected:
void AddUrlToHistory(const std::string& url, int visit_count) {
HistoryServiceFactory::GetForProfile(profile_.get(),
Profile::EXPLICIT_ACCESS)->
AddPageWithDetails(
GURL(url),
base::string16(),
visit_count,
0,
base::Time::Now(),
false,
history::SOURCE_BROWSED);
profile_->BlockUntilHistoryProcessesPendingRequests();
}
NavigationID CreateNavigationID(int process_id,
int render_view_id,
const std::string& main_frame_url) {
NavigationID navigation_id;
navigation_id.render_process_id = process_id;
navigation_id.render_view_id = render_view_id;
navigation_id.main_frame_url = GURL(main_frame_url);
navigation_id.creation_time = base::TimeTicks::Now();
return navigation_id;
}
ResourcePrefetchPredictor::URLRequestSummary CreateURLRequestSummary(
int process_id,
int render_view_id,
const std::string& main_frame_url,
const std::string& resource_url,
ResourceType::Type resource_type,
const std::string& mime_type,
bool was_cached) {
ResourcePrefetchPredictor::URLRequestSummary summary;
summary.navigation_id = CreateNavigationID(process_id, render_view_id,
main_frame_url);
summary.resource_url = GURL(resource_url);
summary.resource_type = resource_type;
summary.mime_type = mime_type;
summary.was_cached = was_cached;
return summary;
}
void InitializePredictor() {
predictor_->StartInitialization();
base::RunLoop loop;
loop.RunUntilIdle(); // Runs the DB lookup.
profile_->BlockUntilHistoryProcessesPendingRequests();
}
bool URLRequestSummaryAreEqual(const URLRequestSummary& lhs,
const URLRequestSummary& rhs) {
return lhs.navigation_id == rhs.navigation_id &&
lhs.resource_url == rhs.resource_url &&
lhs.resource_type == rhs.resource_type &&
lhs.mime_type == rhs.mime_type &&
lhs.was_cached == rhs.was_cached;
}
void ResetPredictor() {
ResourcePrefetchPredictorConfig config;
config.max_urls_to_track = 3;
config.max_hosts_to_track = 2;
config.min_url_visit_count = 2;
config.max_resources_per_entry = 4;
config.max_consecutive_misses = 2;
// TODO(shishir): Enable the prefetching mode in the tests.
config.mode |= ResourcePrefetchPredictorConfig::URL_LEARNING;
config.mode |= ResourcePrefetchPredictorConfig::HOST_LEARNING;
predictor_.reset(new ResourcePrefetchPredictor(config, profile_.get()));
predictor_->set_mock_tables(mock_tables_);
}
void InitializeSampleData();
base::MessageLoop loop_;
content::TestBrowserThread ui_thread_;
content::TestBrowserThread db_thread_;
scoped_ptr<TestingProfile> profile_;
scoped_ptr<ResourcePrefetchPredictor> predictor_;
scoped_refptr<StrictMock<MockResourcePrefetchPredictorTables> > mock_tables_;
PrefetchDataMap test_url_data_;
PrefetchDataMap test_host_data_;
PrefetchData empty_url_data_;
PrefetchData empty_host_data_;
};
ResourcePrefetchPredictorTest::ResourcePrefetchPredictorTest()
: loop_(base::MessageLoop::TYPE_DEFAULT),
ui_thread_(content::BrowserThread::UI, &loop_),
db_thread_(content::BrowserThread::DB, &loop_),
profile_(new TestingProfile()),
mock_tables_(new StrictMock<MockResourcePrefetchPredictorTables>()),
empty_url_data_(PREFETCH_KEY_TYPE_URL, std::string()),
empty_host_data_(PREFETCH_KEY_TYPE_HOST, std::string()) {}
ResourcePrefetchPredictorTest::~ResourcePrefetchPredictorTest() {
profile_.reset(NULL);
loop_.RunUntilIdle();
}
void ResourcePrefetchPredictorTest::SetUp() {
InitializeSampleData();
ASSERT_TRUE(profile_->CreateHistoryService(true, false));
profile_->BlockUntilHistoryProcessesPendingRequests();
EXPECT_TRUE(HistoryServiceFactory::GetForProfile(profile_.get(),
Profile::EXPLICIT_ACCESS));
// Initialize the predictor with empty data.
ResetPredictor();
EXPECT_EQ(predictor_->initialization_state_,
ResourcePrefetchPredictor::NOT_INITIALIZED);
EXPECT_CALL(*mock_tables_.get(),
GetAllData(Pointee(ContainerEq(PrefetchDataMap())),
Pointee(ContainerEq(PrefetchDataMap()))));
InitializePredictor();
EXPECT_TRUE(predictor_->inflight_navigations_.empty());
EXPECT_EQ(predictor_->initialization_state_,
ResourcePrefetchPredictor::INITIALIZED);
}
void ResourcePrefetchPredictorTest::TearDown() {
predictor_.reset(NULL);
profile_->DestroyHistoryService();
}
void ResourcePrefetchPredictorTest::InitializeSampleData() {
{ // Url data.
PrefetchData google(PREFETCH_KEY_TYPE_URL, "http://www.google.com/");
google.last_visit = base::Time::FromInternalValue(1);
google.resources.push_back(ResourceRow(std::string(),
"http://google.com/style1.css",
ResourceType::STYLESHEET,
3,
2,
1,
1.0));
google.resources.push_back(ResourceRow(std::string(),
"http://google.com/script3.js",
ResourceType::SCRIPT,
4,
0,
1,
2.1));
google.resources.push_back(ResourceRow(std::string(),
"http://google.com/script4.js",
ResourceType::SCRIPT,
11,
0,
0,
2.1));
google.resources.push_back(ResourceRow(std::string(),
"http://google.com/image1.png",
ResourceType::IMAGE,
6,
3,
0,
2.2));
google.resources.push_back(ResourceRow(std::string(),
"http://google.com/a.font",
ResourceType::LAST_TYPE,
2,
0,
0,
5.1));
PrefetchData reddit(PREFETCH_KEY_TYPE_URL, "http://www.reddit.com/");
reddit.last_visit = base::Time::FromInternalValue(2);
reddit.resources
.push_back(ResourceRow(std::string(),
"http://reddit-resource.com/script1.js",
ResourceType::SCRIPT,
4,
0,
1,
1.0));
reddit.resources
.push_back(ResourceRow(std::string(),
"http://reddit-resource.com/script2.js",
ResourceType::SCRIPT,
2,
0,
0,
2.1));
PrefetchData yahoo(PREFETCH_KEY_TYPE_URL, "http://www.yahoo.com/");
yahoo.last_visit = base::Time::FromInternalValue(3);
yahoo.resources.push_back(ResourceRow(std::string(),
"http://google.com/image.png",
ResourceType::IMAGE,
20,
1,
0,
10.0));
test_url_data_.clear();
test_url_data_.insert(std::make_pair("http://www.google.com/", google));
test_url_data_.insert(std::make_pair("http://www.reddit.com/", reddit));
test_url_data_.insert(std::make_pair("http://www.yahoo.com/", yahoo));
}
{ // Host data.
PrefetchData facebook(PREFETCH_KEY_TYPE_HOST, "www.facebook.com");
facebook.last_visit = base::Time::FromInternalValue(4);
facebook.resources
.push_back(ResourceRow(std::string(),
"http://www.facebook.com/style.css",
ResourceType::STYLESHEET,
5,
2,
1,
1.1));
facebook.resources
.push_back(ResourceRow(std::string(),
"http://www.facebook.com/script.js",
ResourceType::SCRIPT,
4,
0,
1,
2.1));
facebook.resources
.push_back(ResourceRow(std::string(),
"http://www.facebook.com/image.png",
ResourceType::IMAGE,
6,
3,
0,
2.2));
facebook.resources.push_back(ResourceRow(std::string(),
"http://www.facebook.com/a.font",
ResourceType::LAST_TYPE,
2,
0,
0,
5.1));
facebook.resources
.push_back(ResourceRow(std::string(),
"http://www.resources.facebook.com/script.js",
ResourceType::SCRIPT,
11,
0,
0,
8.5));
PrefetchData yahoo(PREFETCH_KEY_TYPE_HOST, "www.yahoo.com");
yahoo.last_visit = base::Time::FromInternalValue(5);
yahoo.resources.push_back(ResourceRow(std::string(),
"http://google.com/image.png",
ResourceType::IMAGE,
20,
1,
0,
10.0));
test_host_data_.clear();
test_host_data_.insert(std::make_pair("www.facebook.com", facebook));
test_host_data_.insert(std::make_pair("www.yahoo.com", yahoo));
}
}
TEST_F(ResourcePrefetchPredictorTest, LazilyInitializeEmpty) {
// Tests that the predictor initializes correctly without any data.
EXPECT_TRUE(predictor_->url_table_cache_->empty());
EXPECT_TRUE(predictor_->host_table_cache_->empty());
}
TEST_F(ResourcePrefetchPredictorTest, LazilyInitializeWithData) {
// Tests that the history and the db tables data are loaded correctly.
AddUrlToHistory("http://www.google.com/", 4);
AddUrlToHistory("http://www.yahoo.com/", 2);
EXPECT_CALL(*mock_tables_.get(),
GetAllData(Pointee(ContainerEq(PrefetchDataMap())),
Pointee(ContainerEq(PrefetchDataMap()))))
.WillOnce(DoAll(SetArgPointee<0>(test_url_data_),
SetArgPointee<1>(test_host_data_)));
ResetPredictor();
InitializePredictor();
// Test that the internal variables correctly initialized.
EXPECT_EQ(predictor_->initialization_state_,
ResourcePrefetchPredictor::INITIALIZED);
EXPECT_TRUE(predictor_->inflight_navigations_.empty());
EXPECT_EQ(test_url_data_, *predictor_->url_table_cache_);
EXPECT_EQ(test_host_data_, *predictor_->host_table_cache_);
}
TEST_F(ResourcePrefetchPredictorTest, NavigationNotRecorded) {
// Single navigation but history count is low, so should not record.
AddUrlToHistory("http://www.google.com", 1);
URLRequestSummary main_frame =
CreateURLRequestSummary(1,
1,
"http://www.google.com",
"http://www.google.com",
ResourceType::MAIN_FRAME,
std::string(),
false);
predictor_->RecordURLRequest(main_frame);
EXPECT_EQ(1, static_cast<int>(predictor_->inflight_navigations_.size()));
// Now add a few subresources.
URLRequestSummary resource1 = CreateURLRequestSummary(
1, 1, "http://www.google.com", "http://google.com/style1.css",
ResourceType::STYLESHEET, "text/css", false);
predictor_->RecordURLResponse(resource1);
URLRequestSummary resource2 = CreateURLRequestSummary(
1, 1, "http://www.google.com", "http://google.com/script1.js",
ResourceType::SCRIPT, "text/javascript", false);
predictor_->RecordURLResponse(resource2);
URLRequestSummary resource3 = CreateURLRequestSummary(
1, 1, "http://www.google.com", "http://google.com/script2.js",
ResourceType::SCRIPT, "text/javascript", false);
predictor_->RecordURLResponse(resource3);
PrefetchData host_data(PREFETCH_KEY_TYPE_HOST, "www.google.com");
host_data.resources.push_back(ResourceRow(std::string(),
"http://google.com/style1.css",
ResourceType::STYLESHEET,
1,
0,
0,
1.0));
host_data.resources.push_back(ResourceRow(std::string(),
"http://google.com/script1.js",
ResourceType::SCRIPT,
1,
0,
0,
2.0));
host_data.resources.push_back(ResourceRow(std::string(),
"http://google.com/script2.js",
ResourceType::SCRIPT,
1,
0,
0,
3.0));
EXPECT_CALL(*mock_tables_.get(), UpdateData(empty_url_data_, host_data));
predictor_->OnNavigationComplete(main_frame.navigation_id);
profile_->BlockUntilHistoryProcessesPendingRequests();
}
TEST_F(ResourcePrefetchPredictorTest, NavigationUrlNotInDB) {
// Single navigation that will be recorded. Will check for duplicate
// resources and also for number of resources saved.
AddUrlToHistory("http://www.google.com", 4);
URLRequestSummary main_frame =
CreateURLRequestSummary(1,
1,
"http://www.google.com",
"http://www.google.com",
ResourceType::MAIN_FRAME,
std::string(),
false);
predictor_->RecordURLRequest(main_frame);
EXPECT_EQ(1, static_cast<int>(predictor_->inflight_navigations_.size()));
URLRequestSummary resource1 = CreateURLRequestSummary(
1, 1, "http://www.google.com", "http://google.com/style1.css",
ResourceType::STYLESHEET, "text/css", false);
predictor_->RecordURLResponse(resource1);
URLRequestSummary resource2 = CreateURLRequestSummary(
1, 1, "http://www.google.com", "http://google.com/script1.js",
ResourceType::SCRIPT, "text/javascript", false);
predictor_->RecordURLResponse(resource2);
URLRequestSummary resource3 = CreateURLRequestSummary(
1, 1, "http://www.google.com", "http://google.com/script2.js",
ResourceType::SCRIPT, "text/javascript", false);
predictor_->RecordURLResponse(resource3);
URLRequestSummary resource4 = CreateURLRequestSummary(
1, 1, "http://www.google.com", "http://google.com/script1.js",
ResourceType::SCRIPT, "text/javascript", true);
predictor_->RecordURLResponse(resource4);
URLRequestSummary resource5 = CreateURLRequestSummary(
1, 1, "http://www.google.com", "http://google.com/image1.png",
ResourceType::IMAGE, "image/png", false);
predictor_->RecordURLResponse(resource5);
URLRequestSummary resource6 = CreateURLRequestSummary(
1, 1, "http://www.google.com", "http://google.com/image2.png",
ResourceType::IMAGE, "image/png", false);
predictor_->RecordURLResponse(resource6);
URLRequestSummary resource7 = CreateURLRequestSummary(
1, 1, "http://www.google.com", "http://google.com/style2.css",
ResourceType::STYLESHEET, "text/css", true);
predictor_->RecordURLResponse(resource7);
PrefetchData url_data(PREFETCH_KEY_TYPE_URL, "http://www.google.com/");
url_data.resources.push_back(ResourceRow(std::string(),
"http://google.com/style1.css",
ResourceType::STYLESHEET,
1,
0,
0,
1.0));
url_data.resources.push_back(ResourceRow(std::string(),
"http://google.com/script1.js",
ResourceType::SCRIPT,
1,
0,
0,
2.0));
url_data.resources.push_back(ResourceRow(std::string(),
"http://google.com/script2.js",
ResourceType::SCRIPT,
1,
0,
0,
3.0));
url_data.resources.push_back(ResourceRow(std::string(),
"http://google.com/style2.css",
ResourceType::STYLESHEET,
1,
0,
0,
7.0));
EXPECT_CALL(*mock_tables_.get(), UpdateData(url_data, empty_host_data_));
PrefetchData host_data(PREFETCH_KEY_TYPE_HOST, "www.google.com");
host_data.resources = url_data.resources;
EXPECT_CALL(*mock_tables_.get(), UpdateData(empty_url_data_, host_data));
predictor_->OnNavigationComplete(main_frame.navigation_id);
profile_->BlockUntilHistoryProcessesPendingRequests();
}
TEST_F(ResourcePrefetchPredictorTest, NavigationUrlInDB) {
// Tests that navigation is recorded correctly for URL already present in
// the database cache.
AddUrlToHistory("http://www.google.com", 4);
EXPECT_CALL(*mock_tables_.get(),
GetAllData(Pointee(ContainerEq(PrefetchDataMap())),
Pointee(ContainerEq(PrefetchDataMap()))))
.WillOnce(DoAll(SetArgPointee<0>(test_url_data_),
SetArgPointee<1>(test_host_data_)));
ResetPredictor();
InitializePredictor();
EXPECT_EQ(3, static_cast<int>(predictor_->url_table_cache_->size()));
EXPECT_EQ(2, static_cast<int>(predictor_->host_table_cache_->size()));
URLRequestSummary main_frame =
CreateURLRequestSummary(1,
1,
"http://www.google.com",
"http://www.google.com",
ResourceType::MAIN_FRAME,
std::string(),
false);
predictor_->RecordURLRequest(main_frame);
EXPECT_EQ(1, static_cast<int>(predictor_->inflight_navigations_.size()));
URLRequestSummary resource1 = CreateURLRequestSummary(
1, 1, "http://www.google.com", "http://google.com/style1.css",
ResourceType::STYLESHEET, "text/css", false);
predictor_->RecordURLResponse(resource1);
URLRequestSummary resource2 = CreateURLRequestSummary(
1, 1, "http://www.google.com", "http://google.com/script1.js",
ResourceType::SCRIPT, "text/javascript", false);
predictor_->RecordURLResponse(resource2);
URLRequestSummary resource3 = CreateURLRequestSummary(
1, 1, "http://www.google.com", "http://google.com/script2.js",
ResourceType::SCRIPT, "text/javascript", false);
predictor_->RecordURLResponse(resource3);
URLRequestSummary resource4 = CreateURLRequestSummary(
1, 1, "http://www.google.com", "http://google.com/script1.js",
ResourceType::SCRIPT, "text/javascript", true);
predictor_->RecordURLResponse(resource4);
URLRequestSummary resource5 = CreateURLRequestSummary(
1, 1, "http://www.google.com", "http://google.com/image1.png",
ResourceType::IMAGE, "image/png", false);
predictor_->RecordURLResponse(resource5);
URLRequestSummary resource6 = CreateURLRequestSummary(
1, 1, "http://www.google.com", "http://google.com/image2.png",
ResourceType::IMAGE, "image/png", false);
predictor_->RecordURLResponse(resource6);
URLRequestSummary resource7 = CreateURLRequestSummary(
1, 1, "http://www.google.com", "http://google.com/style2.css",
ResourceType::STYLESHEET, "text/css", true);
predictor_->RecordURLResponse(resource7);
PrefetchData url_data(PREFETCH_KEY_TYPE_URL, "http://www.google.com/");
url_data.resources.push_back(ResourceRow(std::string(),
"http://google.com/style1.css",
ResourceType::STYLESHEET,
4,
2,
0,
1.0));
url_data.resources.push_back(ResourceRow(std::string(),
"http://google.com/script1.js",
ResourceType::SCRIPT,
1,
0,
0,
2.0));
url_data.resources.push_back(ResourceRow(std::string(),
"http://google.com/script4.js",
ResourceType::SCRIPT,
11,
1,
1,
2.1));
url_data.resources.push_back(ResourceRow(std::string(),
"http://google.com/script2.js",
ResourceType::SCRIPT,
1,
0,
0,
3.0));
EXPECT_CALL(*mock_tables_.get(), UpdateData(url_data, empty_host_data_));
EXPECT_CALL(
*mock_tables_.get(),
DeleteSingleDataPoint("www.facebook.com", PREFETCH_KEY_TYPE_HOST));
PrefetchData host_data(PREFETCH_KEY_TYPE_HOST, "www.google.com");
host_data.resources.push_back(ResourceRow(std::string(),
"http://google.com/style1.css",
ResourceType::STYLESHEET,
1,
0,
0,
1.0));
host_data.resources.push_back(ResourceRow(std::string(),
"http://google.com/script1.js",
ResourceType::SCRIPT,
1,
0,
0,
2.0));
host_data.resources.push_back(ResourceRow(std::string(),
"http://google.com/script2.js",
ResourceType::SCRIPT,
1,
0,
0,
3.0));
host_data.resources.push_back(ResourceRow(std::string(),
"http://google.com/style2.css",
ResourceType::STYLESHEET,
1,
0,
0,
7.0));
EXPECT_CALL(*mock_tables_.get(), UpdateData(empty_url_data_, host_data));
predictor_->OnNavigationComplete(main_frame.navigation_id);
profile_->BlockUntilHistoryProcessesPendingRequests();
}
TEST_F(ResourcePrefetchPredictorTest, NavigationUrlNotInDBAndDBFull) {
// Tests that a URL is deleted before another is added if the cache is full.
AddUrlToHistory("http://www.nike.com/", 4);
EXPECT_CALL(*mock_tables_.get(),
GetAllData(Pointee(ContainerEq(PrefetchDataMap())),
Pointee(ContainerEq(PrefetchDataMap()))))
.WillOnce(DoAll(SetArgPointee<0>(test_url_data_),
SetArgPointee<1>(test_host_data_)));
ResetPredictor();
InitializePredictor();
EXPECT_EQ(3, static_cast<int>(predictor_->url_table_cache_->size()));
EXPECT_EQ(2, static_cast<int>(predictor_->host_table_cache_->size()));
URLRequestSummary main_frame =
CreateURLRequestSummary(1,
1,
"http://www.nike.com",
"http://www.nike.com",
ResourceType::MAIN_FRAME,
std::string(),
false);
predictor_->RecordURLRequest(main_frame);
EXPECT_EQ(1, static_cast<int>(predictor_->inflight_navigations_.size()));
URLRequestSummary resource1 = CreateURLRequestSummary(
1, 1, "http://www.nike.com", "http://nike.com/style1.css",
ResourceType::STYLESHEET, "text/css", false);
predictor_->RecordURLResponse(resource1);
URLRequestSummary resource2 = CreateURLRequestSummary(
1, 1, "http://www.nike.com", "http://nike.com/image2.png",
ResourceType::IMAGE, "image/png", false);
predictor_->RecordURLResponse(resource2);
EXPECT_CALL(
*mock_tables_.get(),
DeleteSingleDataPoint("http://www.google.com/", PREFETCH_KEY_TYPE_URL));
EXPECT_CALL(
*mock_tables_.get(),
DeleteSingleDataPoint("www.facebook.com", PREFETCH_KEY_TYPE_HOST));
PrefetchData url_data(PREFETCH_KEY_TYPE_URL, "http://www.nike.com/");
url_data.resources.push_back(ResourceRow(std::string(),
"http://nike.com/style1.css",
ResourceType::STYLESHEET,
1,
0,
0,
1.0));
url_data.resources.push_back(ResourceRow(std::string(),
"http://nike.com/image2.png",
ResourceType::IMAGE,
1,
0,
0,
2.0));
EXPECT_CALL(*mock_tables_.get(), UpdateData(url_data, empty_host_data_));
PrefetchData host_data(PREFETCH_KEY_TYPE_HOST, "www.nike.com");
host_data.resources = url_data.resources;
EXPECT_CALL(*mock_tables_.get(), UpdateData(empty_url_data_, host_data));
predictor_->OnNavigationComplete(main_frame.navigation_id);
profile_->BlockUntilHistoryProcessesPendingRequests();
}
TEST_F(ResourcePrefetchPredictorTest, DeleteUrls) {
// Add some dummy entries to cache.
predictor_->url_table_cache_->insert(std::make_pair(
"http://www.google.com/page1.html",
PrefetchData(PREFETCH_KEY_TYPE_URL, "http://www.google.com/page1.html")));
predictor_->url_table_cache_->insert(std::make_pair(
"http://www.google.com/page2.html",
PrefetchData(PREFETCH_KEY_TYPE_URL, "http://www.google.com/page2.html")));
predictor_->url_table_cache_->insert(std::make_pair(
"http://www.yahoo.com/",
PrefetchData(PREFETCH_KEY_TYPE_URL, "http://www.yahoo.com/")));
predictor_->url_table_cache_->insert(std::make_pair(
"http://www.apple.com/",
PrefetchData(PREFETCH_KEY_TYPE_URL, "http://www.apple.com/")));
predictor_->url_table_cache_->insert(std::make_pair(
"http://www.nike.com/",
PrefetchData(PREFETCH_KEY_TYPE_URL, "http://www.nike.com/")));
predictor_->host_table_cache_->insert(std::make_pair(
"www.google.com",
PrefetchData(PREFETCH_KEY_TYPE_HOST, "www.google.com")));
predictor_->host_table_cache_->insert(std::make_pair(
"www.yahoo.com",
PrefetchData(PREFETCH_KEY_TYPE_HOST, "www.yahoo.com")));
predictor_->host_table_cache_->insert(std::make_pair(
"www.apple.com",
PrefetchData(PREFETCH_KEY_TYPE_HOST, "www.apple.com")));
history::URLRows rows;
rows.push_back(history::URLRow(GURL("http://www.google.com/page2.html")));
rows.push_back(history::URLRow(GURL("http://www.apple.com")));
rows.push_back(history::URLRow(GURL("http://www.nike.com")));
std::vector<std::string> urls_to_delete, hosts_to_delete;
urls_to_delete.push_back("http://www.google.com/page2.html");
urls_to_delete.push_back("http://www.apple.com/");
urls_to_delete.push_back("http://www.nike.com/");
hosts_to_delete.push_back("www.google.com");
hosts_to_delete.push_back("www.apple.com");
EXPECT_CALL(
*mock_tables_.get(),
DeleteData(ContainerEq(urls_to_delete), ContainerEq(hosts_to_delete)));
predictor_->DeleteUrls(rows);
EXPECT_EQ(2, static_cast<int>(predictor_->url_table_cache_->size()));
EXPECT_EQ(1, static_cast<int>(predictor_->host_table_cache_->size()));
EXPECT_CALL(*mock_tables_.get(), DeleteAllData());
predictor_->DeleteAllUrls();
EXPECT_TRUE(predictor_->url_table_cache_->empty());
EXPECT_TRUE(predictor_->host_table_cache_->empty());
}
TEST_F(ResourcePrefetchPredictorTest, OnMainFrameRequest) {
URLRequestSummary summary1 = CreateURLRequestSummary(1,
1,
"http://www.google.com",
"http://www.google.com",
ResourceType::MAIN_FRAME,
std::string(),
false);
URLRequestSummary summary2 = CreateURLRequestSummary(1,
2,
"http://www.google.com",
"http://www.google.com",
ResourceType::MAIN_FRAME,
std::string(),
false);
URLRequestSummary summary3 = CreateURLRequestSummary(2,
1,
"http://www.yahoo.com",
"http://www.yahoo.com",
ResourceType::MAIN_FRAME,
std::string(),
false);
predictor_->OnMainFrameRequest(summary1);
EXPECT_EQ(1, static_cast<int>(predictor_->inflight_navigations_.size()));
predictor_->OnMainFrameRequest(summary2);
EXPECT_EQ(2, static_cast<int>(predictor_->inflight_navigations_.size()));
predictor_->OnMainFrameRequest(summary3);
EXPECT_EQ(3, static_cast<int>(predictor_->inflight_navigations_.size()));
// Insert anther with same navigation id. It should replace.
URLRequestSummary summary4 = CreateURLRequestSummary(1,
1,
"http://www.nike.com",
"http://www.nike.com",
ResourceType::MAIN_FRAME,
std::string(),
false);
URLRequestSummary summary5 = CreateURLRequestSummary(1,
2,
"http://www.google.com",
"http://www.google.com",
ResourceType::MAIN_FRAME,
std::string(),
false);
predictor_->OnMainFrameRequest(summary4);
EXPECT_EQ(3, static_cast<int>(predictor_->inflight_navigations_.size()));
// Change this creation time so that it will go away on the next insert.
summary5.navigation_id.creation_time = base::TimeTicks::Now() -
base::TimeDelta::FromDays(1);
predictor_->OnMainFrameRequest(summary5);
EXPECT_EQ(3, static_cast<int>(predictor_->inflight_navigations_.size()));
URLRequestSummary summary6 = CreateURLRequestSummary(3,
1,
"http://www.shoes.com",
"http://www.shoes.com",
ResourceType::MAIN_FRAME,
std::string(),
false);
predictor_->OnMainFrameRequest(summary6);
EXPECT_EQ(3, static_cast<int>(predictor_->inflight_navigations_.size()));
EXPECT_TRUE(predictor_->inflight_navigations_.find(summary3.navigation_id) !=
predictor_->inflight_navigations_.end());
EXPECT_TRUE(predictor_->inflight_navigations_.find(summary4.navigation_id) !=
predictor_->inflight_navigations_.end());
EXPECT_TRUE(predictor_->inflight_navigations_.find(summary6.navigation_id) !=
predictor_->inflight_navigations_.end());
}
TEST_F(ResourcePrefetchPredictorTest, OnMainFrameRedirect) {
URLRequestSummary summary1 = CreateURLRequestSummary(1,
1,
"http://www.google.com",
"http://www.google.com",
ResourceType::MAIN_FRAME,
std::string(),
false);
URLRequestSummary summary2 = CreateURLRequestSummary(1,
2,
"http://www.google.com",
"http://www.google.com",
ResourceType::MAIN_FRAME,
std::string(),
false);
URLRequestSummary summary3 = CreateURLRequestSummary(2,
1,
"http://www.yahoo.com",
"http://www.yahoo.com",
ResourceType::MAIN_FRAME,
std::string(),
false);
predictor_->OnMainFrameRedirect(summary1);
EXPECT_TRUE(predictor_->inflight_navigations_.empty());
predictor_->OnMainFrameRequest(summary1);
EXPECT_EQ(1, static_cast<int>(predictor_->inflight_navigations_.size()));
predictor_->OnMainFrameRequest(summary2);
EXPECT_EQ(2, static_cast<int>(predictor_->inflight_navigations_.size()));
predictor_->OnMainFrameRedirect(summary3);
EXPECT_EQ(2, static_cast<int>(predictor_->inflight_navigations_.size()));
predictor_->OnMainFrameRedirect(summary1);
EXPECT_EQ(1, static_cast<int>(predictor_->inflight_navigations_.size()));
predictor_->OnMainFrameRedirect(summary2);
EXPECT_TRUE(predictor_->inflight_navigations_.empty());
}
TEST_F(ResourcePrefetchPredictorTest, OnSubresourceResponse) {
// If there is no inflight navigation, nothing happens.
URLRequestSummary resource1 = CreateURLRequestSummary(
1, 1, "http://www.google.com", "http://google.com/style1.css",
ResourceType::STYLESHEET, "text/css", false);
predictor_->OnSubresourceResponse(resource1);
EXPECT_TRUE(predictor_->inflight_navigations_.empty());
// Add an inflight navigation.
URLRequestSummary main_frame1 =
CreateURLRequestSummary(1,
1,
"http://www.google.com",
"http://www.google.com",
ResourceType::MAIN_FRAME,
std::string(),
false);
predictor_->OnMainFrameRequest(main_frame1);
EXPECT_EQ(1, static_cast<int>(predictor_->inflight_navigations_.size()));
// Now add a few subresources.
URLRequestSummary resource2 = CreateURLRequestSummary(
1, 1, "http://www.google.com", "http://google.com/script1.js",
ResourceType::SCRIPT, "text/javascript", false);
URLRequestSummary resource3 = CreateURLRequestSummary(
1, 1, "http://www.google.com", "http://google.com/script2.js",
ResourceType::SCRIPT, "text/javascript", false);
predictor_->OnSubresourceResponse(resource1);
predictor_->OnSubresourceResponse(resource2);
predictor_->OnSubresourceResponse(resource3);
EXPECT_EQ(1, static_cast<int>(predictor_->inflight_navigations_.size()));
EXPECT_EQ(3, static_cast<int>(
predictor_->inflight_navigations_[main_frame1.navigation_id]->size()));
EXPECT_TRUE(URLRequestSummaryAreEqual(
resource1,
predictor_->inflight_navigations_[main_frame1.navigation_id]->at(0)));
EXPECT_TRUE(URLRequestSummaryAreEqual(
resource2,
predictor_->inflight_navigations_[main_frame1.navigation_id]->at(1)));
EXPECT_TRUE(URLRequestSummaryAreEqual(
resource3,
predictor_->inflight_navigations_[main_frame1.navigation_id]->at(2)));
}
} // namespace predictors
| [
"[email protected]"
] | |
f7896669371f364ecdd52a629054c0bc8329e10e | 5436011a815b5ea17177b48828e1769b0712939c | /checkIfAGivenStringCanBeRearrangedToPalinDromeOrNot.cpp | 9cbb268282834d5b2245cbe2df95d00f26ac9675 | [] | no_license | amitprat/PracticeCode | d43b47215d19947ec93bf048e2beed61b3b31978 | 948732e9f943d5a748befb43ec3242d537a28c39 | refs/heads/master | 2023-08-31T07:54:41.339417 | 2023-08-20T08:12:07 | 2023-08-20T08:12:07 | 28,275,561 | 3 | 5 | null | null | null | null | UTF-8 | C++ | false | false | 748 | cpp | //Reference : http://www.careercup.com/question?id=5635989726822400
Write a program to test whether a string and all strings that can be made using the characters of that string are palindrome or not.
Eg:
Input Output
mmo True
yakak True
travel False
Get the string length as x
Put all characters with respective count in a map or array with count as value and character ascii as index
Scan through the map, and count the odd chars
if count(oddChars) > 1 || count(oddChars) == 1 && len&1 == 0
return false;
else
return true;
/If we need to rearrange chars also to make it palindrome then,
fidn the odd char (count) position if there , keep it at midlen
now iterate for each each <char,freq> in map, and place at l=(mid-1), r=(mid+1)
| [
"[email protected]"
] | |
a3882bcc4e8dd8ed756c81a56f479bb05f973e16 | efe279fe3ec4cff5ff8d644a6e8ec6fd1ffd8048 | /spaceInvaders.cpp | fbba1b42e9a377ece642e3df85915701ba02eb25 | [] | no_license | jvbechara/SpaceInvaders | 659eb0869556bae5e5d6177ae4730766e900f66d | 1a4f92be0d25f9e8c5571da1207c6377a660ab57 | refs/heads/master | 2020-03-26T21:06:40.954698 | 2018-08-20T04:34:51 | 2018-08-20T04:34:51 | 145,366,539 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 20,599 | cpp | #include <iostream>
#include <allegro5/allegro.h>
#include <allegro5/allegro_image.h>
#include <allegro5/allegro_ttf.h>
#include <allegro5/allegro_font.h>
#include <allegro5/allegro_primitives.h>
#include <allegro5/allegro_audio.h>
#include <allegro5/allegro_acodec.h>
#include <stdio.h>
#include <stdbool.h>
#include <list>
using namespace std;
const int LARGURA_TELA = 640;
const int ALTURA_TELA = 680;
ALLEGRO_DISPLAY *janela = NULL;
ALLEGRO_EVENT_QUEUE *fila_eventos = NULL;
ALLEGRO_BITMAP *nave = NULL;
ALLEGRO_BITMAP *tela_inicial = NULL;
ALLEGRO_BITMAP *aliens = NULL;
ALLEGRO_FONT *fonte = NULL;
ALLEGRO_TIMER *timer = NULL;
ALLEGRO_SAMPLE *sample = NULL;
ALLEGRO_SAMPLE *fundo = NULL;
ALLEGRO_SAMPLE *bonus = NULL;
ALLEGRO_SAMPLE *morte = NULL;
ALLEGRO_AUDIO_STREAM *musica = NULL;
const float FPS = 60;
bool inicializar();
class Aliens{
public:
int value;
int posX;
int posY;
bool alive;
Aliens(){
value = 0;
alive = true;
aliens = al_load_bitmap("spriteSI.png");
}
void setValue(int v){
value = v;
}
int getValue(){
return value;
}
int getPosX(){
return posX;
}
int getPosY(){
return posY;
}
void setPosX(int px){
posX = px;
}
void setPosY(int py){
posY = py;
}
int getAlive(){
return alive;
}
void setAlive( bool a){
alive = a;
}
};
class Shot{
public:
int posX;
int posY;
bool active;
int maxShot;
Shot(){
maxShot = 12;
}
int getPosX(){
return posX;
}
int getPosY(){
return posY;
}
void setPosX(int px){
posX = px;
}
void setPosY(int py){
posY = py;
}
void setActive(bool ac){
active = ac;
}
bool getActive(){
return active;
}
};
class Barreira{
public:
int posX;
int posY;
int kind;
bool active;
Barreira(){
active = true;
kind = 0;
}
int getPosX(){
return posX;
}
int getPosY(){
return posY;
}
void setPosX(int px){
posX = px;
}
void setPosY(int py){
posY = py;
}
void setKind(int k){
kind = k;
}
int getKind(){
return kind;
}
bool getActive(){
return active;
}
void setActive(bool ac){
active = ac;
}
};
class Nave{
public:
int posX;
int posY;
int speed;
int life;
Nave(){
nave = al_load_bitmap("spriteSI.png");
life = 3;
}
int getPosX(){
return posX;
}
int getPosY(){
return posY;
}
void setPosX(int px){
posX = px;
}
void setPosY(int py){
posY = py;
}
void setLife(int l){
life = l;
}
int getLife(){
return life;
}
void draw(){
//al_draw_bitmap_region(nave,474,83,44,32,posX,posY,0);
al_draw_bitmap_region(nave,357,20,43,27,posX,posY,0);
for(int i=0; i<life; i++){
al_draw_bitmap_region(nave,357,20,43,27,20+i*55,ALTURA_TELA-50,0);
}
}
void right(){
if(posX+speed < LARGURA_TELA-93){
posX = posX+speed;
al_draw_bitmap_region(nave,357,20,43,27,posX,posY,0);
}
}
void left(){
if(posX+speed > 50 ){
posX = posX-speed;
al_draw_bitmap_region(nave,357,20,43,27,posX,posY,0);
}
}
void setSpeed(int s){
speed = s;
}
int getSpeed(){
return speed;
}
};
class SpaceInvaders{
public:
int score;
int speedAliens;
int nAliens;
int e;
Aliens **a;
Aliens especial;
Barreira *b;
Nave n;
Shot *shot;
Shot *shotAliens;
SpaceInvaders(){
a = new Aliens*[6];
for(int i=0; i<6; i++){
a[i] = new Aliens[6];
}
shot = new Shot[12];
for(int i=0; i<12; i++){
shot[i].setActive(false);
}
e = 1;
shotAliens = new Shot[2];
for(int i=0; i<2; i++){
shotAliens[i].setActive(false);
}
especial.setValue(100);
especial.setPosX(0);
especial.setPosY(90);
especial.setAlive(false);
fonte = al_load_font("space_invaders.ttf", 20, 0);
b = new Barreira[3];
n.setPosX(LARGURA_TELA/2-47);
n.setPosY(ALTURA_TELA-90);
n.setSpeed(6);
nAliens = 36;
score = 0;
aliens = al_load_bitmap("spriteSI.png");
}
void initialize(){
for(int i=0; i<6; i++){
for(int j=0; j<6; j++){
if(i == 0){
al_draw_bitmap_region(aliens,5,20,30,28,50+70*j,130,0);
a[i][j].setValue(30);
a[i][j].setPosX(50+ 70*j);
a[i][j].setPosY(130);
}
else if(i == 1){
al_draw_bitmap_region(aliens,5,20,30,28,50+ 70*j,130+40,0);
a[i][j].setValue(25);
a[i][j].setPosX(50+ 70*j);
a[i][j].setPosY(130+40);
}
else if(i == 2){
al_draw_bitmap_region(aliens,92,20,37,30,50+ 70*j,130+80,0);
a[i][j].setValue(20);
a[i][j].setPosX(50+ 70*j);
a[i][j].setPosY(130+80);
}
else if(i == 3){
al_draw_bitmap_region(aliens,92,20,37,30,50+ 70*j,130+120,0);
a[i][j].setValue(15);
a[i][j].setPosX(50+ 70*j);
a[i][j].setPosY(130+120);
}
else if(i == 4){
al_draw_bitmap_region(aliens,186,20,38,33,50+ 70*j,130+160,0);
a[i][j].setValue(10);
a[i][j].setPosX(50+ 70*j);
a[i][j].setPosY(130+160);
}
else if(i == 5){
al_draw_bitmap_region(aliens,186,20,38,33,50+ 70*j,130+200,0);
a[i][j].setValue(5);
a[i][j].setPosX(50+ 70*j);
a[i][j].setPosY(130+200);
}
}
}
al_draw_bitmap_region(aliens,410,5,62,46,LARGURA_TELA/4 -31,540,0);
b[0].setPosX(LARGURA_TELA/4 -31);
b[0].setPosY(540);
al_draw_bitmap_region(aliens,410,5,62,46,LARGURA_TELA/4*2-31,540,0);
b[1].setPosX(LARGURA_TELA/4*2-31);
b[1].setPosY(540);
al_draw_bitmap_region(aliens,410,5,62,46,LARGURA_TELA/4*3-31,540,0);
b[2].setPosX(LARGURA_TELA/4*3-31);
b[2].setPosY(540);
}
void right_nave(){
n.right();
}
void left_nave(){
n.left();
}
void tiro(){
for(int i=0; i<12; i++){
if(shot[i].getActive() == false){
shot[i].setActive(true);
shot[i].setPosX(n.getPosX() + (43/2));
shot[i].setPosY(n.getPosY()-20);
break;
}
}
}
void draw_nave(){
n.draw();
}
int aliensWalking(int direction){
for(int i=0; i<6; i++){
for(int j=0; j<6; j++){
a[i][j].setPosX(a[i][j].getPosX()+direction);
}
}
if(a[5][5].getPosX() >= 590 -34){
if(direction == 1){
for(int i=0; i<6; i++){
for(int j=0; j<6; j++){
a[i][j].setPosY(a[i][j].getPosY()+20);
}
}
}
return -1;
}
else if(a[0][0].getPosX() <= 50){
if(direction == -1){
for(int i=0; i<6; i++){
for(int j=0; j<6; j++){
a[i][j].setPosY(a[i][j].getPosY()+5);
}
}
}
return 1;
}
else
return direction;
}
void score_text(){
al_draw_bitmap_region(aliens,10,70,165,30,LARGURA_TELA/2-80,10,0);
al_draw_textf(fonte, al_map_rgb(255, 255, 255), LARGURA_TELA/2,50, ALLEGRO_ALIGN_CENTER, "00000");
al_draw_textf(fonte, al_map_rgb(255, 255, 255), LARGURA_TELA-40, 10, ALLEGRO_ALIGN_RIGHT, "SCORE<2>");
al_draw_textf(fonte, al_map_rgb(255, 255, 255), 35, 10, ALLEGRO_ALIGN_LEFT, "SCORE<1>");
al_draw_textf(fonte, al_map_rgb(255, 255, 255), LARGURA_TELA-70, ALTURA_TELA-40, ALLEGRO_ALIGN_RIGHT, "CREDIT 00");
al_draw_textf(fonte, al_map_rgb(255, 255, 255), 60, 50, ALLEGRO_ALIGN_LEFT, "%04d", score);
al_draw_line( 0, ALTURA_TELA-50, LARGURA_TELA, ALTURA_TELA-50, al_map_rgb(0, 255, 0), 1);
}
void print(int estado){
score_text();
if(estado == 0){
if(e == 1){
al_play_sample(fundo, 1.0, 0.0, 1.0, ALLEGRO_PLAYMODE_ONCE, NULL);
e = 0;
}
for(int i=0; i<6; i++){
for(int j=0; j<6; j++){
if(i == 0){
if(a[i][j].getAlive() == true)
al_draw_bitmap_region(aliens,5,20,30,28,a[i][j].getPosX(),a[i][j].getPosY(),0);
}
else if(i == 1){
if(a[i][j].getAlive() == true)
al_draw_bitmap_region(aliens,5,20,30,28,a[i][j].getPosX(),a[i][j].getPosY(),0);
}
else if(i == 2){
if(a[i][j].getAlive() == true)
al_draw_bitmap_region(aliens,92,20,37,30,a[i][j].getPosX(),a[i][j].getPosY(),0);
}
else if(i == 3){
if(a[i][j].getAlive() == true)
al_draw_bitmap_region(aliens,92,20,37,30,a[i][j].getPosX(),a[i][j].getPosY(),0);
}
else if(i == 4){
if(a[i][j].getAlive() == true)
al_draw_bitmap_region(aliens,186,20,38,33,a[i][j].getPosX(),a[i][j].getPosY(),0);
}
else if(i == 5){
if(a[i][j].getAlive() == true)
al_draw_bitmap_region(aliens,186,20,38,33,a[i][j].getPosX(),a[i][j].getPosY(),0);
}
}
}
}
else{
if(e == 0){
al_play_sample(fundo, 1.0, 0.0, 1.0, ALLEGRO_PLAYMODE_ONCE, NULL);
e = 1;
}
for(int i=0; i<6; i++){
for(int j=0; j<6; j++){
if(i == 0){
if(a[i][j].getAlive() == true)
al_draw_bitmap_region(aliens,52,20,30,28,a[i][j].getPosX(),a[i][j].getPosY(),0);
}
else if(i == 1){
if(a[i][j].getAlive() == true)
al_draw_bitmap_region(aliens,52,20,30,28,a[i][j].getPosX(),a[i][j].getPosY(),0);
}
else if(i == 2){
if(a[i][j].getAlive() == true)
al_draw_bitmap_region(aliens,140,20,37,30,a[i][j].getPosX(),a[i][j].getPosY(),0);
}
else if(i == 3){
if(a[i][j].getAlive() == true)
al_draw_bitmap_region(aliens,140,20,37,30,a[i][j].getPosX(),a[i][j].getPosY(),0);
}
else if(i == 4){
if(a[i][j].getAlive() == true)
al_draw_bitmap_region(aliens,231,20,38,33,a[i][j].getPosX(),a[i][j].getPosY(),0);
}
else if(i == 5){
if(a[i][j].getAlive() == true)
al_draw_bitmap_region(aliens,231,20,38,33,a[i][j].getPosX(),a[i][j].getPosY(),0);
}
}
}
}
for(int i=0; i<12; i++){ // TIROS NAVE
if(shot[i].getActive() == true){
al_draw_bitmap_region(aliens,535,88,8,18,shot[i].getPosX(),shot[i].getPosY(),0);
shot[i].setPosY(shot[i].getPosY()-15);
if(shot[i].getPosY() < 0){
shot[i].setActive(false);
}
}
}
for(int i=0; i<2; i++){ // TIROS ALIENS
if(shotAliens[i].getActive() == true){
al_draw_bitmap_region(aliens,535,88,8,18,shotAliens[i].getPosX(),shotAliens[i].getPosY(), ALLEGRO_FLIP_VERTICAL);
shotAliens[i].setPosY(shotAliens[i].getPosY()+8);
if(shotAliens[i].getPosY() > ALTURA_TELA-60){
shotAliens[i].setActive(false);
}
}
}
for(int i=0; i<3; i++){ // BARREIRAS
if((b[i].getKind() == 0 || b[i].getKind() == 1))
al_draw_bitmap_region(aliens,410,5,62,46,b[i].getPosX(),b[i].getPosY(),0);
else if((b[i].getKind() == 2 || b[i].getKind() == 3))
al_draw_bitmap_region(aliens,624,2,62,47,b[i].getPosX(),b[i].getPosY(),0);
else if((b[i].getKind() == 4 || b[i].getKind() == 5))
al_draw_bitmap_region(aliens,623,72,62,46,b[i].getPosX(),b[i].getPosY(),0);
else if((b[i].getKind() == 6 || b[i].getKind() == 7))
al_draw_bitmap_region(aliens,556,2,62,46,b[i].getPosX(),b[i].getPosY(),0);
else if((b[i].getKind() == 8 || b[i].getKind() == 9))
al_draw_bitmap_region(aliens,483,2,62,46,b[i].getPosX(),b[i].getPosY(),0);
else{
b[i].setActive(false);
}
}
if(especial.getAlive() == true){ //BONUS
al_draw_bitmap_region(aliens,275,18,70,18,especial.getPosX(),especial.getPosY(),0);
}
}
void colision_aliens(){
for(int i=0; i<12; i++){
if(shot[i].getActive() == true){
for(int k=5; k>=0; k--){
for(int j=0; j<6; j++){
if(a[k][j].getAlive() == true){
if(k == 5 || k == 4){
if(a[k][j].getPosX() < shot[i].getPosX()+4 &&
a[k][j].getPosX()+38 > shot[i].getPosX()+4 &&
shot[i].getPosY() < a[k][j].getPosY()+15 &&
shot[i].getActive() == true){
a[k][j].setAlive(false);
shot[i].setActive(false);
al_draw_bitmap_region(aliens,565,82,39,30,a[k][j].getPosX(),a[k][j].getPosY(),0);
al_flip_display();
score = score + a[k][j].getValue();
break;
}
}
if(k == 3 || k == 2){
if(a[k][j].getPosX() < shot[i].getPosX()+4 &&
a[k][j].getPosX()+37 > shot[i].getPosX()+4 &&
shot[i].getPosY() < a[k][j].getPosY()+15 &&
shot[i].getActive() == true){
a[k][j].setAlive(false);
shot[i].setActive(false);
al_draw_bitmap_region(aliens,565,82,39,30,a[k][j].getPosX(),a[k][j].getPosY(),0);
al_flip_display();
score = score + a[k][j].getValue();
break;
}
}
if(k == 1 || k == 0){
if(a[k][j].getPosX() < shot[i].getPosX()+4 &&
a[k][j].getPosX()+30 > shot[i].getPosX()+4 &&
shot[i].getPosY() < a[k][j].getPosY()+15 &&
shot[i].getActive() == true){
a[k][j].setAlive(false);
shot[i].setActive(false);
al_draw_bitmap_region(aliens,565,82,39,30,a[k][j].getPosX(),a[k][j].getPosY(),0);
al_flip_display();
score = score + a[k][j].getValue();
break;
}
}
}
}
}
if(especial.getPosX() < shot[i].getPosX()+4 &&
especial.getPosX()+70 > shot[i].getPosX()+4 &&
shot[i].getPosY() < especial.getPosY()+18 &&
shot[i].getActive() == true){
especial.setAlive(false);
especial.setPosX(ALTURA_TELA);
shot[i].setActive(false);
al_draw_bitmap_region(aliens,565,82,39,30,especial.getPosX(),especial.getPosY(),0);
al_flip_display();
score = score + especial.getValue();
}
}
}
}
void shooting_aliens(){
int s1, s2;
s1 = rand()%6;
for(int j=0; j<6; j++){
for(int i=5; i>=0; i--){
for(int k=0; k<2; k++){
if(a[i][j].getAlive() == true &&
shotAliens[k].getActive() == false &&
j==s1 ){
shotAliens[k].setActive(true);
if(a[i][j].getValue() == 5 || a[i][j].getValue() == 10){
shotAliens[k].setPosX(a[i][j].getPosX() + (30/2));
shotAliens[k].setPosY(a[i][j].getPosY() + 28);
}
else if(a[i][j].getValue() == 15 || a[i][j].getValue() == 20){
shotAliens[k].setPosX(a[i][j].getPosX() + (36/2));
shotAliens[k].setPosY(a[i][j].getPosY() + 30);
}
else if(a[i][j].getValue() == 25 || a[i][j].getValue() == 30){
shotAliens[k].setPosX(a[i][j].getPosX() + (38/2));
shotAliens[k].setPosY(a[i][j].getPosY() + 33);
}
return;
}
}
}
}
}
void colision_nave(){
for(int i=0; i<2; i++){
if(shotAliens[i].getPosX()+4 > n.getPosX() &&
shotAliens[i].getPosX()+4 < n.getPosX() + 43 &&
shotAliens[i].getPosY()+9 > n.getPosY() &&
shotAliens[i].getActive() == true ){
n.setLife(n.getLife()-1);
al_draw_bitmap_region(aliens,474,83,44,32,n.getPosX(), n.getPosY(),0);
al_flip_display();
al_play_sample(morte, 1.0, 0.0, 1.0, ALLEGRO_PLAYMODE_ONCE, NULL);
al_rest(1.2);
shotAliens[i].setActive(false);
}
}
}
void colision_barreira(){
for(int i=0; i<3; i++){
for(int j=0; j<2; j++){
if(b[i].getActive() == true &&
shotAliens[j].getActive() == true &&
shotAliens[j].getPosX()+4 > b[i].getPosX() &&
shotAliens[j].getPosX()+4 < b[i].getPosX()+62 &&
shotAliens[j].getPosY()+9 > b[i].getPosY()){
shotAliens[j].setActive(false);
b[i].setKind(b[i].getKind() + 1);
}
}
}
}
bool gameOver(){
if(n.getLife() == -1){
al_clear_to_color(al_map_rgb(0,0,0));
al_draw_textf(fonte, al_map_rgb(255, 255, 255), LARGURA_TELA/2, ALTURA_TELA/2, ALLEGRO_ALIGN_CENTER, "SCORE %04d", score);
al_flip_display();
al_rest(10.0);
return true;
}
}
void bonus(){
if(especial.getAlive() == true){
especial.setPosX(especial.getPosX()+3);
}
else{
if(score > 400 && especial.getPosX() < 10){
especial.setAlive(true);
}
}
}
};
int main(void){
int f = 0;
bool sair = false;
srand( (unsigned)time(NULL) );
if (!inicializar()){
return -1;
}
int tecla = 0;
int direction = 1;
int vel = 2;
al_clear_to_color(al_map_rgb(0,0,0));
al_flip_display();
SpaceInvaders si;
si.initialize();
al_flip_display();
al_attach_audio_stream_to_mixer(musica, al_get_default_mixer());
al_clear_to_color(al_map_rgb(0,0,0));
tela_inicial = al_load_bitmap("space_invaders_sprite_sheet_by_gooperblooper22.png");
al_draw_bitmap_region(tela_inicial,0,0,610,180, 20,240, 0);
al_flip_display();
al_rest(5.0);
while (!sair){
al_clear_to_color(al_map_rgb(0,0,0));
if(int(al_get_time()*vel)%2 == 0){
si.print(0);
}
else
si.print(1);
si.draw_nave();
al_flip_display();
//al_play_sample(fundo, 1.0, 0.0, 1.0, ALLEGRO_PLAYMODE_ONCE, NULL);
//al_rest(0.5);
//al_set_audio_stream_playing(musica, true);
ALLEGRO_EVENT evento;
ALLEGRO_TIMEOUT timeout;
al_init_timeout(&timeout, 0.0005);
int tem_eventos = al_wait_for_event_until(fila_eventos, &evento, &timeout);
if (evento.type == ALLEGRO_EVENT_DISPLAY_CLOSE){
sair = true;
}
if (evento.type == ALLEGRO_EVENT_KEY_DOWN){
switch(evento.keyboard.keycode){
case ALLEGRO_KEY_SPACE:
tecla = 1;
al_play_sample(sample, 1.0, 0.0, 1.0, ALLEGRO_PLAYMODE_ONCE, NULL);
break;
case ALLEGRO_KEY_LEFT:
tecla = 2;
break;
case ALLEGRO_KEY_RIGHT:
tecla = 3;
break;
}
}
/*else{
tecla =0;
}*/
si.colision_aliens();
if(int(al_get_time())%7 == 0){
si.shooting_aliens();
}
if(int(al_get_time())%11 == 0){
si.shooting_aliens();
}
/*if(int(al_get_time())%2 == 1 && int(al_get_time()) != f){
f = int(al_get_time());
al_play_sample(fundo, 1.0, 0.0, 1.0, ALLEGRO_PLAYMODE_ONCE, NULL);
}*/
if(tecla == 2)
si.left_nave();
else if(tecla == 3)
si.right_nave();
else if(tecla == 1){
si.tiro();
tecla = 0;
}
si.colision_nave();
si.colision_barreira();
direction = si.aliensWalking(direction);
si.bonus();
if(si.gameOver()){
sair = true;
}
al_flip_display();
}
al_destroy_audio_stream(musica);
al_destroy_sample(sample);
al_destroy_display(janela);
al_destroy_event_queue(fila_eventos);
return 0;
}
bool inicializar(){
if (!al_init())
{
fprintf(stderr, "Falha ao inicializar a Allegro.\n");
return false;
}
al_init_font_addon();
if (!al_init_ttf_addon())
{
fprintf(stderr, "Falha ao inicializar add-on allegro_ttf.\n");
return false;
}
if (!al_init_image_addon())
{
fprintf(stderr, "Falha ao inicializar add-on allegro_image.\n");
return false;
}
if (!al_install_keyboard())
{
fprintf(stderr, "Falha ao inicializar o teclado.\n");
return false;
}
if (!al_init_primitives_addon())
{
fprintf(stderr, "Falha ao inicializar add-on de primitivas.\n");
return false;
}
janela = al_create_display(LARGURA_TELA, ALTURA_TELA);
if (!janela)
{
fprintf(stderr, "Falha ao criar janela.\n");
return false;
}
// Inicializa o add-on para utilização de imagens
al_init_image_addon();
al_set_window_title(janela, "SPACE INVADERS - JOÃO VICTOR MARINHO BECHARA");
fila_eventos = al_create_event_queue();
if (!fila_eventos)
{
fprintf(stderr, "Falha ao criar fila de eventos.\n");
al_destroy_display(janela);
return false;
}
if (!al_install_audio())
{
fprintf(stderr, "Falha ao inicializar áudio.\n");
return false;
}
if (!al_init_acodec_addon())
{
fprintf(stderr, "Falha ao inicializar codecs de áudio.\n");
return false;
}
if (!al_reserve_samples(1))
{
fprintf(stderr, "Falha ao alocar canais de áudio.\n");
return false;
}
sample = al_load_sample("shoot.wav");
if (!sample)
{
fprintf(stderr, "Falha ao carregar sample.\n");
al_destroy_display(janela);
return false;
}
fundo = al_load_sample("fastinvader1.wav");
if (!fundo)
{
fprintf(stderr, "Falha ao carregar sample.\n");
al_destroy_display(janela);
return false;
}
morte = al_load_sample("explosion.wav");
if (!morte)
{
fprintf(stderr, "Falha ao carregar sample.\n");
al_destroy_display(janela);
return false;
}
bonus = al_load_sample("ufo_lowpitch.wav");
if (!bonus)
{
fprintf(stderr, "Falha ao carregar sample.\n");
al_destroy_display(janela);
return false;
}
musica = al_load_audio_stream("fastinvader1.wav", 4, 1024);
if (!musica)
{
fprintf(stderr, "Falha ao carregar audio.\n");
al_destroy_event_queue(fila_eventos);
al_destroy_display(janela);
al_destroy_sample(sample);
return false;
}
al_register_event_source(fila_eventos, al_get_keyboard_event_source());
al_register_event_source(fila_eventos, al_get_display_event_source(janela));
return true;
}
| [
"[email protected]"
] | |
981ce74453513dd8c81cdca6e465d23be08642d0 | df6bb56c094ba1b9ab8bfc054ff234c212285118 | /Codeforce/242B_BigSegment.cpp | 6771378213935ca8b9379b653a54311a90edc1b6 | [] | no_license | thientoan0101/CodeForce | ddc5432d346285f3b390e456cf0ea8c0178b5542 | fb89eb7c158e9de47d27faca0f2732897b2a427d | refs/heads/main | 2023-04-18T19:33:24.669756 | 2021-04-24T01:16:46 | 2021-04-24T01:16:46 | 361,042,802 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 453 | cpp | #include <iostream>
#include <string>
#include <vector>
using namespace std;
int main()
{
int n;
cin >> n;
vector<int> L(n), R(n);
for (int i = 0; i < n; i++) {
cin >> L[i] >> R[i];
}
int min = L[0], max = R[0];
for (int i = 1; i < n; i++) {
if (min > L[i]) min = L[i];
if (max < R[i]) max = R[i];
}
for (int i = 0; i < n; i++) {
if (L[i] == min && R[i] == max) {
cout << i + 1;
return 0;
}
}
cout << -1;
return 0;
} | [
"[email protected]"
] | |
f4f3fd7f2fca65c182482b1873e60f40ca69e3e6 | 1d6b4209facf36398960670d1d6db9fd9f9dbf61 | /Cpp DS/dynamic/memorization/max_sum_inc_subseq.cpp | 9cd3bfe2d651aaf51bf6bfcbca44619833f39dc7 | [] | no_license | himankjn/DS-ALGO | 5fd207bd35e79c8aa96e5ae5a56df1d6ba1e8986 | 391bec00ff92256dc8cb32918965385a3e484c92 | refs/heads/master | 2023-07-01T16:17:18.572131 | 2021-08-10T04:37:48 | 2021-08-10T04:37:48 | 389,082,157 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 493 | cpp | #include<iostream>
#include<vector>
using namespace std;
vector<int>dp (1000,-1);
int msis(int arr[], int n)
{
if(n==0){
return arr[0];
}
int max=0;
for(int j=0;j<n;j++){
if (dp[j]==-1)dp[j]=msis(arr,j);
if(arr[j]<arr[n] && dp[j]>max)
max=dp[j];
}
return (arr[n]+max);
}
int main(){
int n;
cin>>n;
int a[n];
for(int i=0;i<n;i++){
cin>>a[i];
}
cout<<msis(a,n-1);
return 0;
} | [
"[email protected]"
] | |
3c4caaecfb0e64f12d26cd612ddd1218ab070be7 | 44b200bd08c729fdf40e8369564123537a937cf9 | /PWM-RGB/PWM-RGB.ino | 17a24a11c676752a9626d0bf92f39f61eb90dd25 | [] | no_license | CinisSec/Arduino-testinground | 2a9444f73a3fccbe7dbd4f6416e279241c4c2e2d | 022d12d52cc3f5a5b35df3a7aa3e406d237c13e4 | refs/heads/main | 2023-07-27T05:13:50.630878 | 2021-09-10T20:18:13 | 2021-09-10T20:18:13 | 400,294,554 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 881 | ino | const int redrgbpin = 11;
const int bluergbpin = 10;
const int greenrgbpin = 9;
const int redsensorpin = A0;
const int bluesensorpin = A1;
const int greensensorpin = A2;
int red = 0;
int blue = 0;
int green = 0;
int redsensor = 0;
int bluesensor = 0;
int greensensor = 0;
void setup() {
// put your setup code here, to run once:
Serial.begin(9600);
pinMode(redrgbpin, OUTPUT);
pinMode(bluergbpin, OUTPUT);
pinMode(greenrgbpin, OUTPUT);
}
void loop() {
// put your main code here, to run repeatedly:
redsensor = analogRead(redsensorpin);
delay(5);
bluesensor = analogRead(bluesensorpin);
delay(5);
greensensor = analogRead(greensensorpin);
red = random(255);
blue = random(255);
green = random(255);
analogWrite(redrgbpin,red);
delay(100);
analogWrite(bluergbpin,blue);
delay(200);
analogWrite(greenrgbpin,green);
delay(100);
}
| [
"[email protected]"
] | |
05ae58782e729a197c52a15d0d346cddbb230d1b | dde1ddb460e02dd8fce6962489012aae802c4c64 | /floyd_warshall.cpp | 024939c177451087743f585279de3cd15c11b19d | [] | no_license | hotblaze18/ADA_1BM18CS072 | eb7355912434e33ac5c227fe94c58b7bec9ac4d7 | faac96b7c3ee48b460915b9edf88bf853bb5a5f9 | refs/heads/master | 2020-12-28T14:13:57.101091 | 2020-05-16T07:25:50 | 2020-05-16T07:25:50 | 238,365,121 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 987 | cpp | #include<iostream>
#define V 4
using namespace std;
void floydWarshall (int graph[][V])
{
int dist[V][V], i, j, k;
for (i = 0; i < V; i++)
for (j = 0; j < V; j++)
dist[i][j] = graph[i][j];
for (k = 0; k < V; k++)
{
for (i = 0; i < V; i++)
{
for (j = 0; j < V; j++)
{
if (dist[i][k] + dist[k][j] < dist[i][j])
dist[i][j] = dist[i][k] + dist[k][j];
}
}
}
cout<<"\nThe All pairs shortest path matrix is as follows:\n";
for (i = 0; i < V; i++)
{
for (j = 0; j < V; j++)
{
cout<< dist[i][j] << " ";
}
cout<<"\n";
}
}
int main() {
int graph[5][5] = { {0, 5, INF, 10},
{INF, 0, 3, INF},
{INF, INF, 0, 1},
{INF, INF, INF, 0}
};
floydWarshall(graph);
return 0;
}
| [
"[email protected]"
] | |
a3a83a4543b6f99e49dbdcb722ab25cc16f5ce9e | 802934efe97183d1c07931c8a24edbd4dbf69d1f | /weixin_DZGZ/src/insertchar.cpp | c87e63ce9bbffd8764022f55c5fe822f28b162ff | [] | no_license | teaspring/problems | 153a3c37866c1f8310819e6e726a09735896a20d | f42230938daeb241f5f0ffddb5ab5de4b431004b | refs/heads/master | 2022-11-29T00:16:27.225454 | 2022-11-18T07:05:23 | 2022-11-18T09:42:52 | 12,702,541 | 5 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 1,432 | cpp | /*
* problem on Oct15,2013
* given a string, how many chars need to insert to transfer it to palindrome in minimum?
* a good dynamic programming
*
* test data:
* bcddefa
* bcdefd
* dcfd
*/
#include "stdio.h"
#include <iostream>
#include <string>
#include <cstring>
using namespace std;
inline int max(int a, int b){
return a>b ? a : b;
}
int turn2palindrome(const string& str){
int s = str.size();
int ** dp = new int*[s];
for(int i=0;i<s;++i){ //dp[i][j] means for str starting at [i] with size j, the length of internal palindrome
dp[i] = new int[s+1]();
}
for(int i=0;i<s;++i){
dp[i][1] = 1; //any char is palindrome naturally
}
for(int j=2;j<=s;++j){
for(int i=0;i+j-1<s;++i){
if(str[i] == str[i+j-1]){
dp[i][j] = 2 + dp[i+1][j-2];
}else{
dp[i][j] = max(dp[i+1][j-1], dp[i][j-1]);
}
}
}
int res = s - dp[0][s];
for(int i =0;i<s;++i){
delete[] dp[i];
dp[i] = 0;
}
delete[] dp;
dp = 0;
return res;
}
int main(int argc, char* argv[]){
string str;
while(1){
if(getline(cin, str)==0 || str.empty())
break;
int res = turn2palindrome(str);
printf("to be palindrome: insert %d chars in minimum\n", res);
}
return 0;
}
| [
"[email protected]"
] | |
44b1dc843bd84bbee0fab18b60b8901fdee92a09 | 23a8a73e6c7774579859b9aca0672b4e6e945ea6 | /plugins/battlelistui/src/BattleListModel.h | b4a288f84501d04eb7b8c116dbb91426fc1b856c | [] | no_license | Kryndex/tibia-hook | 47cb043f7a6c01805157d3edbf34c96cbec9bc94 | 3eb122ea323538263d87d50ec61ec94cc0dd3538 | refs/heads/master | 2021-05-27T06:01:51.632021 | 2012-12-04T21:10:28 | 2012-12-04T21:10:28 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,379 | h | /* Copyright (c) 2012 Gillis Van Ginderachter <[email protected]>
*
* 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.
*/
#ifndef BATTLELISTTABLEMODEL_H
#define BATTLELISTTABLEMODEL_H
#include <QAbstractTableModel>
#include <BattleListPluginInterface.h>
#include <PluginManagerInterface.h>
class BattleListModel: public QAbstractTableModel {
Q_OBJECT
public:
BattleListModel(PluginManagerInterface* plugins, QObject* = 0);
int columnCount(const QModelIndex& parent = QModelIndex()) const;
int rowCount(const QModelIndex& parent = QModelIndex()) const;
QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const;
QModelIndex index(int row, int column, const QModelIndex& parent = QModelIndex()) const;
QModelIndex parent(const QModelIndex& index) const;
private:
BattleListPluginInterface* battleList_;
};
#endif
| [
"[email protected]"
] | |
785b76e9ab202e9a7c464a2a50d942bec32d3c88 | 1f63dde39fcc5f8be29f2acb947c41f1b6f1683e | /Boss2D/addon/webrtc-jumpingyang001_for_boss/modules/audio_coding/codecs/g711/audio_decoder_pcm.cc | 51ce95248e531264f26966d5f1caf360c142133d | [
"MIT",
"BSD-3-Clause",
"LicenseRef-scancode-google-patent-license-webm",
"LicenseRef-scancode-google-patent-license-webrtc",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | koobonil/Boss2D | 09ca948823e0df5a5a53b64a10033c4f3665483a | e5eb355b57228a701495f2660f137bd05628c202 | refs/heads/master | 2022-10-20T09:02:51.341143 | 2019-07-18T02:13:44 | 2019-07-18T02:13:44 | 105,999,368 | 7 | 2 | MIT | 2022-10-04T23:31:12 | 2017-10-06T11:57:07 | C++ | UTF-8 | C++ | false | false | 3,295 | cc | /*
* Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include BOSS_WEBRTC_U_modules__audio_coding__codecs__g711__audio_decoder_pcm_h //original-code:"modules/audio_coding/codecs/g711/audio_decoder_pcm.h"
#include BOSS_WEBRTC_U_modules__audio_coding__codecs__g711__g711_interface_h //original-code:"modules/audio_coding/codecs/g711/g711_interface.h"
#include BOSS_WEBRTC_U_modules__audio_coding__codecs__legacy_encoded_audio_frame_h //original-code:"modules/audio_coding/codecs/legacy_encoded_audio_frame.h"
namespace webrtc {
void AudioDecoderPcmU::Reset() {}
std::vector<AudioDecoder::ParseResult> AudioDecoderPcmU::ParsePayload(
rtc::Buffer&& payload,
uint32_t timestamp) {
return LegacyEncodedAudioFrame::SplitBySamples(
this, std::move(payload), timestamp, 8 * num_channels_, 8);
}
int AudioDecoderPcmU::SampleRateHz() const {
return 8000;
}
size_t AudioDecoderPcmU::Channels() const {
return num_channels_;
}
int AudioDecoderPcmU::DecodeInternal(const uint8_t* encoded,
size_t encoded_len,
int sample_rate_hz,
int16_t* decoded,
SpeechType* speech_type) {
RTC_DCHECK_EQ(SampleRateHz(), sample_rate_hz);
int16_t temp_type = 1; // Default is speech.
size_t ret = WebRtcG711_DecodeU(encoded, encoded_len, decoded, &temp_type);
*speech_type = ConvertSpeechType(temp_type);
return static_cast<int>(ret);
}
int AudioDecoderPcmU::PacketDuration(const uint8_t* encoded,
size_t encoded_len) const {
// One encoded byte per sample per channel.
return static_cast<int>(encoded_len / Channels());
}
void AudioDecoderPcmA::Reset() {}
std::vector<AudioDecoder::ParseResult> AudioDecoderPcmA::ParsePayload(
rtc::Buffer&& payload,
uint32_t timestamp) {
return LegacyEncodedAudioFrame::SplitBySamples(
this, std::move(payload), timestamp, 8 * num_channels_, 8);
}
int AudioDecoderPcmA::SampleRateHz() const {
return 8000;
}
size_t AudioDecoderPcmA::Channels() const {
return num_channels_;
}
int AudioDecoderPcmA::DecodeInternal(const uint8_t* encoded,
size_t encoded_len,
int sample_rate_hz,
int16_t* decoded,
SpeechType* speech_type) {
RTC_DCHECK_EQ(SampleRateHz(), sample_rate_hz);
int16_t temp_type = 1; // Default is speech.
size_t ret = WebRtcG711_DecodeA(encoded, encoded_len, decoded, &temp_type);
*speech_type = ConvertSpeechType(temp_type);
return static_cast<int>(ret);
}
int AudioDecoderPcmA::PacketDuration(const uint8_t* encoded,
size_t encoded_len) const {
// One encoded byte per sample per channel.
return static_cast<int>(encoded_len / Channels());
}
} // namespace webrtc
| [
"[email protected]"
] | |
0c24b448ef6703e89fcbecd21f7b1e064136e198 | c60668cae0fecb8ab0b2ce0cfdbd004813c2d76f | /ServerSocket/Server.cpp | cb86d892bd38dc1153e98918b8cd353dbd154514 | [] | no_license | duonghan/network-programing | 6af12110f3e4ece876feabdccf16b3db8ad43cd3 | e49db75c9779b139568c16233d493ead8669d23a | refs/heads/master | 2021-01-20T10:59:29.807580 | 2017-08-28T16:05:00 | 2017-08-28T16:05:00 | 101,660,509 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 784 | cpp | //#include <iostream>
//#include <stdio.h>
//#include <tchar.h>
//#include <winsock2.h>
//
//#pragma comment (lib,"ws2_32.lib")
//
//
//using namespace std;
//
//int _tmain(int argc, _TCHAR * argv[]) {
// WSADATA SData;
// int iResult = WSAStartup(0x2020, &SData);
//
// if (iResult != 0)
// {
// cout << "Khong the khoi dong WinShock";
// return 1;
// }
//
// cout << "KHOI TAO WINSHOCK THANH CONG: \n";
// cout << "Phien ban: " << SData.wVersion << "\n";
// cout << "Phien ban co the ho tro: " << SData.wHighVersion << "\n";
// cout << "Ghi chu: " << SData.szDescription << "\n";
// cout << "Thong tin cau hinh: " << SData.szSystemStatus << "\n";
//
//
//
// WSACleanup();
// return 0;
//}
//
//int main() {
// cout << "Hello World"<<endl;
//
// system("pause");
// return 0;
//} | [
"[email protected]"
] | |
fa69d4de194c9c4c19e84601581f950a7bbf56e7 | 5e6943ef0183cc59ab8392060472ccc561700c24 | /src/brick/android/jni_generator/sample_for_tests.h | 0d923b73c558c2891c05310302d983aa665f2a22 | [] | no_license | israel-Liu/brick | 88b7ea62c79fc0fc250a60a482d81543c48ec795 | 9b4e4011df7c0bdede945d98bcd1e0a5ac535773 | refs/heads/master | 2022-04-20T10:00:47.049834 | 2020-04-24T03:32:07 | 2020-04-24T03:32:07 | 96,489,912 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,697 | h | // Copyright (c) 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef BRICK_ANDROID_JNI_GENERATOR_SAMPLE_FOR_TESTS_H_
#define BRICK_ANDROID_JNI_GENERATOR_SAMPLE_FOR_TESTS_H_
#include <jni.h>
#include <map>
#include <string>
#include "brick/android/jni_android.h"
namespace base {
namespace android {
// This file is used to:
// - document the best practices and guidelines on JNI usage.
// - ensure sample_for_tests_jni.h compiles and the functions declared in it
// as expected.
//
// Methods are called directly from Java. More documentation in
// SampleForTests.java. See BUILD.gn for the build rules necessary for JNI
// to be used in an APK.
//
// For C++ to access Java methods:
// - GN Build must be configured to generate bindings:
// # Add import at top of file:
// if (is_android) {
// import("//build/config/android/rules.gni") # For generate_jni().
// }
// # ...
// # An example target that will rely on JNI:
// component("foo") {
// # ... normal sources, defines, deps.
// # For each jni generated .java -> .h header file in jni_headers
// # target there will be a single .cc file here that includes it.
// #
// # Add a dep for JNI:
// if (is_android) {
// deps += [ ":foo_jni" ]
// }
// }
// # ...
// # Create target for JNI:
// if (is_android) {
// generate_jni("jni_headers") {
// sources = [
// "java/src/org/chromium/example/jni_generator/SampleForTests.java",
// ]
// jni_package = "foo"
// }
// android_library("java") {
// java_files = [
// "java/src/org/chromium/example/jni_generator/SampleForTests.java",
// "java/src/org/chromium/example/jni_generator/NonJniFile.java",
// ]
// }
// }
// The build rules above are generally that that's needed when adding new
// JNI methods/files. For a full GN example, see
// brick/android/jni_generator/BUILD.gn
//
// For C++ methods to be exposed to Java:
// - The Java class must be part of an android_apk target that depends on
// a generate_jni_registration target. This generate_jni_registration target
// automatically generates all necessary registration functions. The
// generated header file exposes two functions that should be called when a
// library is first loaded:
// 1) RegisterMainDexNatives()
// - Registers all methods that are used outside the browser process
// 2) RegisterNonMainDexNatives()
// - Registers all methods used in the browser process
//
class CPPClass {
public:
CPPClass();
~CPPClass();
// Java @CalledByNative methods implicitly available to C++ via the _jni.h
// file included in the .cc file.
class InnerClass {
public:
jdouble MethodOtherP0(JNIEnv* env,
const base::android::JavaParamRef<jobject>& caller);
};
void Destroy(JNIEnv* env, const base::android::JavaParamRef<jobject>& caller);
jint Method(JNIEnv* env, const base::android::JavaParamRef<jobject>& caller);
void AddStructB(JNIEnv* env,
const base::android::JavaParamRef<jobject>& caller,
const base::android::JavaParamRef<jobject>& structb);
void IterateAndDoSomethingWithStructB(
JNIEnv* env,
const base::android::JavaParamRef<jobject>& caller);
base::android::ScopedJavaLocalRef<jstring> ReturnAString(
JNIEnv* env,
const base::android::JavaParamRef<jobject>& caller);
private:
std::map<long, std::string> map_;
DISALLOW_COPY_AND_ASSIGN(CPPClass);
};
} // namespace android
} // namespace base
#endif // BRICK_ANDROID_JNI_GENERATOR_SAMPLE_FOR_TESTS_H_
| [
"[email protected]"
] | |
5c5616ddb6f7376d244a0fa44ad3aa323c2578b2 | 34b22618cc53750a239ee7d3c98314d8e9b19093 | /framework/deprecated/core/cofiles/include/cofiles/Events/Callback.h | 66102a5c529d70b7d57bd2af4b3839dbaaf25c42 | [] | no_license | ivan-kits/cframework | 7beef16da89fb4f9559c0611863d05ac3de25abd | 30015ddf1e5adccd138a2988455fe8010d1d9f50 | refs/heads/master | 2023-06-12T05:09:30.355989 | 2021-07-04T09:00:00 | 2021-07-04T09:00:00 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,483 | h | #ifndef COFILES_CALLBACK_H
#define COFILES_CALLBACK_H
#include "cofiles/RCObject.h"
#include "cofiles/Utils/SharedPtr.h"
namespace CoFiles
{
//! Base class of simple callbacks
class CallbackBase
{
public:
//! Callback
virtual void DoCallback() = 0;
};
typedef SharedPtr< CallbackBase > CallbackBasePtr;
//! A simple callback
template < class T >
class Callback : public CallbackBase
{
public:
typedef void (T::*CallbackFunction)();
//! Constructor
Callback( T* _pReceiver, CallbackFunction _pCallback )
: m_pReceiver( _pReceiver ),
m_pCallback( _pCallback )
{
}
//! Callback
virtual void DoCallback()
{
(m_pReceiver->*m_pCallback)();
}
private:
//! Callback receiver
T* m_pReceiver;
//! Callback function
CallbackFunction m_pCallback;
};
//! Static simple callback
class StaticCallback : public CallbackBase
{
public:
typedef void (*CallbackFunction)();
//! Constructor
StaticCallback( CallbackFunction _pCallback )
: m_pCallback( _pCallback )
{
}
//! Callback
virtual void DoCallback()
{
(*m_pCallback)();
}
private:
//! Callback function
CallbackFunction m_pCallback;
};
}
#endif
| [
"[email protected]"
] | |
59332c897c0e37b94fe791cbc5978dee6b5e9c50 | 8dc84558f0058d90dfc4955e905dab1b22d12c08 | /chrome/browser/notifications/platform_notification_service_impl.h | 7f6712da8c0c9a94bd8d144922d5d3abaa90d35c | [
"BSD-3-Clause",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | meniossin/src | 42a95cc6c4a9c71d43d62bc4311224ca1fd61e03 | 44f73f7e76119e5ab415d4593ac66485e65d700a | refs/heads/master | 2022-12-16T20:17:03.747113 | 2020-09-03T10:43:12 | 2020-09-03T10:43:12 | 263,710,168 | 1 | 0 | BSD-3-Clause | 2020-05-13T18:20:09 | 2020-05-13T18:20:08 | null | UTF-8 | C++ | false | false | 6,429 | h | // Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_BROWSER_NOTIFICATIONS_PLATFORM_NOTIFICATION_SERVICE_IMPL_H_
#define CHROME_BROWSER_NOTIFICATIONS_PLATFORM_NOTIFICATION_SERVICE_IMPL_H_
#include <stdint.h>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <unordered_set>
#include "base/callback_forward.h"
#include "base/gtest_prod_util.h"
#include "base/macros.h"
#include "base/memory/singleton.h"
#include "base/optional.h"
#include "base/strings/string16.h"
#include "chrome/browser/notifications/notification_common.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/common/buildflags.h"
#include "content/public/browser/platform_notification_service.h"
#include "content/public/common/persistent_notification_status.h"
#include "third_party/blink/public/platform/modules/permissions/permission_status.mojom.h"
#include "ui/message_center/public/cpp/notification.h"
class NotificationDelegate;
class ScopedKeepAlive;
namespace content {
class BrowserContext;
struct NotificationResources;
}
namespace gcm {
class PushMessagingBrowserTest;
}
// The platform notification service is the profile-agnostic entry point through
// which Web Notifications can be controlled.
class PlatformNotificationServiceImpl
: public content::PlatformNotificationService {
public:
// Returns the active instance of the service in the browser process. Safe to
// be called from any thread.
static PlatformNotificationServiceImpl* GetInstance();
// To be called when a persistent notification has been clicked on. The
// Service Worker associated with the registration will be started if
// needed, on which the event will be fired. Must be called on the UI thread.
void OnPersistentNotificationClick(
content::BrowserContext* browser_context,
const std::string& notification_id,
const GURL& origin,
const base::Optional<int>& action_index,
const base::Optional<base::string16>& reply,
base::OnceClosure completed_closure);
// To be called when a persistent notification has been closed. The data
// associated with the notification has to be pruned from the database in this
// case, to make sure that it continues to be in sync. Must be called on the
// UI thread.
void OnPersistentNotificationClose(content::BrowserContext* browser_context,
const std::string& notification_id,
const GURL& origin,
bool by_user,
base::OnceClosure completed_closure);
// content::PlatformNotificationService implementation.
void DisplayNotification(
content::BrowserContext* browser_context,
const std::string& notification_id,
const GURL& origin,
const content::PlatformNotificationData& notification_data,
const content::NotificationResources& notification_resources) override;
void DisplayPersistentNotification(
content::BrowserContext* browser_context,
const std::string& notification_id,
const GURL& service_worker_scope,
const GURL& origin,
const content::PlatformNotificationData& notification_data,
const content::NotificationResources& notification_resources) override;
void CloseNotification(content::BrowserContext* browser_context,
const std::string& notification_id) override;
void ClosePersistentNotification(content::BrowserContext* browser_context,
const std::string& notification_id) override;
void GetDisplayedNotifications(
content::BrowserContext* browser_context,
const DisplayedNotificationsCallback& callback) override;
private:
friend struct base::DefaultSingletonTraits<PlatformNotificationServiceImpl>;
friend class PlatformNotificationServiceBrowserTest;
friend class PlatformNotificationServiceTest;
friend class PushMessagingBrowserTest;
FRIEND_TEST_ALL_PREFIXES(PlatformNotificationServiceTest,
CreateNotificationFromData);
FRIEND_TEST_ALL_PREFIXES(PlatformNotificationServiceTest,
DisplayNameForContextMessage);
PlatformNotificationServiceImpl();
~PlatformNotificationServiceImpl() override;
void OnClickEventDispatchComplete(
base::OnceClosure completed_closure,
content::PersistentNotificationStatus status);
void OnCloseEventDispatchComplete(
base::OnceClosure completed_closure,
content::PersistentNotificationStatus status);
// Creates a new Web Notification-based Notification object. Should only be
// called when the notification is first shown.
// TODO(peter): |delegate| can be a scoped_refptr, but properly passing this
// through requires changing a whole lot of Notification constructor calls.
message_center::Notification CreateNotificationFromData(
Profile* profile,
const GURL& origin,
const std::string& notification_id,
const content::PlatformNotificationData& notification_data,
const content::NotificationResources& notification_resources,
scoped_refptr<message_center::NotificationDelegate> delegate) const;
// Returns a display name for an origin, to be used in the context message
base::string16 DisplayNameForContextMessage(Profile* profile,
const GURL& origin) const;
void RecordSiteEngagement(content::BrowserContext* browser_context,
const GURL& origin);
#if BUILDFLAG(ENABLE_BACKGROUND_MODE)
// Makes sure we keep the browser alive while the event in being processed.
// As we have no control on the click handling, the notification could be
// closed before a browser is brought up, thus terminating Chrome if it was
// the last KeepAlive. (see https://crbug.com/612815)
std::unique_ptr<ScopedKeepAlive> click_dispatch_keep_alive_;
int pending_click_dispatch_events_;
#endif
// Tracks the id of persistent notifications that have been closed
// programmatically to avoid dispatching close events for them.
std::unordered_set<std::string> closed_notifications_;
DISALLOW_COPY_AND_ASSIGN(PlatformNotificationServiceImpl);
};
#endif // CHROME_BROWSER_NOTIFICATIONS_PLATFORM_NOTIFICATION_SERVICE_IMPL_H_
| [
"[email protected]"
] | |
ad1b115247eadd8c366b1c0b17ded5987dc02b0a | db7c5838538bb3ef9c84fe9f77cf361e2cb9c832 | /select_number_and_sum/main.cpp | af073089ba0f290c9be5a4349c400ba0be84e39d | [] | no_license | halida/learn_acm | 025cde07b58abc8bdfd92a27acbddfd0589b8d5e | 7ca10666283ca0359751b1a833d1a392bb523b09 | refs/heads/master | 2016-09-06T14:50:06.277702 | 2014-08-17T01:36:11 | 2014-08-17T01:36:11 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,701 | cpp | //-*-coding:utf-8-*-
//----------------------------------------------------------
// module: main
//----------------------------------------------------------
#include <assert.h>
#include <algorithm>
#include <iostream>
#include <stdio.h>
using namespace std;
bool solve(int a[], unsigned int size, int m){
for (int i = 0; i < size; ++i)
{
for (int j = i+1; j < size; ++j)
{
for (int k = j+1; k < size; ++k)
{
for (int l = k+1; l < size; ++l)
{
if (a[i] + a[j] + a[k] + a[l] == m) {
printf("%d + %d + %d + %d = %d\n", a[i], a[j], a[k], a[l], m);
return true;
}
}
}
}
}
return false;
}
int binary_search(int a[], unsigned int size, int m){
int l=0, r=size-1;
while ( l <= r){
int mid = (l + r) / 2;
if (mid < 0 ) mid = 0;
// printf("%d, %d, %d = %d %d\n", l, r, mid, m, a[mid]);
if (a[mid] == m) return mid;
if (a[mid] > m)
{
r = mid-1;
}
else
{
l = mid+1;
};
}
return -1;
}
bool fastsolve(int a[], unsigned int size, int m){
// 2 level array init
int a2[size * (size-1)];
int pa2 = 0;
for (int i = 0; i < size; ++i)
{
for (int j = i+1; j < size; ++j)
{
a2[pa2] = a[i] + a[j];
pa2 ++;
// printf("%d=%d\n", i*size + j, a2[i*size + j]);
}
}
// sort
// for (int i = 0; i < pa2; ++i) {
// printf("%d\n", a2[i]);
// }
std::sort(a2, a2 + pa2);
// query
for (int i = 0; i < size; ++i)
{
for (int j = i+1; j < size; ++j)
{
int v = binary_search(a2, pa2, (m - a[i] - a[j]));
// printf("search for %d = %d\n", m - a[i] - a[j], v);
if (v >= 0) {
// int k = a2[v % size];
// int l = a2[v / size];
// printf("%d + %d + %d + %d = %d\n", a[i], a[j], a[k], a[l], m);
return true;
}
}
}
return false;
}
int main(int argc, char *argv[])
{
int a1[] = {1, 2, 3, 4, 4, 5, 6};
assert(fastsolve(a1, 7, 15) == true);
assert(solve(a1, 7, 150) == false);
return 0;
}
| [
"[email protected]"
] | |
506d5c0e4b567265c69415305bad9e6e889bd011 | 755c650f9048a928f600663047a2a4f384bafc63 | /SOFT/simulation/project1/controllers/test_my_driver/test_my_driver.cpp | 6fcd72affc26f366fa919fe5e739561d1b6565db | [] | no_license | todocono/swarmesh | 5481192cc7e13b19fcc27ab86ca75314fa0c4851 | 9631728b3b6dc52c3e4f576c3c748ecbc2c53168 | refs/heads/master | 2021-07-06T14:57:53.921185 | 2020-11-27T02:12:11 | 2020-11-27T02:12:11 | 211,023,357 | 6 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 2,952 | cpp | #include <webots/Emitter.hpp>
#include <webots/Field.hpp>
#include <webots/Keyboard.hpp>
#include <webots/Node.hpp>
#include <webots/Supervisor.hpp>
#include <stdlib.h>
#include <cstring>
#include <iostream>
#include <string>
using namespace std;
using namespace webots;
class Driver : public Supervisor {
public:
Driver();
void run();
private:
static void displayHelp();
int timeStep;
Emitter *emitter;
Field *translationField;
Keyboard *keyboard;
double x;
double z;
double translation[3];
};
Driver::Driver() {
timeStep = 128;
x = -0.25f;
z = -0.25f;
translation[0] = x;
translation[2] = z;
emitter = getEmitter("emitter");
Node *robot = getFromDef("ROBOT1");
if (!robot){
// robot might be NULL if the controller is about to quit
exit(1);
}
translationField = robot->getField("translation");
keyboard = getKeyboard();
keyboard->enable(timeStep);
}
void Driver::run() {
string previous_message("");
string message("");
displayHelp();
float orderX = -0.25;
float orderZ = -0.25;
// cout << emitter->getChannel() << endl;
// main loop
while (step(timeStep) != -1) {
// Read sensors; update message according to the pressed keyboard key
int k = keyboard->getKey();
switch (k) {
case 'A':
message.assign("avoid obstacles");
break;
case 'F':
message.assign("move forward");
break;
case 'S':
message.assign("stop");
break;
case 'T':
message.assign("turn");
break;
case 'I':
displayHelp();
break;
case 'G': {
const double *translationValues = translationField->getSFVec3f();
cout << "ROBOT1 is located at (" << translationValues[0] << "," << translationValues[2] << ")" << endl;
break;
}
case 'R':
cout << "Teleport ROBOT1 at (" << x << "," << z << ")" << endl;
translationField->setSFVec3f(translation);
break;
case 'O':
cout << "Robot1 go to (" << orderX << "," << orderZ << ")" << endl;
message.assign("order");
break;
default:
message.clear();
}
// send actuators commands; send a new message through the emitter device
if (!message.empty() && message.compare(previous_message)) {
previous_message.assign(message);
cout << "Please, " << message.c_str() << endl;
emitter->send(message.c_str(), (int)strlen(message.c_str()) + 1);
}
}
}
void Driver::displayHelp() {
string s("Commands:\n"
" I for displaying the commands\n"
" A for avoid obstacles\n"
" F for move forward\n"
" S for stop\n"
" T for turn\n"
" R for positioning ROBOT1 at (0.1,0.3)\n"
" G for knowing the (x,z) position of ROBOT1");
cout << s << endl;
}
int main() {
Driver *controller = new Driver();
controller->run();
delete controller;
return 0;
}
| [
"[email protected]"
] | |
c70d9c084398d1981f86e29da410663514e4217f | 86a9729c1f14d6abe11607bccf3a46e48ce0cfad | /src/qt/rpcconsole.cpp | e528355e86cdfa902369b6bb691152aa7e8cdc7b | [
"MIT"
] | permissive | Ricky-Petrovich/GorillaBucks | 9b166f371ce7562581800e2b48290c0c9df99a72 | bc608c0abf38072adbb332ea2a75b2925e832cc1 | refs/heads/master | 2020-12-07T05:12:41.224831 | 2015-05-28T07:22:28 | 2015-05-28T07:22:28 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 13,901 | cpp | #include "rpcconsole.h"
#include "ui_rpcconsole.h"
#include "clientmodel.h"
#include "bitcoinrpc.h"
#include "guiutil.h"
#include <QTime>
#include <QTimer>
#include <QThread>
#include <QTextEdit>
#include <QKeyEvent>
#include <QUrl>
#include <QScrollBar>
// TODO: add a scrollback limit, as there is currently none
// TODO: make it possible to filter out categories (esp debug messages when implemented)
// TODO: receive errors and debug messages through ClientModel
const int CONSOLE_HISTORY = 50;
const QSize ICON_SIZE(24, 24);
const struct {
const char *url;
const char *source;
} ICON_MAPPING[] = {
{"cmd-request", ":/icons/tx_input"},
{"cmd-reply", ":/icons/tx_output"},
{"cmd-error", ":/icons/tx_output"},
{"misc", ":/icons/tx_inout"},
{NULL, NULL}
};
/* Object for executing console RPC commands in a separate thread.
*/
class RPCExecutor: public QObject
{
Q_OBJECT
public slots:
void start();
void request(const QString &command);
signals:
void reply(int category, const QString &command);
};
#include "rpcconsole.moc"
void RPCExecutor::start()
{
// Nothing to do
}
/**
* Split shell command line into a list of arguments. Aims to emulate \c bash and friends.
*
* - Arguments are delimited with whitespace
* - Extra whitespace at the beginning and end and between arguments will be ignored
* - Text can be "double" or 'single' quoted
* - The backslash \c \ is used as escape character
* - Outside quotes, any character can be escaped
* - Within double quotes, only escape \c " and backslashes before a \c " or another backslash
* - Within single quotes, no escaping is possible and no special interpretation takes place
*
* @param[out] args Parsed arguments will be appended to this list
* @param[in] strCommand Command line to split
*/
bool parseCommandLine(std::vector<std::string> &args, const std::string &strCommand)
{
enum CmdParseState
{
STATE_EATING_SPACES,
STATE_ARGUMENT,
STATE_SINGLEQUOTED,
STATE_DOUBLEQUOTED,
STATE_ESCAPE_OUTER,
STATE_ESCAPE_DOUBLEQUOTED
} state = STATE_EATING_SPACES;
std::string curarg;
foreach(char ch, strCommand)
{
switch(state)
{
case STATE_ARGUMENT: // In or after argument
case STATE_EATING_SPACES: // Handle runs of whitespace
switch(ch)
{
case '"': state = STATE_DOUBLEQUOTED; break;
case '\'': state = STATE_SINGLEQUOTED; break;
case '\\': state = STATE_ESCAPE_OUTER; break;
case ' ': case '\n': case '\t':
if(state == STATE_ARGUMENT) // Space ends argument
{
args.push_back(curarg);
curarg.clear();
}
state = STATE_EATING_SPACES;
break;
default: curarg += ch; state = STATE_ARGUMENT;
}
break;
case STATE_SINGLEQUOTED: // Single-quoted string
switch(ch)
{
case '\'': state = STATE_ARGUMENT; break;
default: curarg += ch;
}
break;
case STATE_DOUBLEQUOTED: // Double-quoted string
switch(ch)
{
case '"': state = STATE_ARGUMENT; break;
case '\\': state = STATE_ESCAPE_DOUBLEQUOTED; break;
default: curarg += ch;
}
break;
case STATE_ESCAPE_OUTER: // '\' outside quotes
curarg += ch; state = STATE_ARGUMENT;
break;
case STATE_ESCAPE_DOUBLEQUOTED: // '\' in double-quoted text
if(ch != '"' && ch != '\\') curarg += '\\'; // keep '\' for everything but the quote and '\' itself
curarg += ch; state = STATE_DOUBLEQUOTED;
break;
}
}
switch(state) // final state
{
case STATE_EATING_SPACES:
return true;
case STATE_ARGUMENT:
args.push_back(curarg);
return true;
default: // ERROR to end in one of the other states
return false;
}
}
void RPCExecutor::request(const QString &command)
{
std::vector<std::string> args;
if(!parseCommandLine(args, command.toStdString()))
{
emit reply(RPCConsole::CMD_ERROR, QString("Parse error: unbalanced ' or \""));
return;
}
if(args.empty())
return; // Nothing to do
try
{
std::string strPrint;
// Convert argument list to JSON objects in method-dependent way,
// and pass it along with the method name to the dispatcher.
json_spirit::Value result = tableRPC.execute(
args[0],
RPCConvertValues(args[0], std::vector<std::string>(args.begin() + 1, args.end())));
// Format result reply
if (result.type() == json_spirit::null_type)
strPrint = "";
else if (result.type() == json_spirit::str_type)
strPrint = result.get_str();
else
strPrint = write_string(result, true);
emit reply(RPCConsole::CMD_REPLY, QString::fromStdString(strPrint));
}
catch (json_spirit::Object& objError)
{
try // Nice formatting for standard-format error
{
int code = find_value(objError, "code").get_int();
std::string message = find_value(objError, "message").get_str();
emit reply(RPCConsole::CMD_ERROR, QString::fromStdString(message) + " (code " + QString::number(code) + ")");
}
catch(std::runtime_error &) // raised when converting to invalid type, i.e. missing code or message
{
// Show raw JSON object
emit reply(RPCConsole::CMD_ERROR, QString::fromStdString(write_string(json_spirit::Value(objError), false)));
}
}
catch (std::exception& e)
{
emit reply(RPCConsole::CMD_ERROR, QString("Error: ") + QString::fromStdString(e.what()));
}
}
RPCConsole::RPCConsole(QWidget *parent) :
QDialog(parent),
ui(new Ui::RPCConsole),
historyPtr(0)
{
ui->setupUi(this);
// Install event filter for up and down arrow
ui->lineEdit->installEventFilter(this);
ui->messagesWidget->installEventFilter(this);
connect(ui->clearButton, SIGNAL(clicked()), this, SLOT(clear()));
startExecutor();
clear();
}
RPCConsole::~RPCConsole()
{
emit stopExecutor();
delete ui;
}
bool RPCConsole::eventFilter(QObject* obj, QEvent *event)
{
if(event->type() == QEvent::KeyPress) // Special key handling
{
QKeyEvent *keyevt = static_cast<QKeyEvent*>(event);
int key = keyevt->key();
Qt::KeyboardModifiers mod = keyevt->modifiers();
switch(key)
{
case Qt::Key_Up: if(obj == ui->lineEdit) { browseHistory(-1); return true; } break;
case Qt::Key_Down: if(obj == ui->lineEdit) { browseHistory(1); return true; } break;
case Qt::Key_PageUp: /* pass paging keys to messages widget */
case Qt::Key_PageDown:
if(obj == ui->lineEdit)
{
QApplication::postEvent(ui->messagesWidget, new QKeyEvent(*keyevt));
return true;
}
break;
default:
// Typing in messages widget brings focus to line edit, and redirects key there
// Exclude most combinations and keys that emit no text, except paste shortcuts
if(obj == ui->messagesWidget && (
(!mod && !keyevt->text().isEmpty() && key != Qt::Key_Tab) ||
((mod & Qt::ControlModifier) && key == Qt::Key_V) ||
((mod & Qt::ShiftModifier) && key == Qt::Key_Insert)))
{
ui->lineEdit->setFocus();
QApplication::postEvent(ui->lineEdit, new QKeyEvent(*keyevt));
return true;
}
}
}
return QDialog::eventFilter(obj, event);
}
void RPCConsole::setClientModel(ClientModel *model)
{
this->clientModel = model;
if(model)
{
// Subscribe to information, replies, messages, errors
connect(model, SIGNAL(numConnectionsChanged(int)), this, SLOT(setNumConnections(int)));
connect(model, SIGNAL(numBlocksChanged(int)), this, SLOT(setNumBlocks(int)));
// Provide initial values
ui->clientVersion->setText(model->formatFullVersion());
ui->clientName->setText(model->clientName());
ui->buildDate->setText(model->formatBuildDate());
setNumConnections(model->getNumConnections());
ui->isTestNet->setChecked(model->isTestNet());
setNumBlocks(model->getNumBlocks());
}
}
static QString categoryClass(int category)
{
switch(category)
{
case RPCConsole::CMD_REQUEST: return "cmd-request"; break;
case RPCConsole::CMD_REPLY: return "cmd-reply"; break;
case RPCConsole::CMD_ERROR: return "cmd-error"; break;
default: return "misc";
}
}
void RPCConsole::clear()
{
ui->messagesWidget->clear();
history.clear();
historyPtr = 0;
ui->lineEdit->clear();
ui->lineEdit->setFocus();
// Add smoothly scaled icon images.
// (when using width/height on an img, Qt uses nearest instead of linear interpolation)
for(int i=0; ICON_MAPPING[i].url; ++i)
{
ui->messagesWidget->document()->addResource(
QTextDocument::ImageResource,
QUrl(ICON_MAPPING[i].url),
QImage(ICON_MAPPING[i].source).scaled(ICON_SIZE, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
}
// Set default style sheet
ui->messagesWidget->document()->setDefaultStyleSheet(
"table { }"
"td.time { color: #808080; padding-top: 3px; } "
"td.message { font-family: Monospace; font-size: 12px; } "
"td.cmd-request { color: #006060; } "
"td.cmd-error { color: red; } "
"b { color: #006060; } "
);
message(CMD_REPLY, tr("Welcome to the GorillaBucks RPC console.<br>"
"Use up and down arrows to navigate history, and <b>Ctrl-L</b> to clear screen.<br>"
"Type <b>help</b> for an overview of available commands."), true);
}
void RPCConsole::message(int category, const QString &message, bool html)
{
QTime time = QTime::currentTime();
QString timeString = time.toString();
QString out;
out += "<table><tr><td class=\"time\" width=\"65\">" + timeString + "</td>";
out += "<td class=\"icon\" width=\"32\"><img src=\"" + categoryClass(category) + "\"></td>";
out += "<td class=\"message " + categoryClass(category) + "\" valign=\"middle\">";
if(html)
out += message;
else
out += GUIUtil::HtmlEscape(message, true);
out += "</td></tr></table>";
ui->messagesWidget->append(out);
}
void RPCConsole::setNumConnections(int count)
{
ui->numberOfConnections->setText(QString::number(count));
}
void RPCConsole::setNumBlocks(int count)
{
ui->numberOfBlocks->setText(QString::number(count));
if(clientModel)
{
// If there is no current number available display N/A instead of 0, which can't ever be true
ui->totalBlocks->setText(clientModel->getNumBlocksOfPeers() == 0 ? tr("N/A") : QString::number(clientModel->getNumBlocksOfPeers()));
ui->lastBlockTime->setText(clientModel->getLastBlockDate().toString());
}
}
void RPCConsole::on_lineEdit_returnPressed()
{
QString cmd = ui->lineEdit->text();
ui->lineEdit->clear();
if(!cmd.isEmpty())
{
message(CMD_REQUEST, cmd);
emit cmdRequest(cmd);
// Truncate history from current position
history.erase(history.begin() + historyPtr, history.end());
// Append command to history
history.append(cmd);
// Enforce maximum history size
while(history.size() > CONSOLE_HISTORY)
history.removeFirst();
// Set pointer to end of history
historyPtr = history.size();
// Scroll console view to end
scrollToEnd();
}
}
void RPCConsole::browseHistory(int offset)
{
historyPtr += offset;
if(historyPtr < 0)
historyPtr = 0;
if(historyPtr > history.size())
historyPtr = history.size();
QString cmd;
if(historyPtr < history.size())
cmd = history.at(historyPtr);
ui->lineEdit->setText(cmd);
}
void RPCConsole::startExecutor()
{
QThread* thread = new QThread;
RPCExecutor *executor = new RPCExecutor();
executor->moveToThread(thread);
// Notify executor when thread started (in executor thread)
connect(thread, SIGNAL(started()), executor, SLOT(start()));
// Replies from executor object must go to this object
connect(executor, SIGNAL(reply(int,QString)), this, SLOT(message(int,QString)));
// Requests from this object must go to executor
connect(this, SIGNAL(cmdRequest(QString)), executor, SLOT(request(QString)));
// On stopExecutor signal
// - queue executor for deletion (in execution thread)
// - quit the Qt event loop in the execution thread
connect(this, SIGNAL(stopExecutor()), executor, SLOT(deleteLater()));
connect(this, SIGNAL(stopExecutor()), thread, SLOT(quit()));
// Queue the thread for deletion (in this thread) when it is finished
connect(thread, SIGNAL(finished()), thread, SLOT(deleteLater()));
// Default implementation of QThread::run() simply spins up an event loop in the thread,
// which is what we want.
thread->start();
}
void RPCConsole::on_tabWidget_currentChanged(int index)
{
if(ui->tabWidget->widget(index) == ui->tab_console)
{
ui->lineEdit->setFocus();
}
}
void RPCConsole::scrollToEnd()
{
QScrollBar *scrollbar = ui->messagesWidget->verticalScrollBar();
scrollbar->setValue(scrollbar->maximum());
}
| [
"[email protected]"
] | |
6ded060922da2a0b33d3c26fe14f99c70d2d5cb4 | a358da2dfe6f585239678e6318d61109b6b4af91 | /sylar/sylar/streams/socket_stream.cc | a1ea4f01fd8dccd1ef22da0176372711d333da98 | [] | no_license | ztreble/BuddhaServer | 52d5f5ca20145ffd01715e59526273b48d236953 | 71f09124b212d7c22ab75bcb75b25e962155c90f | refs/heads/master | 2023-03-18T00:00:58.813696 | 2021-03-14T04:35:54 | 2021-03-14T04:35:54 | 326,431,137 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,091 | cc | #include "socket_stream.h"
#include "sylar/util.h"
namespace sylar {
SocketStream::SocketStream(Socket::ptr sock, bool owner)
:m_socket(sock)
,m_owner(owner) {
}
SocketStream::~SocketStream() {
if(m_owner && m_socket) {
m_socket->close();
}
}
bool SocketStream::isConnected() const {
return m_socket && m_socket->isConnected();
}
int SocketStream::read(void* buffer, size_t length) {
if(!isConnected()) {
return -1;
}
return m_socket->recv(buffer, length);
}
int SocketStream::read(ByteArray::ptr ba, size_t length) {
if(!isConnected()) {
return -1;
}
std::vector<iovec> iovs;
ba->getWriteBuffers(iovs, length);
int rt = m_socket->recv(&iovs[0], iovs.size());
if(rt > 0) {
ba->setPosition(ba->getPosition() + rt);
}
return rt;
}
int SocketStream::write(const void* buffer, size_t length) {
if(!isConnected()) {
return -1;
}
return m_socket->send(buffer, length);
}
int SocketStream::write(ByteArray::ptr ba, size_t length) {
if(!isConnected()) {
return -1;
}
std::vector<iovec> iovs;
ba->getReadBuffers(iovs, length);
int rt = m_socket->send(&iovs[0], iovs.size());
if(rt > 0) {
ba->setPosition(ba->getPosition() + rt);
}
return rt;
}
void SocketStream::close() {
if(m_socket) {
m_socket->close();
}
}
Address::ptr SocketStream::getRemoteAddress() {
if(m_socket) {
return m_socket->getRemoteAddress();
}
return nullptr;
}
Address::ptr SocketStream::getLocalAddress() {
if(m_socket) {
return m_socket->getLocalAddress();
}
return nullptr;
}
std::string SocketStream::getRemoteAddressString() {
auto addr = getRemoteAddress();
if(addr) {
return addr->toString();
}
return "";
}
std::string SocketStream::getLocalAddressString() {
auto addr = getLocalAddress();
if(addr) {
return addr->toString();
}
return "";
}
}
| [
"[email protected]"
] | |
63f032980a6d846e1ef36e22647361aa7450dca5 | 9621b172b8d01dd9d275537293b3d1e9a19ef4ce | /src/demos/robot/robosimian/sequential/demo_ROBOT_RoboSimian_SCM.cpp | f4f5bd10a68e84636a5175589e009552b3919bd9 | [
"BSD-3-Clause"
] | permissive | jmange/chrono | c72173d06824405c958be0914e41db70540b84e8 | f25c40d0eccfe30b5a6cdec3148e26d5c393015b | refs/heads/main | 2023-07-09T20:03:16.294624 | 2023-07-05T18:13:27 | 2023-07-05T18:13:27 | 629,678,854 | 0 | 0 | null | 2023-04-18T20:03:19 | 2023-04-18T20:03:18 | null | UTF-8 | C++ | false | false | 22,534 | cpp | // =============================================================================
// PROJECT CHRONO - http://projectchrono.org
//
// Copyright (c) 2018 projectchrono.org
// All rights reserved.
//
// Use of this source code is governed by a BSD-style license that can be found
// in the LICENSE file at the top level of the distribution and at
// http://projectchrono.org/license-chrono.txt.
//
// =============================================================================
// Authors: Radu Serban
// =============================================================================
//
// RoboSimian on rigid terrain
//
// =============================================================================
#include <cmath>
#include <cstdio>
#include <vector>
#include "chrono/physics/ChSystemSMC.h"
#include "chrono/utils/ChUtilsInputOutput.h"
#include "chrono_models/robot/robosimian/RoboSimian.h"
#include "chrono_models/robot/robosimian/RoboSimianVisualSystemIrrlicht.h"
#include "chrono_vehicle/terrain/SCMTerrain.h"
#include "chrono_thirdparty/filesystem/path.h"
#include "chrono_thirdparty/cxxopts/ChCLI.h"
#include "chrono_thirdparty/filesystem/path.h"
using namespace chrono;
using namespace chrono::collision;
using std::cout;
using std::endl;
// Drop the robot on SCM terrain
bool drop = true;
// Phase durations
double duration_pose = 1.0; // Interval to assume initial pose
double duration_settle_robot = 0.5; // Interval to allow robot settling on terrain
double duration_sim = 10; // Duration of actual locomotion simulation
// Output frequencies
double output_fps = 100;
double render_fps = 60;
// Output directories
const std::string out_dir = GetChronoOutputPath() + "ROBOSIMIAN_SCM";
const std::string pov_dir = out_dir + "/POVRAY";
const std::string img_dir = out_dir + "/IMG";
// =============================================================================
bool GetProblemSpecs(int argc,
char** argv,
double& time_step,
robosimian::LocomotionMode& mode,
int& num_cycles,
double& dbp_incr,
double& terrain_length,
bool& render,
bool& data_output,
bool& image_output,
bool& povray_output);
// =============================================================================
class DBPcontroller : public robosimian::RS_Driver::PhaseChangeCallback {
public:
DBPcontroller(robosimian::RoboSimian* robot);
~DBPcontroller() { delete m_csv; }
virtual void OnPhaseChange(robosimian::RS_Driver::Phase old_phase, robosimian::RS_Driver::Phase new_phase) override;
void SetCycleFreq(int freq) { m_cycle_freq = freq; }
void SetIncrement(double incr) { m_dbp_incr = incr; }
bool Stop() const { return m_avg_speed < 0; }
void WriteOutput(const std::string& filename) { m_csv->write_to_file(filename); }
double GetDistance() const { return m_robot->GetChassisPos().x() - m_start_x; }
double GetDuration() const { return m_robot->GetSystem()->GetChTime() - m_start_time; }
double GetAvgSpeed() const { return GetDistance() / GetDuration(); }
private:
robosimian::RoboSimian* m_robot;
std::shared_ptr<ChLoadBodyForce> m_load;
double m_weight; // total robot weight
double m_dbp; // DBP factor (ratio of robot weight)
double m_dbp_incr; // DBP factor increment
int m_cycle_number; // current cycle
int m_cycle_freq; // number of cycles between DBP increases
double m_start_x; // cached robot location
double m_start_time; // cached time at last location
double m_avg_speed; // average speed over last segment
utils::CSV_writer* m_csv;
ChTimer m_timer;
};
DBPcontroller::DBPcontroller(robosimian::RoboSimian* robot)
: m_robot(robot),
m_dbp(0),
m_dbp_incr(0.04),
m_cycle_number(0),
m_cycle_freq(2),
m_start_x(0),
m_start_time(0),
m_avg_speed(0) {
// Cache robot weight
double mass = robot->GetMass();
double g = std::abs(robot->GetSystem()->Get_G_acc().z());
m_weight = mass * g;
// Create a body force load on the robot chassis.
// This is a horizontal force applied at the chassis center.
auto force_container = chrono_types::make_shared<ChLoadContainer>();
robot->GetSystem()->Add(force_container);
m_load = chrono_types::make_shared<ChLoadBodyForce>(robot->GetChassisBody(), VNULL, false, VNULL, true);
force_container->Add(m_load);
m_timer.reset();
m_timer.start();
// Prepare CSV output
m_csv = new utils::CSV_writer(",");
*m_csv << "DBP_factor"
<< "DBP_force"
<< "Avg_speed" << endl;
}
void DBPcontroller::OnPhaseChange(robosimian::RS_Driver::Phase old_phase, robosimian::RS_Driver::Phase new_phase) {
m_timer.stop();
cout << "Elapsed time: " << m_timer() << endl;
m_timer.reset();
m_timer.start();
if (new_phase == robosimian::RS_Driver::CYCLE) {
if (m_cycle_number == 0) {
m_start_x = m_robot->GetChassisPos().x();
m_start_time = m_robot->GetSystem()->GetChTime();
} else if (m_cycle_number % m_cycle_freq == 0) {
// Save average speed at current DBP factor
m_avg_speed = GetAvgSpeed();
cout << "*** DBP: " << m_dbp << " force: " << m_dbp * m_weight << " avg. speed: " << m_avg_speed << endl;
*m_csv << m_dbp << m_dbp * m_weight << m_avg_speed << endl;
// Cache new start time and location
m_start_x = m_robot->GetChassisPos().x();
m_start_time = m_robot->GetSystem()->GetChTime();
// Increment DBP force
m_dbp += m_dbp_incr;
m_load->SetForce(ChVector<>(-m_dbp * m_weight, 0, 0), false);
}
cout << " FL wheel location: " << m_robot->GetWheelPos(robosimian::LimbID::FL).x() << endl;
cout << " FR wheel location: " << m_robot->GetWheelPos(robosimian::LimbID::FR).x() << endl;
cout << " Chassis location: " << m_robot->GetChassisPos().x() << endl;
cout << " Distance travelled: " << GetDistance() << endl;
m_cycle_number++;
}
}
// =============================================================================
std::shared_ptr<vehicle::SCMTerrain> CreateTerrain(robosimian::RoboSimian* robot,
double length,
double width,
double height,
double offset) {
// Deformable terrain properties (LETE sand)
////double Kphi = 5301e3; // Bekker Kphi
////double Kc = 102e3; // Bekker Kc
////double n = 0.793; // Bekker n exponent
////double coh = 1.3e3; // Mohr cohesive limit (Pa)
////double phi = 31.1; // Mohr friction limit (degrees)
////double K = 1.2e-2; // Janosi shear coefficient (m)
////double E_elastic = 2e8; // Elastic stiffness (Pa/m), before plastic yeld
////double damping = 3e4; // Damping coefficient (Pa*s/m)
// Deformable terrain properties (CDT FGS dry - 6/29/2018)
double Kphi = 6259.1e3; // Bekker Kphi
double Kc = 5085.6e3; // Bekker Kc
double n = 1.42; // Bekker n exponent
double coh = 1.58e3; // Mohr cohesive limit (Pa)
double phi = 34.1; // Mohr friction limit (degrees)
double K = 22.17e-3; // Janosi shear coefficient (m)
double E_elastic = 2e8; // Elastic stiffness (Pa/m), before plastic yeld
double damping = 3e4; // Damping coefficient (Pa*s/m)
auto terrain = chrono_types::make_shared<vehicle::SCMTerrain>(robot->GetSystem());
terrain->SetPlane(ChCoordsys<>(ChVector<>(length / 2 - offset, 0, height), QUNIT));
terrain->SetSoilParameters(Kphi, Kc, n, coh, phi, K, E_elastic, damping);
terrain->SetPlotType(vehicle::SCMTerrain::PLOT_SINKAGE, 0, 0.15);
terrain->Initialize(length, width, 1.0 / 64);
// Enable moving patch feature
terrain->AddMovingPatch(robot->GetChassisBody(), ChVector<>(0, 0, 0), ChVector<>(3.0, 2.0, 1.0));
return terrain;
}
void SetContactProperties(robosimian::RoboSimian* robot) {
assert(robot->GetSystem()->GetContactMethod() == ChContactMethod::SMC);
float friction = 0.4f;
float Y = 1e7f;
float cr = 0.0f;
robot->GetSledContactMaterial()->SetFriction(friction);
robot->GetSledContactMaterial()->SetRestitution(cr);
robot->GetWheelContactMaterial()->SetFriction(friction);
robot->GetWheelContactMaterial()->SetRestitution(cr);
std::static_pointer_cast<ChMaterialSurfaceSMC>(robot->GetSledContactMaterial())->SetYoungModulus(Y);
std::static_pointer_cast<ChMaterialSurfaceSMC>(robot->GetWheelContactMaterial())->SetYoungModulus(Y);
}
// =============================================================================
int main(int argc, char* argv[]) {
// ----------------------------
// Parse command line arguments
// ----------------------------
robosimian::LocomotionMode mode;
double time_step;
int num_cycles;
double dbp_incr;
double terrain_length;
bool render;
bool data_output;
bool povray_output;
bool image_output;
// Extract arguments
if (!GetProblemSpecs(argc, argv, time_step, mode, num_cycles, dbp_incr, terrain_length, render, data_output,
image_output, povray_output)) {
cout << "-------------" << endl;
return 1;
}
double terrain_width = 2.0;
double location_offset = 2.0;
// ------------
// Timed events
// ------------
double time_create_terrain = duration_pose; // create terrain after robot assumes initial pose
// -------------
// Create system
// -------------
ChSystemSMC my_sys;
my_sys.SetSolverMaxIterations(200);
my_sys.SetSolverType(ChSolver::Type::BARZILAIBORWEIN);
my_sys.Set_G_acc(ChVector<double>(0, 0, -9.8));
////my_sys.Set_G_acc(ChVector<double>(0, 0, 0));
// -----------------------
// Create RoboSimian robot
// -----------------------
std::string mode_name;
switch (mode) {
case robosimian::LocomotionMode::WALK:
mode_name = "walk";
break;
case robosimian::LocomotionMode::SCULL:
mode_name = "scull";
break;
case robosimian::LocomotionMode::INCHWORM:
mode_name = "inchworm";
break;
case robosimian::LocomotionMode::DRIVE:
mode_name = "drive";
break;
}
robosimian::RoboSimian robot(&my_sys, true, true);
// Set output directory
robot.SetOutputDirectory(out_dir, mode_name);
// Set actuation mode for wheel motors
////robot.SetMotorActuationMode(robosimian::ActuationMode::ANGLE);
// Control collisions (default: true for sled and wheels only)
////robot.SetCollide(robosimian::CollisionFlags::NONE);
////robot.SetCollide(robosimian::CollisionFlags::ALL);
////robot.SetCollide(robosimian::CollisionFlags::LIMBS);
////robot.SetCollide(robosimian::CollisionFlags::CHASSIS | robosimian::CollisionFlags::WHEELS);
// Set visualization modes (default: all COLLISION)
////robot.SetVisualizationTypeChassis(robosimian::VisualizationType::MESH);
////robot.SetVisualizationTypeLimb(robosimian::FL, robosimian::VisualizationType::COLLISION);
////robot.SetVisualizationTypeLimb(robosimian::FR, robosimian::VisualizationType::COLLISION);
////robot.SetVisualizationTypeLimb(robosimian::RL, robosimian::VisualizationType::COLLISION);
////robot.SetVisualizationTypeLimb(robosimian::RR, robosimian::VisualizationType::COLLISION);
////robot.SetVisualizationTypeLimbs(robosimian::VisualizationType::NONE);
////robot.SetVisualizationTypeChassis(robosimian::VisualizationType::MESH);
////robot.SetVisualizationTypeSled(robosimian::VisualizationType::MESH);
////robot.SetVisualizationTypeLimbs(robosimian::VisualizationType::MESH);
// Initialize Robosimian robot
////robot.Initialize(ChCoordsys<>(ChVector<>(0, 0, 0), QUNIT));
robot.Initialize(ChCoordsys<>(ChVector<>(0, 0, 0), Q_from_AngX(CH_C_PI)));
// -----------------------------------
// Create a driver and attach to robot
// -----------------------------------
std::shared_ptr<robosimian::RS_Driver> driver;
switch (mode) {
case robosimian::LocomotionMode::WALK:
driver = chrono_types::make_shared<robosimian::RS_Driver>(
"", // start input file
GetChronoDataFile("robot/robosimian/actuation/walking_cycle.txt"), // cycle input file
"", // stop input file
true);
break;
case robosimian::LocomotionMode::SCULL:
driver = chrono_types::make_shared<robosimian::RS_Driver>(
GetChronoDataFile("robot/robosimian/actuation/sculling_start.txt"), // start input file
GetChronoDataFile("robot/robosimian/actuation/sculling_cycle2.txt"), // cycle input file
GetChronoDataFile("robot/robosimian/actuation/sculling_stop.txt"), // stop input file
true);
break;
case robosimian::LocomotionMode::INCHWORM:
driver = chrono_types::make_shared<robosimian::RS_Driver>(
GetChronoDataFile("robot/robosimian/actuation/inchworming_start.txt"), // start input file
GetChronoDataFile("robot/robosimian/actuation/inchworming_cycle.txt"), // cycle input file
GetChronoDataFile("robot/robosimian/actuation/inchworming_stop.txt"), // stop input file
true);
break;
case robosimian::LocomotionMode::DRIVE:
driver = chrono_types::make_shared<robosimian::RS_Driver>(
GetChronoDataFile("robot/robosimian/actuation/driving_start.txt"), // start input file
GetChronoDataFile("robot/robosimian/actuation/driving_cycle.txt"), // cycle input file
GetChronoDataFile("robot/robosimian/actuation/driving_stop.txt"), // stop input file
true);
break;
}
driver->SetTimeOffsets(duration_pose, duration_settle_robot);
robot.SetDriver(driver);
// -----------------------------------------------------
// Drawback pull setup (as phase-change callback object)
// -----------------------------------------------------
cout << "Problem parameters" << endl;
cout << " Locomotion mode: " << mode_name << endl;
cout << " Integration step size: " << time_step << endl;
cout << " Number cycles: " << num_cycles << endl;
cout << " DBP increment: " << dbp_incr << endl;
cout << " Terrain length: " << terrain_length << endl;
cout << " Render? " << (render ? "YES" : "NO") << endl;
cout << " Data output? " << (data_output ? "YES" : "NO") << endl;
cout << " Image output? " << (image_output ? "YES" : "NO") << endl;
cout << " PovRay output? " << (povray_output ? "YES" : "NO") << endl;
cout << "RoboSimian total mass: " << robot.GetMass() << endl;
DBPcontroller DBP_controller(&robot);
DBP_controller.SetCycleFreq(num_cycles);
DBP_controller.SetIncrement(dbp_incr);
driver->RegisterPhaseChangeCallback(&DBP_controller);
// -------------------------------
// Create the visualization window
// -------------------------------
std::shared_ptr<robosimian::RoboSimianVisualSystemIrrlicht> vis;
if (render) {
vis = chrono_types::make_shared<robosimian::RoboSimianVisualSystemIrrlicht>(&robot, driver.get());
vis->AttachSystem(&my_sys);
vis->SetWindowTitle("RoboSimian - SCM terrain");
vis->SetWindowSize(800, 600);
vis->Initialize();
vis->AddLogo();
vis->AddSkyBox();
vis->AddCamera(ChVector<>(1, -2.75, 0.2), ChVector<>(1, 0, 0));
vis->AddLight(ChVector<>(100, +100, 100), 290, ChColor(0.7f, 0.7f, 0.7f));
vis->AddLight(ChVector<>(100, -100, 80), 190, ChColor(0.7f, 0.8f, 0.8f));
////vis->AddLightWithShadow(ChVector<>(10.0, -6.0, 3.0), ChVector<>(0, 0, 0), 3, -10, 10, 40, 512);
////vis->EnableShadows();
}
// -----------------------------
// Initialize output directories
// -----------------------------
if (!filesystem::create_directory(filesystem::path(out_dir))) {
cout << "Error creating directory " << out_dir << endl;
return 1;
}
if (povray_output) {
if (!filesystem::create_directory(filesystem::path(pov_dir))) {
cout << "Error creating directory " << pov_dir << endl;
return 1;
}
}
if (image_output) {
if (!filesystem::create_directory(filesystem::path(img_dir))) {
cout << "Error creating directory " << img_dir << endl;
return 1;
}
}
// ---------------------------------
// Run simulation for specified time
// ---------------------------------
int output_steps = (int)std::ceil((1.0 / output_fps) / time_step);
int render_steps = (int)std::ceil((1.0 / render_fps) / time_step);
int sim_frame = 0;
int render_frame = 0;
std::shared_ptr<vehicle::SCMTerrain> terrain;
bool terrain_created = false;
while (true) {
if (render && !vis->Run()) {
break;
}
if (DBP_controller.Stop()) {
break;
}
if (robot.GetChassisPos().x() > terrain_length - 2 * location_offset) {
cout << "Reached end of terrain patch!" << endl;
cout << " time = " << my_sys.GetChTime() << endl;
cout << " Chassis location: " << robot.GetChassisPos().x() << endl;
break;
}
if (drop && !terrain_created && my_sys.GetChTime() > time_create_terrain) {
// Set terrain height
double z = robot.GetWheelPos(robosimian::FR).z() - 0.15;
// Create terrain
terrain = CreateTerrain(&robot, terrain_length, terrain_width, z, location_offset);
vis->BindItem(terrain->GetSCMLoader());
SetContactProperties(&robot);
// Release robot
robot.GetChassisBody()->SetBodyFixed(false);
terrain_created = true;
}
if (render) {
vis->BeginScene();
vis->Render();
}
if (data_output && sim_frame % output_steps == 0) {
robot.Output();
}
// Output POV-Ray date and/or snapshot images
if (sim_frame % render_steps == 0) {
if (povray_output) {
char filename[100];
sprintf(filename, "%s/data_%04d.dat", pov_dir.c_str(), render_frame + 1);
utils::WriteVisualizationAssets(&my_sys, filename);
}
if (render && image_output) {
char filename[100];
sprintf(filename, "%s/img_%04d.jpg", img_dir.c_str(), render_frame + 1);
vis->WriteImageToFile(filename);
}
render_frame++;
}
robot.DoStepDynamics(time_step);
sim_frame++;
if (render) {
vis->EndScene();
}
}
DBP_controller.WriteOutput(out_dir + "/DBP_" + mode_name + ".csv");
return 0;
}
// =============================================================================
bool GetProblemSpecs(int argc,
char** argv,
double& time_step,
robosimian::LocomotionMode& mode,
int& num_cycles,
double& dbp_incr,
double& terrain_length,
bool& render,
bool& data_output,
bool& image_output,
bool& povray_output) {
// Default values
time_step = 5e-4;
render = true;
mode = robosimian::LocomotionMode::WALK;
num_cycles = 2;
dbp_incr = 0.04;
terrain_length = 8.0;
data_output = false;
povray_output = false;
image_output = false;
ChCLI cli(argv[0]);
cli.AddOption<int>("Demo", "mode", "Locomotion mode (0:walk, 1:scull, 2:inchworm, 3:drive)", "0");
cli.AddOption<double>("Demo", "step_size", "Integration step size [s]", std::to_string(time_step));
cli.AddOption<int>("Demo", "cycles", "Number of cycles for constant DBP force", std::to_string(num_cycles));
cli.AddOption<double>("Demo", "increment", "DBP factor increment", std::to_string(dbp_incr));
cli.AddOption<double>("Demo", "terrain_length", "Length of terrain patch", std::to_string(terrain_length));
cli.AddOption<bool>("Demo", "render", "Irrlicht rendering?", std::to_string(render));
cli.AddOption<bool>("Demo", "output", "Generate result output files", std::to_string(data_output));
cli.AddOption<bool>("Demo", "pov_output", "Generate POV-Ray output files", std::to_string(povray_output));
cli.AddOption<bool>("Demo", "img_output", "Generate Irrlicht capture output files", std::to_string(image_output));
if (!cli.Parse(argc, argv)) {
cli.Help();
return false;
}
switch (cli.GetAsType<int>("mode")) {
case 0:
mode = robosimian::LocomotionMode::WALK;
break;
case 1:
mode = robosimian::LocomotionMode::SCULL;
break;
case 2:
mode = robosimian::LocomotionMode::INCHWORM;
break;
case 3:
mode = robosimian::LocomotionMode::DRIVE;
break;
default:
cout << "Invalid locomotion mode" << endl;
cli.Help();
return false;
}
time_step = cli.GetAsType<double>("step_size");
num_cycles = cli.GetAsType<int>("cycles");
dbp_incr = cli.GetAsType<double>("increment");
terrain_length = cli.GetAsType<double>("terrain_length");
render = cli.GetAsType<bool>("render");
data_output = cli.GetAsType<bool>("output");
povray_output = cli.GetAsType<bool>("pov_output");
image_output = cli.GetAsType<bool>("img_output");
image_output = image_output && render;
return true;
}
| [
"[email protected]"
] | |
e6e1ed23f6018bf85d294eb56b416e5eb3daf075 | 99df0f601fff296d93fdd20c65c266d752701168 | /libraries/glbinding/gl/functions14ext.h | 7c7542e8c469bf1ee6b61f7d4ef7f1dbeeec3966 | [
"MIT"
] | permissive | Alec-Sobeck/FPS-Game | c4d7ac2eb3cf6bd38dd5123e487d8a757c888d75 | 3a0f3e82bdbc651ee99e7b10d71d55ba43bb6d35 | refs/heads/master | 2023-04-11T09:03:33.550360 | 2021-04-24T18:59:33 | 2021-04-24T18:59:33 | 29,252,995 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 413,776 | h | #pragma once
#include <glbinding/gl/nogl.h>
#include <glbinding/gl/values.h>
#include <glbinding/gl/boolean.h>
namespace gl14ext
{
#include <glbinding/gl/types.inl>
#include <glbinding/gl/boolean.inl>
#include <glbinding/gl/values.inl>
} // namespace gl14ext
#include <glbinding/Binding.h>
namespace gl14ext
{
inline void glAccumxOES(GLenum op, GLfixed value)
{
return glbinding::Binding::AccumxOES(op, value);
}
inline void glActiveProgramEXT(GLuint program)
{
return glbinding::Binding::ActiveProgramEXT(program);
}
inline void glActiveShaderProgram(GLuint pipeline, GLuint program)
{
return glbinding::Binding::ActiveShaderProgram(pipeline, program);
}
inline void glActiveStencilFaceEXT(GLenum face)
{
return glbinding::Binding::ActiveStencilFaceEXT(face);
}
inline void glActiveTextureARB(GLenum texture)
{
return glbinding::Binding::ActiveTextureARB(texture);
}
inline void glActiveVaryingNV(GLuint program, const GLchar * name)
{
return glbinding::Binding::ActiveVaryingNV(program, name);
}
inline void glAlphaFragmentOp1ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod)
{
return glbinding::Binding::AlphaFragmentOp1ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod);
}
inline void glAlphaFragmentOp2ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod)
{
return glbinding::Binding::AlphaFragmentOp2ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
}
inline void glAlphaFragmentOp3ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod)
{
return glbinding::Binding::AlphaFragmentOp3ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
}
inline void glAlphaFuncxOES(GLenum func, GLfixed ref)
{
return glbinding::Binding::AlphaFuncxOES(func, ref);
}
inline void glApplyTextureEXT(GLenum mode)
{
return glbinding::Binding::ApplyTextureEXT(mode);
}
inline GLboolean glAreProgramsResidentNV(GLsizei n, const GLuint * programs, GLboolean * residences)
{
return glbinding::Binding::AreProgramsResidentNV(n, programs, residences);
}
inline GLboolean glAreTexturesResidentEXT(GLsizei n, const GLuint * textures, GLboolean * residences)
{
return glbinding::Binding::AreTexturesResidentEXT(n, textures, residences);
}
inline void glArrayElementEXT(GLint i)
{
return glbinding::Binding::ArrayElementEXT(i);
}
inline void glArrayObjectATI(GLenum array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset)
{
return glbinding::Binding::ArrayObjectATI(array, size, type, stride, buffer, offset);
}
inline void glAsyncMarkerSGIX(GLuint marker)
{
return glbinding::Binding::AsyncMarkerSGIX(marker);
}
inline void glAttachObjectARB(GLhandleARB containerObj, GLhandleARB obj)
{
return glbinding::Binding::AttachObjectARB(containerObj, obj);
}
inline void glAttachShader(GLuint program, GLuint shader)
{
return glbinding::Binding::AttachShader(program, shader);
}
inline void glBeginConditionalRender(GLuint id, GLenum mode)
{
return glbinding::Binding::BeginConditionalRender(id, mode);
}
inline void glBeginConditionalRenderNV(GLuint id, GLenum mode)
{
return glbinding::Binding::BeginConditionalRenderNV(id, mode);
}
inline void glBeginConditionalRenderNVX(GLuint id)
{
return glbinding::Binding::BeginConditionalRenderNVX(id);
}
inline void glBeginFragmentShaderATI()
{
return glbinding::Binding::BeginFragmentShaderATI();
}
inline void glBeginOcclusionQueryNV(GLuint id)
{
return glbinding::Binding::BeginOcclusionQueryNV(id);
}
inline void glBeginPerfMonitorAMD(GLuint monitor)
{
return glbinding::Binding::BeginPerfMonitorAMD(monitor);
}
inline void glBeginPerfQueryINTEL(GLuint queryHandle)
{
return glbinding::Binding::BeginPerfQueryINTEL(queryHandle);
}
inline void glBeginQuery(GLenum target, GLuint id)
{
return glbinding::Binding::BeginQuery(target, id);
}
inline void glBeginQueryARB(GLenum target, GLuint id)
{
return glbinding::Binding::BeginQueryARB(target, id);
}
inline void glBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
{
return glbinding::Binding::BeginQueryIndexed(target, index, id);
}
inline void glBeginTransformFeedback(GLenum primitiveMode)
{
return glbinding::Binding::BeginTransformFeedback(primitiveMode);
}
inline void glBeginTransformFeedbackEXT(GLenum primitiveMode)
{
return glbinding::Binding::BeginTransformFeedbackEXT(primitiveMode);
}
inline void glBeginTransformFeedbackNV(GLenum primitiveMode)
{
return glbinding::Binding::BeginTransformFeedbackNV(primitiveMode);
}
inline void glBeginVertexShaderEXT()
{
return glbinding::Binding::BeginVertexShaderEXT();
}
inline void glBeginVideoCaptureNV(GLuint video_capture_slot)
{
return glbinding::Binding::BeginVideoCaptureNV(video_capture_slot);
}
inline void glBindAttribLocation(GLuint program, GLuint index, const GLchar * name)
{
return glbinding::Binding::BindAttribLocation(program, index, name);
}
inline void glBindAttribLocationARB(GLhandleARB programObj, GLuint index, const GLcharARB * name)
{
return glbinding::Binding::BindAttribLocationARB(programObj, index, name);
}
inline void glBindBuffer(GLenum target, GLuint buffer)
{
return glbinding::Binding::BindBuffer(target, buffer);
}
inline void glBindBufferARB(GLenum target, GLuint buffer)
{
return glbinding::Binding::BindBufferARB(target, buffer);
}
inline void glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
{
return glbinding::Binding::BindBufferBase(target, index, buffer);
}
inline void glBindBufferBaseEXT(GLenum target, GLuint index, GLuint buffer)
{
return glbinding::Binding::BindBufferBaseEXT(target, index, buffer);
}
inline void glBindBufferBaseNV(GLenum target, GLuint index, GLuint buffer)
{
return glbinding::Binding::BindBufferBaseNV(target, index, buffer);
}
inline void glBindBufferOffsetEXT(GLenum target, GLuint index, GLuint buffer, GLintptr offset)
{
return glbinding::Binding::BindBufferOffsetEXT(target, index, buffer, offset);
}
inline void glBindBufferOffsetNV(GLenum target, GLuint index, GLuint buffer, GLintptr offset)
{
return glbinding::Binding::BindBufferOffsetNV(target, index, buffer, offset);
}
inline void glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
{
return glbinding::Binding::BindBufferRange(target, index, buffer, offset, size);
}
inline void glBindBufferRangeEXT(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
{
return glbinding::Binding::BindBufferRangeEXT(target, index, buffer, offset, size);
}
inline void glBindBufferRangeNV(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
{
return glbinding::Binding::BindBufferRangeNV(target, index, buffer, offset, size);
}
inline void glBindBuffersBase(GLenum target, GLuint first, GLsizei count, const GLuint * buffers)
{
return glbinding::Binding::BindBuffersBase(target, first, count, buffers);
}
inline void glBindBuffersRange(GLenum target, GLuint first, GLsizei count, const GLuint * buffers, const GLintptr * offsets, const GLsizeiptr * sizes)
{
return glbinding::Binding::BindBuffersRange(target, first, count, buffers, offsets, sizes);
}
inline void glBindFragDataLocation(GLuint program, GLuint color, const GLchar * name)
{
return glbinding::Binding::BindFragDataLocation(program, color, name);
}
inline void glBindFragDataLocationEXT(GLuint program, GLuint color, const GLchar * name)
{
return glbinding::Binding::BindFragDataLocationEXT(program, color, name);
}
inline void glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar * name)
{
return glbinding::Binding::BindFragDataLocationIndexed(program, colorNumber, index, name);
}
inline void glBindFragmentShaderATI(GLuint id)
{
return glbinding::Binding::BindFragmentShaderATI(id);
}
inline void glBindFramebuffer(GLenum target, GLuint framebuffer)
{
return glbinding::Binding::BindFramebuffer(target, framebuffer);
}
inline void glBindFramebufferEXT(GLenum target, GLuint framebuffer)
{
return glbinding::Binding::BindFramebufferEXT(target, framebuffer);
}
inline void glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
{
return glbinding::Binding::BindImageTexture(unit, texture, level, layered, layer, access, format);
}
inline void glBindImageTextureEXT(GLuint index, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLint format)
{
return glbinding::Binding::BindImageTextureEXT(index, texture, level, layered, layer, access, format);
}
inline void glBindImageTextures(GLuint first, GLsizei count, const GLuint * textures)
{
return glbinding::Binding::BindImageTextures(first, count, textures);
}
inline GLuint glBindLightParameterEXT(GLenum light, GLenum value)
{
return glbinding::Binding::BindLightParameterEXT(light, value);
}
inline GLuint glBindMaterialParameterEXT(GLenum face, GLenum value)
{
return glbinding::Binding::BindMaterialParameterEXT(face, value);
}
inline void glBindMultiTextureEXT(GLenum texunit, GLenum target, GLuint texture)
{
return glbinding::Binding::BindMultiTextureEXT(texunit, target, texture);
}
inline GLuint glBindParameterEXT(GLenum value)
{
return glbinding::Binding::BindParameterEXT(value);
}
inline void glBindProgramARB(GLenum target, GLuint program)
{
return glbinding::Binding::BindProgramARB(target, program);
}
inline void glBindProgramNV(GLenum target, GLuint id)
{
return glbinding::Binding::BindProgramNV(target, id);
}
inline void glBindProgramPipeline(GLuint pipeline)
{
return glbinding::Binding::BindProgramPipeline(pipeline);
}
inline void glBindRenderbuffer(GLenum target, GLuint renderbuffer)
{
return glbinding::Binding::BindRenderbuffer(target, renderbuffer);
}
inline void glBindRenderbufferEXT(GLenum target, GLuint renderbuffer)
{
return glbinding::Binding::BindRenderbufferEXT(target, renderbuffer);
}
inline void glBindSampler(GLuint unit, GLuint sampler)
{
return glbinding::Binding::BindSampler(unit, sampler);
}
inline void glBindSamplers(GLuint first, GLsizei count, const GLuint * samplers)
{
return glbinding::Binding::BindSamplers(first, count, samplers);
}
inline GLuint glBindTexGenParameterEXT(GLenum unit, GLenum coord, GLenum value)
{
return glbinding::Binding::BindTexGenParameterEXT(unit, coord, value);
}
inline void glBindTextureEXT(GLenum target, GLuint texture)
{
return glbinding::Binding::BindTextureEXT(target, texture);
}
inline void glBindTextureUnit(GLuint unit, GLuint texture)
{
return glbinding::Binding::BindTextureUnit(unit, texture);
}
inline GLuint glBindTextureUnitParameterEXT(GLenum unit, GLenum value)
{
return glbinding::Binding::BindTextureUnitParameterEXT(unit, value);
}
inline void glBindTextures(GLuint first, GLsizei count, const GLuint * textures)
{
return glbinding::Binding::BindTextures(first, count, textures);
}
inline void glBindTransformFeedback(GLenum target, GLuint id)
{
return glbinding::Binding::BindTransformFeedback(target, id);
}
inline void glBindTransformFeedbackNV(GLenum target, GLuint id)
{
return glbinding::Binding::BindTransformFeedbackNV(target, id);
}
inline void glBindVertexArray(GLuint array)
{
return glbinding::Binding::BindVertexArray(array);
}
inline void glBindVertexArrayAPPLE(GLuint array)
{
return glbinding::Binding::BindVertexArrayAPPLE(array);
}
inline void glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
{
return glbinding::Binding::BindVertexBuffer(bindingindex, buffer, offset, stride);
}
inline void glBindVertexBuffers(GLuint first, GLsizei count, const GLuint * buffers, const GLintptr * offsets, const GLsizei * strides)
{
return glbinding::Binding::BindVertexBuffers(first, count, buffers, offsets, strides);
}
inline void glBindVertexShaderEXT(GLuint id)
{
return glbinding::Binding::BindVertexShaderEXT(id);
}
inline void glBindVideoCaptureStreamBufferNV(GLuint video_capture_slot, GLuint stream, GLenum frame_region, GLintptrARB offset)
{
return glbinding::Binding::BindVideoCaptureStreamBufferNV(video_capture_slot, stream, frame_region, offset);
}
inline void glBindVideoCaptureStreamTextureNV(GLuint video_capture_slot, GLuint stream, GLenum frame_region, GLenum target, GLuint texture)
{
return glbinding::Binding::BindVideoCaptureStreamTextureNV(video_capture_slot, stream, frame_region, target, texture);
}
inline void glBinormal3bEXT(GLbyte bx, GLbyte by, GLbyte bz)
{
return glbinding::Binding::Binormal3bEXT(bx, by, bz);
}
inline void glBinormal3bvEXT(const GLbyte * v)
{
return glbinding::Binding::Binormal3bvEXT(v);
}
inline void glBinormal3dEXT(GLdouble bx, GLdouble by, GLdouble bz)
{
return glbinding::Binding::Binormal3dEXT(bx, by, bz);
}
inline void glBinormal3dvEXT(const GLdouble * v)
{
return glbinding::Binding::Binormal3dvEXT(v);
}
inline void glBinormal3fEXT(GLfloat bx, GLfloat by, GLfloat bz)
{
return glbinding::Binding::Binormal3fEXT(bx, by, bz);
}
inline void glBinormal3fvEXT(const GLfloat * v)
{
return glbinding::Binding::Binormal3fvEXT(v);
}
inline void glBinormal3iEXT(GLint bx, GLint by, GLint bz)
{
return glbinding::Binding::Binormal3iEXT(bx, by, bz);
}
inline void glBinormal3ivEXT(const GLint * v)
{
return glbinding::Binding::Binormal3ivEXT(v);
}
inline void glBinormal3sEXT(GLshort bx, GLshort by, GLshort bz)
{
return glbinding::Binding::Binormal3sEXT(bx, by, bz);
}
inline void glBinormal3svEXT(const GLshort * v)
{
return glbinding::Binding::Binormal3svEXT(v);
}
inline void glBinormalPointerEXT(GLenum type, GLsizei stride, const void * pointer)
{
return glbinding::Binding::BinormalPointerEXT(type, stride, pointer);
}
inline void glBitmapxOES(GLsizei width, GLsizei height, GLfixed xorig, GLfixed yorig, GLfixed xmove, GLfixed ymove, const GLubyte * bitmap)
{
return glbinding::Binding::BitmapxOES(width, height, xorig, yorig, xmove, ymove, bitmap);
}
inline void glBlendBarrierKHR()
{
return glbinding::Binding::BlendBarrierKHR();
}
inline void glBlendBarrierNV()
{
return glbinding::Binding::BlendBarrierNV();
}
inline void glBlendColorEXT(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
return glbinding::Binding::BlendColorEXT(red, green, blue, alpha);
}
inline void glBlendColorxOES(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
{
return glbinding::Binding::BlendColorxOES(red, green, blue, alpha);
}
inline void glBlendEquationEXT(GLenum mode)
{
return glbinding::Binding::BlendEquationEXT(mode);
}
inline void glBlendEquationIndexedAMD(GLuint buf, GLenum mode)
{
return glbinding::Binding::BlendEquationIndexedAMD(buf, mode);
}
inline void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
{
return glbinding::Binding::BlendEquationSeparate(modeRGB, modeAlpha);
}
inline void glBlendEquationSeparateEXT(GLenum modeRGB, GLenum modeAlpha)
{
return glbinding::Binding::BlendEquationSeparateEXT(modeRGB, modeAlpha);
}
inline void glBlendEquationSeparateIndexedAMD(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
{
return glbinding::Binding::BlendEquationSeparateIndexedAMD(buf, modeRGB, modeAlpha);
}
inline void glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
{
return glbinding::Binding::BlendEquationSeparatei(buf, modeRGB, modeAlpha);
}
inline void glBlendEquationSeparateiARB(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
{
return glbinding::Binding::BlendEquationSeparateiARB(buf, modeRGB, modeAlpha);
}
inline void glBlendEquationi(GLuint buf, GLenum mode)
{
return glbinding::Binding::BlendEquationi(buf, mode);
}
inline void glBlendEquationiARB(GLuint buf, GLenum mode)
{
return glbinding::Binding::BlendEquationiARB(buf, mode);
}
inline void glBlendFuncIndexedAMD(GLuint buf, GLenum src, GLenum dst)
{
return glbinding::Binding::BlendFuncIndexedAMD(buf, src, dst);
}
inline void glBlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
{
return glbinding::Binding::BlendFuncSeparateEXT(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
inline void glBlendFuncSeparateINGR(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
{
return glbinding::Binding::BlendFuncSeparateINGR(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
inline void glBlendFuncSeparateIndexedAMD(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
{
return glbinding::Binding::BlendFuncSeparateIndexedAMD(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}
inline void glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
{
return glbinding::Binding::BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}
inline void glBlendFuncSeparateiARB(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
{
return glbinding::Binding::BlendFuncSeparateiARB(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}
inline void glBlendFunci(GLuint buf, GLenum src, GLenum dst)
{
return glbinding::Binding::BlendFunci(buf, src, dst);
}
inline void glBlendFunciARB(GLuint buf, GLenum src, GLenum dst)
{
return glbinding::Binding::BlendFunciARB(buf, src, dst);
}
inline void glBlendParameteriNV(GLenum pname, GLint value)
{
return glbinding::Binding::BlendParameteriNV(pname, value);
}
inline void glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, ClearBufferMask mask, GLenum filter)
{
return glbinding::Binding::BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
inline void glBlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, ClearBufferMask mask, GLenum filter)
{
return glbinding::Binding::BlitFramebufferEXT(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
inline void glBlitNamedFramebuffer(GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, ClearBufferMask mask, GLenum filter)
{
return glbinding::Binding::BlitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}
inline void glBufferAddressRangeNV(GLenum pname, GLuint index, GLuint64EXT address, GLsizeiptr length)
{
return glbinding::Binding::BufferAddressRangeNV(pname, index, address, length);
}
inline void glBufferData(GLenum target, GLsizeiptr size, const void * data, GLenum usage)
{
return glbinding::Binding::BufferData(target, size, data, usage);
}
inline void glBufferDataARB(GLenum target, GLsizeiptrARB size, const void * data, GLenum usage)
{
return glbinding::Binding::BufferDataARB(target, size, data, usage);
}
inline void glBufferPageCommitmentARB(GLenum target, GLintptr offset, GLsizeiptr size, GLboolean commit)
{
return glbinding::Binding::BufferPageCommitmentARB(target, offset, size, commit);
}
inline void glBufferParameteriAPPLE(GLenum target, GLenum pname, GLint param)
{
return glbinding::Binding::BufferParameteriAPPLE(target, pname, param);
}
inline void glBufferStorage(GLenum target, GLsizeiptr size, const void * data, MapBufferUsageMask flags)
{
return glbinding::Binding::BufferStorage(target, size, data, flags);
}
inline void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void * data)
{
return glbinding::Binding::BufferSubData(target, offset, size, data);
}
inline void glBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, const void * data)
{
return glbinding::Binding::BufferSubDataARB(target, offset, size, data);
}
inline GLenum glCheckFramebufferStatus(GLenum target)
{
return static_cast<gl14ext::GLenum>(glbinding::Binding::CheckFramebufferStatus(target));
}
inline GLenum glCheckFramebufferStatusEXT(GLenum target)
{
return static_cast<gl14ext::GLenum>(glbinding::Binding::CheckFramebufferStatusEXT(target));
}
inline GLenum glCheckNamedFramebufferStatus(GLuint framebuffer, GLenum target)
{
return static_cast<gl14ext::GLenum>(glbinding::Binding::CheckNamedFramebufferStatus(framebuffer, target));
}
inline GLenum glCheckNamedFramebufferStatusEXT(GLuint framebuffer, GLenum target)
{
return static_cast<gl14ext::GLenum>(glbinding::Binding::CheckNamedFramebufferStatusEXT(framebuffer, target));
}
inline void glClampColor(GLenum target, GLenum clamp)
{
return glbinding::Binding::ClampColor(target, clamp);
}
inline void glClampColorARB(GLenum target, GLenum clamp)
{
return glbinding::Binding::ClampColorARB(target, clamp);
}
inline void glClearAccumxOES(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
{
return glbinding::Binding::ClearAccumxOES(red, green, blue, alpha);
}
inline void glClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void * data)
{
return glbinding::Binding::ClearBufferData(target, internalformat, format, type, data);
}
inline void glClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void * data)
{
return glbinding::Binding::ClearBufferSubData(target, internalformat, offset, size, format, type, data);
}
inline void glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
{
return glbinding::Binding::ClearBufferfi(buffer, drawbuffer, depth, stencil);
}
inline void glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat * value)
{
return glbinding::Binding::ClearBufferfv(buffer, drawbuffer, value);
}
inline void glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint * value)
{
return glbinding::Binding::ClearBufferiv(buffer, drawbuffer, value);
}
inline void glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint * value)
{
return glbinding::Binding::ClearBufferuiv(buffer, drawbuffer, value);
}
inline void glClearColorIiEXT(GLint red, GLint green, GLint blue, GLint alpha)
{
return glbinding::Binding::ClearColorIiEXT(red, green, blue, alpha);
}
inline void glClearColorIuiEXT(GLuint red, GLuint green, GLuint blue, GLuint alpha)
{
return glbinding::Binding::ClearColorIuiEXT(red, green, blue, alpha);
}
inline void glClearColorxOES(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
{
return glbinding::Binding::ClearColorxOES(red, green, blue, alpha);
}
inline void glClearDepthdNV(GLdouble depth)
{
return glbinding::Binding::ClearDepthdNV(depth);
}
inline void glClearDepthf(GLfloat d)
{
return glbinding::Binding::ClearDepthf(d);
}
inline void glClearDepthfOES(GLclampf depth)
{
return glbinding::Binding::ClearDepthfOES(depth);
}
inline void glClearDepthxOES(GLfixed depth)
{
return glbinding::Binding::ClearDepthxOES(depth);
}
inline void glClearNamedBufferData(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void * data)
{
return glbinding::Binding::ClearNamedBufferData(buffer, internalformat, format, type, data);
}
inline void glClearNamedBufferDataEXT(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void * data)
{
return glbinding::Binding::ClearNamedBufferDataEXT(buffer, internalformat, format, type, data);
}
inline void glClearNamedBufferSubData(GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void * data)
{
return glbinding::Binding::ClearNamedBufferSubData(buffer, internalformat, offset, size, format, type, data);
}
inline void glClearNamedBufferSubDataEXT(GLuint buffer, GLenum internalformat, GLsizeiptr offset, GLsizeiptr size, GLenum format, GLenum type, const void * data)
{
return glbinding::Binding::ClearNamedBufferSubDataEXT(buffer, internalformat, offset, size, format, type, data);
}
inline void glClearNamedFramebufferfi(GLuint framebuffer, GLenum buffer, const GLfloat depth, GLint stencil)
{
return glbinding::Binding::ClearNamedFramebufferfi(framebuffer, buffer, depth, stencil);
}
inline void glClearNamedFramebufferfv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat * value)
{
return glbinding::Binding::ClearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value);
}
inline void glClearNamedFramebufferiv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint * value)
{
return glbinding::Binding::ClearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value);
}
inline void glClearNamedFramebufferuiv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint * value)
{
return glbinding::Binding::ClearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value);
}
inline void glClearTexImage(GLuint texture, GLint level, GLenum format, GLenum type, const void * data)
{
return glbinding::Binding::ClearTexImage(texture, level, format, type, data);
}
inline void glClearTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data)
{
return glbinding::Binding::ClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
}
inline void glClientActiveTextureARB(GLenum texture)
{
return glbinding::Binding::ClientActiveTextureARB(texture);
}
inline void glClientActiveVertexStreamATI(GLenum stream)
{
return glbinding::Binding::ClientActiveVertexStreamATI(stream);
}
inline void glClientAttribDefaultEXT(ClientAttribMask mask)
{
return glbinding::Binding::ClientAttribDefaultEXT(mask);
}
inline GLenum glClientWaitSync(GLsync sync, SyncObjectMask flags, GLuint64 timeout)
{
return static_cast<gl14ext::GLenum>(glbinding::Binding::ClientWaitSync(sync, flags, timeout));
}
inline void glClipControl(GLenum origin, GLenum depth)
{
return glbinding::Binding::ClipControl(origin, depth);
}
inline void glClipPlanefOES(GLenum plane, const GLfloat * equation)
{
return glbinding::Binding::ClipPlanefOES(plane, equation);
}
inline void glClipPlanexOES(GLenum plane, const GLfixed * equation)
{
return glbinding::Binding::ClipPlanexOES(plane, equation);
}
inline void glColor3fVertex3fSUN(GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)
{
return glbinding::Binding::Color3fVertex3fSUN(r, g, b, x, y, z);
}
inline void glColor3fVertex3fvSUN(const GLfloat * c, const GLfloat * v)
{
return glbinding::Binding::Color3fVertex3fvSUN(c, v);
}
inline void glColor3hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue)
{
return glbinding::Binding::Color3hNV(red, green, blue);
}
inline void glColor3hvNV(const GLhalfNV * v)
{
return glbinding::Binding::Color3hvNV(v);
}
inline void glColor3xOES(GLfixed red, GLfixed green, GLfixed blue)
{
return glbinding::Binding::Color3xOES(red, green, blue);
}
inline void glColor3xvOES(const GLfixed * components)
{
return glbinding::Binding::Color3xvOES(components);
}
inline void glColor4fNormal3fVertex3fSUN(GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
{
return glbinding::Binding::Color4fNormal3fVertex3fSUN(r, g, b, a, nx, ny, nz, x, y, z);
}
inline void glColor4fNormal3fVertex3fvSUN(const GLfloat * c, const GLfloat * n, const GLfloat * v)
{
return glbinding::Binding::Color4fNormal3fVertex3fvSUN(c, n, v);
}
inline void glColor4hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue, GLhalfNV alpha)
{
return glbinding::Binding::Color4hNV(red, green, blue, alpha);
}
inline void glColor4hvNV(const GLhalfNV * v)
{
return glbinding::Binding::Color4hvNV(v);
}
inline void glColor4ubVertex2fSUN(GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y)
{
return glbinding::Binding::Color4ubVertex2fSUN(r, g, b, a, x, y);
}
inline void glColor4ubVertex2fvSUN(const GLubyte * c, const GLfloat * v)
{
return glbinding::Binding::Color4ubVertex2fvSUN(c, v);
}
inline void glColor4ubVertex3fSUN(GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z)
{
return glbinding::Binding::Color4ubVertex3fSUN(r, g, b, a, x, y, z);
}
inline void glColor4ubVertex3fvSUN(const GLubyte * c, const GLfloat * v)
{
return glbinding::Binding::Color4ubVertex3fvSUN(c, v);
}
inline void glColor4xOES(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
{
return glbinding::Binding::Color4xOES(red, green, blue, alpha);
}
inline void glColor4xvOES(const GLfixed * components)
{
return glbinding::Binding::Color4xvOES(components);
}
inline void glColorFormatNV(GLint size, GLenum type, GLsizei stride)
{
return glbinding::Binding::ColorFormatNV(size, type, stride);
}
inline void glColorFragmentOp1ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod)
{
return glbinding::Binding::ColorFragmentOp1ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod);
}
inline void glColorFragmentOp2ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod)
{
return glbinding::Binding::ColorFragmentOp2ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
}
inline void glColorFragmentOp3ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod)
{
return glbinding::Binding::ColorFragmentOp3ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
}
inline void glColorMaskIndexedEXT(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
{
return glbinding::Binding::ColorMaskIndexedEXT(index, r, g, b, a);
}
inline void glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
{
return glbinding::Binding::ColorMaski(index, r, g, b, a);
}
inline void glColorP3ui(GLenum type, GLuint color)
{
return glbinding::Binding::ColorP3ui(type, color);
}
inline void glColorP3uiv(GLenum type, const GLuint * color)
{
return glbinding::Binding::ColorP3uiv(type, color);
}
inline void glColorP4ui(GLenum type, GLuint color)
{
return glbinding::Binding::ColorP4ui(type, color);
}
inline void glColorP4uiv(GLenum type, const GLuint * color)
{
return glbinding::Binding::ColorP4uiv(type, color);
}
inline void glColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const void * pointer)
{
return glbinding::Binding::ColorPointerEXT(size, type, stride, count, pointer);
}
inline void glColorPointerListIBM(GLint size, GLenum type, GLint stride, const void ** pointer, GLint ptrstride)
{
return glbinding::Binding::ColorPointerListIBM(size, type, stride, pointer, ptrstride);
}
inline void glColorPointervINTEL(GLint size, GLenum type, const void ** pointer)
{
return glbinding::Binding::ColorPointervINTEL(size, type, pointer);
}
inline void glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void * data)
{
return glbinding::Binding::ColorSubTable(target, start, count, format, type, data);
}
inline void glColorSubTableEXT(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void * data)
{
return glbinding::Binding::ColorSubTableEXT(target, start, count, format, type, data);
}
inline void glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void * table)
{
return glbinding::Binding::ColorTable(target, internalformat, width, format, type, table);
}
inline void glColorTableEXT(GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const void * table)
{
return glbinding::Binding::ColorTableEXT(target, internalFormat, width, format, type, table);
}
inline void glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat * params)
{
return glbinding::Binding::ColorTableParameterfv(target, pname, params);
}
inline void glColorTableParameterfvSGI(GLenum target, GLenum pname, const GLfloat * params)
{
return glbinding::Binding::ColorTableParameterfvSGI(target, pname, params);
}
inline void glColorTableParameteriv(GLenum target, GLenum pname, const GLint * params)
{
return glbinding::Binding::ColorTableParameteriv(target, pname, params);
}
inline void glColorTableParameterivSGI(GLenum target, GLenum pname, const GLint * params)
{
return glbinding::Binding::ColorTableParameterivSGI(target, pname, params);
}
inline void glColorTableSGI(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void * table)
{
return glbinding::Binding::ColorTableSGI(target, internalformat, width, format, type, table);
}
inline void glCombinerInputNV(GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage)
{
return glbinding::Binding::CombinerInputNV(stage, portion, variable, input, mapping, componentUsage);
}
inline void glCombinerOutputNV(GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum)
{
return glbinding::Binding::CombinerOutputNV(stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum);
}
inline void glCombinerParameterfNV(GLenum pname, GLfloat param)
{
return glbinding::Binding::CombinerParameterfNV(pname, param);
}
inline void glCombinerParameterfvNV(GLenum pname, const GLfloat * params)
{
return glbinding::Binding::CombinerParameterfvNV(pname, params);
}
inline void glCombinerParameteriNV(GLenum pname, GLint param)
{
return glbinding::Binding::CombinerParameteriNV(pname, param);
}
inline void glCombinerParameterivNV(GLenum pname, const GLint * params)
{
return glbinding::Binding::CombinerParameterivNV(pname, params);
}
inline void glCombinerStageParameterfvNV(GLenum stage, GLenum pname, const GLfloat * params)
{
return glbinding::Binding::CombinerStageParameterfvNV(stage, pname, params);
}
inline void glCompileShader(GLuint shader)
{
return glbinding::Binding::CompileShader(shader);
}
inline void glCompileShaderARB(GLhandleARB shaderObj)
{
return glbinding::Binding::CompileShaderARB(shaderObj);
}
inline void glCompileShaderIncludeARB(GLuint shader, GLsizei count, const GLchar *const* path, const GLint * length)
{
return glbinding::Binding::CompileShaderIncludeARB(shader, count, path, length);
}
inline void glCompressedMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * bits)
{
return glbinding::Binding::CompressedMultiTexImage1DEXT(texunit, target, level, internalformat, width, border, imageSize, bits);
}
inline void glCompressedMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * bits)
{
return glbinding::Binding::CompressedMultiTexImage2DEXT(texunit, target, level, internalformat, width, height, border, imageSize, bits);
}
inline void glCompressedMultiTexImage3DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * bits)
{
return glbinding::Binding::CompressedMultiTexImage3DEXT(texunit, target, level, internalformat, width, height, depth, border, imageSize, bits);
}
inline void glCompressedMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * bits)
{
return glbinding::Binding::CompressedMultiTexSubImage1DEXT(texunit, target, level, xoffset, width, format, imageSize, bits);
}
inline void glCompressedMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * bits)
{
return glbinding::Binding::CompressedMultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, width, height, format, imageSize, bits);
}
inline void glCompressedMultiTexSubImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * bits)
{
return glbinding::Binding::CompressedMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);
}
inline void glCompressedTexImage1DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * data)
{
return glbinding::Binding::CompressedTexImage1DARB(target, level, internalformat, width, border, imageSize, data);
}
inline void glCompressedTexImage2DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * data)
{
return glbinding::Binding::CompressedTexImage2DARB(target, level, internalformat, width, height, border, imageSize, data);
}
inline void glCompressedTexImage3DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * data)
{
return glbinding::Binding::CompressedTexImage3DARB(target, level, internalformat, width, height, depth, border, imageSize, data);
}
inline void glCompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data)
{
return glbinding::Binding::CompressedTexSubImage1DARB(target, level, xoffset, width, format, imageSize, data);
}
inline void glCompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data)
{
return glbinding::Binding::CompressedTexSubImage2DARB(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}
inline void glCompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * data)
{
return glbinding::Binding::CompressedTexSubImage3DARB(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
inline void glCompressedTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * bits)
{
return glbinding::Binding::CompressedTextureImage1DEXT(texture, target, level, internalformat, width, border, imageSize, bits);
}
inline void glCompressedTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * bits)
{
return glbinding::Binding::CompressedTextureImage2DEXT(texture, target, level, internalformat, width, height, border, imageSize, bits);
}
inline void glCompressedTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * bits)
{
return glbinding::Binding::CompressedTextureImage3DEXT(texture, target, level, internalformat, width, height, depth, border, imageSize, bits);
}
inline void glCompressedTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data)
{
return glbinding::Binding::CompressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data);
}
inline void glCompressedTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * bits)
{
return glbinding::Binding::CompressedTextureSubImage1DEXT(texture, target, level, xoffset, width, format, imageSize, bits);
}
inline void glCompressedTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data)
{
return glbinding::Binding::CompressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data);
}
inline void glCompressedTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * bits)
{
return glbinding::Binding::CompressedTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits);
}
inline void glCompressedTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * data)
{
return glbinding::Binding::CompressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}
inline void glCompressedTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * bits)
{
return glbinding::Binding::CompressedTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);
}
inline void glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void * image)
{
return glbinding::Binding::ConvolutionFilter1D(target, internalformat, width, format, type, image);
}
inline void glConvolutionFilter1DEXT(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void * image)
{
return glbinding::Binding::ConvolutionFilter1DEXT(target, internalformat, width, format, type, image);
}
inline void glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * image)
{
return glbinding::Binding::ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
}
inline void glConvolutionFilter2DEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * image)
{
return glbinding::Binding::ConvolutionFilter2DEXT(target, internalformat, width, height, format, type, image);
}
inline void glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
{
return glbinding::Binding::ConvolutionParameterf(target, pname, params);
}
inline void glConvolutionParameterfEXT(GLenum target, GLenum pname, GLfloat params)
{
return glbinding::Binding::ConvolutionParameterfEXT(target, pname, params);
}
inline void glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat * params)
{
return glbinding::Binding::ConvolutionParameterfv(target, pname, params);
}
inline void glConvolutionParameterfvEXT(GLenum target, GLenum pname, const GLfloat * params)
{
return glbinding::Binding::ConvolutionParameterfvEXT(target, pname, params);
}
inline void glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
{
return glbinding::Binding::ConvolutionParameteri(target, pname, params);
}
inline void glConvolutionParameteriEXT(GLenum target, GLenum pname, GLint params)
{
return glbinding::Binding::ConvolutionParameteriEXT(target, pname, params);
}
inline void glConvolutionParameteriv(GLenum target, GLenum pname, const GLint * params)
{
return glbinding::Binding::ConvolutionParameteriv(target, pname, params);
}
inline void glConvolutionParameterivEXT(GLenum target, GLenum pname, const GLint * params)
{
return glbinding::Binding::ConvolutionParameterivEXT(target, pname, params);
}
inline void glConvolutionParameterxOES(GLenum target, GLenum pname, GLfixed param)
{
return glbinding::Binding::ConvolutionParameterxOES(target, pname, param);
}
inline void glConvolutionParameterxvOES(GLenum target, GLenum pname, const GLfixed * params)
{
return glbinding::Binding::ConvolutionParameterxvOES(target, pname, params);
}
inline void glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
{
return glbinding::Binding::CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
}
inline void glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
{
return glbinding::Binding::CopyColorSubTable(target, start, x, y, width);
}
inline void glCopyColorSubTableEXT(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
{
return glbinding::Binding::CopyColorSubTableEXT(target, start, x, y, width);
}
inline void glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
{
return glbinding::Binding::CopyColorTable(target, internalformat, x, y, width);
}
inline void glCopyColorTableSGI(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
{
return glbinding::Binding::CopyColorTableSGI(target, internalformat, x, y, width);
}
inline void glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
{
return glbinding::Binding::CopyConvolutionFilter1D(target, internalformat, x, y, width);
}
inline void glCopyConvolutionFilter1DEXT(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
{
return glbinding::Binding::CopyConvolutionFilter1DEXT(target, internalformat, x, y, width);
}
inline void glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
{
return glbinding::Binding::CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
}
inline void glCopyConvolutionFilter2DEXT(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
{
return glbinding::Binding::CopyConvolutionFilter2DEXT(target, internalformat, x, y, width, height);
}
inline void glCopyImageSubData(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth)
{
return glbinding::Binding::CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
}
inline void glCopyImageSubDataNV(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth)
{
return glbinding::Binding::CopyImageSubDataNV(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth);
}
inline void glCopyMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
{
return glbinding::Binding::CopyMultiTexImage1DEXT(texunit, target, level, internalformat, x, y, width, border);
}
inline void glCopyMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
{
return glbinding::Binding::CopyMultiTexImage2DEXT(texunit, target, level, internalformat, x, y, width, height, border);
}
inline void glCopyMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
{
return glbinding::Binding::CopyMultiTexSubImage1DEXT(texunit, target, level, xoffset, x, y, width);
}
inline void glCopyMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
return glbinding::Binding::CopyMultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, x, y, width, height);
}
inline void glCopyMultiTexSubImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
return glbinding::Binding::CopyMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
inline void glCopyNamedBufferSubData(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
{
return glbinding::Binding::CopyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size);
}
inline void glCopyPathNV(GLuint resultPath, GLuint srcPath)
{
return glbinding::Binding::CopyPathNV(resultPath, srcPath);
}
inline void glCopyTexImage1DEXT(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
{
return glbinding::Binding::CopyTexImage1DEXT(target, level, internalformat, x, y, width, border);
}
inline void glCopyTexImage2DEXT(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
{
return glbinding::Binding::CopyTexImage2DEXT(target, level, internalformat, x, y, width, height, border);
}
inline void glCopyTexSubImage1DEXT(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
{
return glbinding::Binding::CopyTexSubImage1DEXT(target, level, xoffset, x, y, width);
}
inline void glCopyTexSubImage2DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
return glbinding::Binding::CopyTexSubImage2DEXT(target, level, xoffset, yoffset, x, y, width, height);
}
inline void glCopyTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
return glbinding::Binding::CopyTexSubImage3DEXT(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
inline void glCopyTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
{
return glbinding::Binding::CopyTextureImage1DEXT(texture, target, level, internalformat, x, y, width, border);
}
inline void glCopyTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
{
return glbinding::Binding::CopyTextureImage2DEXT(texture, target, level, internalformat, x, y, width, height, border);
}
inline void glCopyTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
{
return glbinding::Binding::CopyTextureSubImage1D(texture, level, xoffset, x, y, width);
}
inline void glCopyTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
{
return glbinding::Binding::CopyTextureSubImage1DEXT(texture, target, level, xoffset, x, y, width);
}
inline void glCopyTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
return glbinding::Binding::CopyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height);
}
inline void glCopyTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
return glbinding::Binding::CopyTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, x, y, width, height);
}
inline void glCopyTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
return glbinding::Binding::CopyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height);
}
inline void glCopyTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
return glbinding::Binding::CopyTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, x, y, width, height);
}
inline void glCoverFillPathInstancedNV(GLsizei numPaths, GLenum pathNameType, const void * paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat * transformValues)
{
return glbinding::Binding::CoverFillPathInstancedNV(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
}
inline void glCoverFillPathNV(GLuint path, GLenum coverMode)
{
return glbinding::Binding::CoverFillPathNV(path, coverMode);
}
inline void glCoverStrokePathInstancedNV(GLsizei numPaths, GLenum pathNameType, const void * paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat * transformValues)
{
return glbinding::Binding::CoverStrokePathInstancedNV(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
}
inline void glCoverStrokePathNV(GLuint path, GLenum coverMode)
{
return glbinding::Binding::CoverStrokePathNV(path, coverMode);
}
inline void glCoverageModulationNV(GLenum components)
{
return glbinding::Binding::CoverageModulationNV(components);
}
inline void glCoverageModulationTableNV(GLsizei n, const GLfloat * v)
{
return glbinding::Binding::CoverageModulationTableNV(n, v);
}
inline void glCreateBuffers(GLsizei n, GLuint * buffers)
{
return glbinding::Binding::CreateBuffers(n, buffers);
}
inline void glCreateFramebuffers(GLsizei n, GLuint * framebuffers)
{
return glbinding::Binding::CreateFramebuffers(n, framebuffers);
}
inline void glCreatePerfQueryINTEL(GLuint queryId, GLuint * queryHandle)
{
return glbinding::Binding::CreatePerfQueryINTEL(queryId, queryHandle);
}
inline GLuint glCreateProgram()
{
return glbinding::Binding::CreateProgram();
}
inline GLhandleARB glCreateProgramObjectARB()
{
return glbinding::Binding::CreateProgramObjectARB();
}
inline void glCreateProgramPipelines(GLsizei n, GLuint * pipelines)
{
return glbinding::Binding::CreateProgramPipelines(n, pipelines);
}
inline void glCreateQueries(GLenum target, GLsizei n, GLuint * ids)
{
return glbinding::Binding::CreateQueries(target, n, ids);
}
inline void glCreateRenderbuffers(GLsizei n, GLuint * renderbuffers)
{
return glbinding::Binding::CreateRenderbuffers(n, renderbuffers);
}
inline void glCreateSamplers(GLsizei n, GLuint * samplers)
{
return glbinding::Binding::CreateSamplers(n, samplers);
}
inline GLuint glCreateShader(GLenum type)
{
return glbinding::Binding::CreateShader(type);
}
inline GLhandleARB glCreateShaderObjectARB(GLenum shaderType)
{
return glbinding::Binding::CreateShaderObjectARB(shaderType);
}
inline GLuint glCreateShaderProgramEXT(GLenum type, const GLchar * string)
{
return glbinding::Binding::CreateShaderProgramEXT(type, string);
}
inline GLuint glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const* strings)
{
return glbinding::Binding::CreateShaderProgramv(type, count, strings);
}
inline GLsync glCreateSyncFromCLeventARB(_cl_context * context, _cl_event * event, UnusedMask flags)
{
return glbinding::Binding::CreateSyncFromCLeventARB(context, event, flags);
}
inline void glCreateTextures(GLenum target, GLsizei n, GLuint * textures)
{
return glbinding::Binding::CreateTextures(target, n, textures);
}
inline void glCreateTransformFeedbacks(GLsizei n, GLuint * ids)
{
return glbinding::Binding::CreateTransformFeedbacks(n, ids);
}
inline void glCreateVertexArrays(GLsizei n, GLuint * arrays)
{
return glbinding::Binding::CreateVertexArrays(n, arrays);
}
inline void glCullParameterdvEXT(GLenum pname, GLdouble * params)
{
return glbinding::Binding::CullParameterdvEXT(pname, params);
}
inline void glCullParameterfvEXT(GLenum pname, GLfloat * params)
{
return glbinding::Binding::CullParameterfvEXT(pname, params);
}
inline void glCurrentPaletteMatrixARB(GLint index)
{
return glbinding::Binding::CurrentPaletteMatrixARB(index);
}
inline void glDebugMessageCallback(GLDEBUGPROC callback, const void * userParam)
{
return glbinding::Binding::DebugMessageCallback(callback, userParam);
}
inline void glDebugMessageCallbackAMD(GLDEBUGPROCAMD callback, void * userParam)
{
return glbinding::Binding::DebugMessageCallbackAMD(callback, userParam);
}
inline void glDebugMessageCallbackARB(GLDEBUGPROCARB callback, const void * userParam)
{
return glbinding::Binding::DebugMessageCallbackARB(callback, userParam);
}
inline void glDebugMessageControl(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint * ids, GLboolean enabled)
{
return glbinding::Binding::DebugMessageControl(source, type, severity, count, ids, enabled);
}
inline void glDebugMessageControlARB(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint * ids, GLboolean enabled)
{
return glbinding::Binding::DebugMessageControlARB(source, type, severity, count, ids, enabled);
}
inline void glDebugMessageEnableAMD(GLenum category, GLenum severity, GLsizei count, const GLuint * ids, GLboolean enabled)
{
return glbinding::Binding::DebugMessageEnableAMD(category, severity, count, ids, enabled);
}
inline void glDebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar * buf)
{
return glbinding::Binding::DebugMessageInsert(source, type, id, severity, length, buf);
}
inline void glDebugMessageInsertAMD(GLenum category, GLenum severity, GLuint id, GLsizei length, const GLchar * buf)
{
return glbinding::Binding::DebugMessageInsertAMD(category, severity, id, length, buf);
}
inline void glDebugMessageInsertARB(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar * buf)
{
return glbinding::Binding::DebugMessageInsertARB(source, type, id, severity, length, buf);
}
inline void glDeformSGIX(FfdMaskSGIX mask)
{
return glbinding::Binding::DeformSGIX(mask);
}
inline void glDeformationMap3dSGIX(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, const GLdouble * points)
{
return glbinding::Binding::DeformationMap3dSGIX(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points);
}
inline void glDeformationMap3fSGIX(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, const GLfloat * points)
{
return glbinding::Binding::DeformationMap3fSGIX(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points);
}
inline void glDeleteAsyncMarkersSGIX(GLuint marker, GLsizei range)
{
return glbinding::Binding::DeleteAsyncMarkersSGIX(marker, range);
}
inline void glDeleteBuffers(GLsizei n, const GLuint * buffers)
{
return glbinding::Binding::DeleteBuffers(n, buffers);
}
inline void glDeleteBuffersARB(GLsizei n, const GLuint * buffers)
{
return glbinding::Binding::DeleteBuffersARB(n, buffers);
}
inline void glDeleteFencesAPPLE(GLsizei n, const GLuint * fences)
{
return glbinding::Binding::DeleteFencesAPPLE(n, fences);
}
inline void glDeleteFencesNV(GLsizei n, const GLuint * fences)
{
return glbinding::Binding::DeleteFencesNV(n, fences);
}
inline void glDeleteFragmentShaderATI(GLuint id)
{
return glbinding::Binding::DeleteFragmentShaderATI(id);
}
inline void glDeleteFramebuffers(GLsizei n, const GLuint * framebuffers)
{
return glbinding::Binding::DeleteFramebuffers(n, framebuffers);
}
inline void glDeleteFramebuffersEXT(GLsizei n, const GLuint * framebuffers)
{
return glbinding::Binding::DeleteFramebuffersEXT(n, framebuffers);
}
inline void glDeleteNamedStringARB(GLint namelen, const GLchar * name)
{
return glbinding::Binding::DeleteNamedStringARB(namelen, name);
}
inline void glDeleteNamesAMD(GLenum identifier, GLuint num, const GLuint * names)
{
return glbinding::Binding::DeleteNamesAMD(identifier, num, names);
}
inline void glDeleteObjectARB(GLhandleARB obj)
{
return glbinding::Binding::DeleteObjectARB(obj);
}
inline void glDeleteOcclusionQueriesNV(GLsizei n, const GLuint * ids)
{
return glbinding::Binding::DeleteOcclusionQueriesNV(n, ids);
}
inline void glDeletePathsNV(GLuint path, GLsizei range)
{
return glbinding::Binding::DeletePathsNV(path, range);
}
inline void glDeletePerfMonitorsAMD(GLsizei n, GLuint * monitors)
{
return glbinding::Binding::DeletePerfMonitorsAMD(n, monitors);
}
inline void glDeletePerfQueryINTEL(GLuint queryHandle)
{
return glbinding::Binding::DeletePerfQueryINTEL(queryHandle);
}
inline void glDeleteProgram(GLuint program)
{
return glbinding::Binding::DeleteProgram(program);
}
inline void glDeleteProgramPipelines(GLsizei n, const GLuint * pipelines)
{
return glbinding::Binding::DeleteProgramPipelines(n, pipelines);
}
inline void glDeleteProgramsARB(GLsizei n, const GLuint * programs)
{
return glbinding::Binding::DeleteProgramsARB(n, programs);
}
inline void glDeleteProgramsNV(GLsizei n, const GLuint * programs)
{
return glbinding::Binding::DeleteProgramsNV(n, programs);
}
inline void glDeleteQueries(GLsizei n, const GLuint * ids)
{
return glbinding::Binding::DeleteQueries(n, ids);
}
inline void glDeleteQueriesARB(GLsizei n, const GLuint * ids)
{
return glbinding::Binding::DeleteQueriesARB(n, ids);
}
inline void glDeleteRenderbuffers(GLsizei n, const GLuint * renderbuffers)
{
return glbinding::Binding::DeleteRenderbuffers(n, renderbuffers);
}
inline void glDeleteRenderbuffersEXT(GLsizei n, const GLuint * renderbuffers)
{
return glbinding::Binding::DeleteRenderbuffersEXT(n, renderbuffers);
}
inline void glDeleteSamplers(GLsizei count, const GLuint * samplers)
{
return glbinding::Binding::DeleteSamplers(count, samplers);
}
inline void glDeleteShader(GLuint shader)
{
return glbinding::Binding::DeleteShader(shader);
}
inline void glDeleteSync(GLsync sync)
{
return glbinding::Binding::DeleteSync(sync);
}
inline void glDeleteTexturesEXT(GLsizei n, const GLuint * textures)
{
return glbinding::Binding::DeleteTexturesEXT(n, textures);
}
inline void glDeleteTransformFeedbacks(GLsizei n, const GLuint * ids)
{
return glbinding::Binding::DeleteTransformFeedbacks(n, ids);
}
inline void glDeleteTransformFeedbacksNV(GLsizei n, const GLuint * ids)
{
return glbinding::Binding::DeleteTransformFeedbacksNV(n, ids);
}
inline void glDeleteVertexArrays(GLsizei n, const GLuint * arrays)
{
return glbinding::Binding::DeleteVertexArrays(n, arrays);
}
inline void glDeleteVertexArraysAPPLE(GLsizei n, const GLuint * arrays)
{
return glbinding::Binding::DeleteVertexArraysAPPLE(n, arrays);
}
inline void glDeleteVertexShaderEXT(GLuint id)
{
return glbinding::Binding::DeleteVertexShaderEXT(id);
}
inline void glDepthBoundsEXT(GLclampd zmin, GLclampd zmax)
{
return glbinding::Binding::DepthBoundsEXT(zmin, zmax);
}
inline void glDepthBoundsdNV(GLdouble zmin, GLdouble zmax)
{
return glbinding::Binding::DepthBoundsdNV(zmin, zmax);
}
inline void glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble * v)
{
return glbinding::Binding::DepthRangeArrayv(first, count, v);
}
inline void glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f)
{
return glbinding::Binding::DepthRangeIndexed(index, n, f);
}
inline void glDepthRangedNV(GLdouble zNear, GLdouble zFar)
{
return glbinding::Binding::DepthRangedNV(zNear, zFar);
}
inline void glDepthRangef(GLfloat n, GLfloat f)
{
return glbinding::Binding::DepthRangef(n, f);
}
inline void glDepthRangefOES(GLclampf n, GLclampf f)
{
return glbinding::Binding::DepthRangefOES(n, f);
}
inline void glDepthRangexOES(GLfixed n, GLfixed f)
{
return glbinding::Binding::DepthRangexOES(n, f);
}
inline void glDetachObjectARB(GLhandleARB containerObj, GLhandleARB attachedObj)
{
return glbinding::Binding::DetachObjectARB(containerObj, attachedObj);
}
inline void glDetachShader(GLuint program, GLuint shader)
{
return glbinding::Binding::DetachShader(program, shader);
}
inline void glDetailTexFuncSGIS(GLenum target, GLsizei n, const GLfloat * points)
{
return glbinding::Binding::DetailTexFuncSGIS(target, n, points);
}
inline void glDisableClientStateIndexedEXT(GLenum array, GLuint index)
{
return glbinding::Binding::DisableClientStateIndexedEXT(array, index);
}
inline void glDisableClientStateiEXT(GLenum array, GLuint index)
{
return glbinding::Binding::DisableClientStateiEXT(array, index);
}
inline void glDisableIndexedEXT(GLenum target, GLuint index)
{
return glbinding::Binding::DisableIndexedEXT(target, index);
}
inline void glDisableVariantClientStateEXT(GLuint id)
{
return glbinding::Binding::DisableVariantClientStateEXT(id);
}
inline void glDisableVertexArrayAttrib(GLuint vaobj, GLuint index)
{
return glbinding::Binding::DisableVertexArrayAttrib(vaobj, index);
}
inline void glDisableVertexArrayAttribEXT(GLuint vaobj, GLuint index)
{
return glbinding::Binding::DisableVertexArrayAttribEXT(vaobj, index);
}
inline void glDisableVertexArrayEXT(GLuint vaobj, GLenum array)
{
return glbinding::Binding::DisableVertexArrayEXT(vaobj, array);
}
inline void glDisableVertexAttribAPPLE(GLuint index, GLenum pname)
{
return glbinding::Binding::DisableVertexAttribAPPLE(index, pname);
}
inline void glDisableVertexAttribArray(GLuint index)
{
return glbinding::Binding::DisableVertexAttribArray(index);
}
inline void glDisableVertexAttribArrayARB(GLuint index)
{
return glbinding::Binding::DisableVertexAttribArrayARB(index);
}
inline void glDisablei(GLenum target, GLuint index)
{
return glbinding::Binding::Disablei(target, index);
}
inline void glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
{
return glbinding::Binding::DispatchCompute(num_groups_x, num_groups_y, num_groups_z);
}
inline void glDispatchComputeGroupSizeARB(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z, GLuint group_size_x, GLuint group_size_y, GLuint group_size_z)
{
return glbinding::Binding::DispatchComputeGroupSizeARB(num_groups_x, num_groups_y, num_groups_z, group_size_x, group_size_y, group_size_z);
}
inline void glDispatchComputeIndirect(GLintptr indirect)
{
return glbinding::Binding::DispatchComputeIndirect(indirect);
}
inline void glDrawArraysEXT(GLenum mode, GLint first, GLsizei count)
{
return glbinding::Binding::DrawArraysEXT(mode, first, count);
}
inline void glDrawArraysIndirect(GLenum mode, const void * indirect)
{
return glbinding::Binding::DrawArraysIndirect(mode, indirect);
}
inline void glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
{
return glbinding::Binding::DrawArraysInstanced(mode, first, count, instancecount);
}
inline void glDrawArraysInstancedARB(GLenum mode, GLint first, GLsizei count, GLsizei primcount)
{
return glbinding::Binding::DrawArraysInstancedARB(mode, first, count, primcount);
}
inline void glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance)
{
return glbinding::Binding::DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
}
inline void glDrawArraysInstancedEXT(GLenum mode, GLint start, GLsizei count, GLsizei primcount)
{
return glbinding::Binding::DrawArraysInstancedEXT(mode, start, count, primcount);
}
inline void glDrawBuffers(GLsizei n, const GLenum * bufs)
{
return glbinding::Binding::DrawBuffers(n, bufs);
}
inline void glDrawBuffersARB(GLsizei n, const GLenum * bufs)
{
return glbinding::Binding::DrawBuffersARB(n, bufs);
}
inline void glDrawBuffersATI(GLsizei n, const GLenum * bufs)
{
return glbinding::Binding::DrawBuffersATI(n, bufs);
}
inline void glDrawElementArrayAPPLE(GLenum mode, GLint first, GLsizei count)
{
return glbinding::Binding::DrawElementArrayAPPLE(mode, first, count);
}
inline void glDrawElementArrayATI(GLenum mode, GLsizei count)
{
return glbinding::Binding::DrawElementArrayATI(mode, count);
}
inline void glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void * indices, GLint basevertex)
{
return glbinding::Binding::DrawElementsBaseVertex(mode, count, type, indices, basevertex);
}
inline void glDrawElementsIndirect(GLenum mode, GLenum type, const void * indirect)
{
return glbinding::Binding::DrawElementsIndirect(mode, type, indirect);
}
inline void glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount)
{
return glbinding::Binding::DrawElementsInstanced(mode, count, type, indices, instancecount);
}
inline void glDrawElementsInstancedARB(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei primcount)
{
return glbinding::Binding::DrawElementsInstancedARB(mode, count, type, indices, primcount);
}
inline void glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLuint baseinstance)
{
return glbinding::Binding::DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
}
inline void glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLint basevertex)
{
return glbinding::Binding::DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
}
inline void glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance)
{
return glbinding::Binding::DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
}
inline void glDrawElementsInstancedEXT(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei primcount)
{
return glbinding::Binding::DrawElementsInstancedEXT(mode, count, type, indices, primcount);
}
inline void glDrawMeshArraysSUN(GLenum mode, GLint first, GLsizei count, GLsizei width)
{
return glbinding::Binding::DrawMeshArraysSUN(mode, first, count, width);
}
inline void glDrawRangeElementArrayAPPLE(GLenum mode, GLuint start, GLuint end, GLint first, GLsizei count)
{
return glbinding::Binding::DrawRangeElementArrayAPPLE(mode, start, end, first, count);
}
inline void glDrawRangeElementArrayATI(GLenum mode, GLuint start, GLuint end, GLsizei count)
{
return glbinding::Binding::DrawRangeElementArrayATI(mode, start, end, count);
}
inline void glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices, GLint basevertex)
{
return glbinding::Binding::DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
}
inline void glDrawRangeElementsEXT(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices)
{
return glbinding::Binding::DrawRangeElementsEXT(mode, start, end, count, type, indices);
}
inline void glDrawTextureNV(GLuint texture, GLuint sampler, GLfloat x0, GLfloat y0, GLfloat x1, GLfloat y1, GLfloat z, GLfloat s0, GLfloat t0, GLfloat s1, GLfloat t1)
{
return glbinding::Binding::DrawTextureNV(texture, sampler, x0, y0, x1, y1, z, s0, t0, s1, t1);
}
inline void glDrawTransformFeedback(GLenum mode, GLuint id)
{
return glbinding::Binding::DrawTransformFeedback(mode, id);
}
inline void glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount)
{
return glbinding::Binding::DrawTransformFeedbackInstanced(mode, id, instancecount);
}
inline void glDrawTransformFeedbackNV(GLenum mode, GLuint id)
{
return glbinding::Binding::DrawTransformFeedbackNV(mode, id);
}
inline void glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
{
return glbinding::Binding::DrawTransformFeedbackStream(mode, id, stream);
}
inline void glDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount)
{
return glbinding::Binding::DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
}
inline void glEdgeFlagFormatNV(GLsizei stride)
{
return glbinding::Binding::EdgeFlagFormatNV(stride);
}
inline void glEdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean * pointer)
{
return glbinding::Binding::EdgeFlagPointerEXT(stride, count, pointer);
}
inline void glEdgeFlagPointerListIBM(GLint stride, const GLboolean ** pointer, GLint ptrstride)
{
return glbinding::Binding::EdgeFlagPointerListIBM(stride, pointer, ptrstride);
}
inline void glElementPointerAPPLE(GLenum type, const void * pointer)
{
return glbinding::Binding::ElementPointerAPPLE(type, pointer);
}
inline void glElementPointerATI(GLenum type, const void * pointer)
{
return glbinding::Binding::ElementPointerATI(type, pointer);
}
inline void glEnableClientStateIndexedEXT(GLenum array, GLuint index)
{
return glbinding::Binding::EnableClientStateIndexedEXT(array, index);
}
inline void glEnableClientStateiEXT(GLenum array, GLuint index)
{
return glbinding::Binding::EnableClientStateiEXT(array, index);
}
inline void glEnableIndexedEXT(GLenum target, GLuint index)
{
return glbinding::Binding::EnableIndexedEXT(target, index);
}
inline void glEnableVariantClientStateEXT(GLuint id)
{
return glbinding::Binding::EnableVariantClientStateEXT(id);
}
inline void glEnableVertexArrayAttrib(GLuint vaobj, GLuint index)
{
return glbinding::Binding::EnableVertexArrayAttrib(vaobj, index);
}
inline void glEnableVertexArrayAttribEXT(GLuint vaobj, GLuint index)
{
return glbinding::Binding::EnableVertexArrayAttribEXT(vaobj, index);
}
inline void glEnableVertexArrayEXT(GLuint vaobj, GLenum array)
{
return glbinding::Binding::EnableVertexArrayEXT(vaobj, array);
}
inline void glEnableVertexAttribAPPLE(GLuint index, GLenum pname)
{
return glbinding::Binding::EnableVertexAttribAPPLE(index, pname);
}
inline void glEnableVertexAttribArray(GLuint index)
{
return glbinding::Binding::EnableVertexAttribArray(index);
}
inline void glEnableVertexAttribArrayARB(GLuint index)
{
return glbinding::Binding::EnableVertexAttribArrayARB(index);
}
inline void glEnablei(GLenum target, GLuint index)
{
return glbinding::Binding::Enablei(target, index);
}
inline void glEndConditionalRender()
{
return glbinding::Binding::EndConditionalRender();
}
inline void glEndConditionalRenderNV()
{
return glbinding::Binding::EndConditionalRenderNV();
}
inline void glEndConditionalRenderNVX()
{
return glbinding::Binding::EndConditionalRenderNVX();
}
inline void glEndFragmentShaderATI()
{
return glbinding::Binding::EndFragmentShaderATI();
}
inline void glEndOcclusionQueryNV()
{
return glbinding::Binding::EndOcclusionQueryNV();
}
inline void glEndPerfMonitorAMD(GLuint monitor)
{
return glbinding::Binding::EndPerfMonitorAMD(monitor);
}
inline void glEndPerfQueryINTEL(GLuint queryHandle)
{
return glbinding::Binding::EndPerfQueryINTEL(queryHandle);
}
inline void glEndQuery(GLenum target)
{
return glbinding::Binding::EndQuery(target);
}
inline void glEndQueryARB(GLenum target)
{
return glbinding::Binding::EndQueryARB(target);
}
inline void glEndQueryIndexed(GLenum target, GLuint index)
{
return glbinding::Binding::EndQueryIndexed(target, index);
}
inline void glEndTransformFeedback()
{
return glbinding::Binding::EndTransformFeedback();
}
inline void glEndTransformFeedbackEXT()
{
return glbinding::Binding::EndTransformFeedbackEXT();
}
inline void glEndTransformFeedbackNV()
{
return glbinding::Binding::EndTransformFeedbackNV();
}
inline void glEndVertexShaderEXT()
{
return glbinding::Binding::EndVertexShaderEXT();
}
inline void glEndVideoCaptureNV(GLuint video_capture_slot)
{
return glbinding::Binding::EndVideoCaptureNV(video_capture_slot);
}
inline void glEvalCoord1xOES(GLfixed u)
{
return glbinding::Binding::EvalCoord1xOES(u);
}
inline void glEvalCoord1xvOES(const GLfixed * coords)
{
return glbinding::Binding::EvalCoord1xvOES(coords);
}
inline void glEvalCoord2xOES(GLfixed u, GLfixed v)
{
return glbinding::Binding::EvalCoord2xOES(u, v);
}
inline void glEvalCoord2xvOES(const GLfixed * coords)
{
return glbinding::Binding::EvalCoord2xvOES(coords);
}
inline void glEvalMapsNV(GLenum target, GLenum mode)
{
return glbinding::Binding::EvalMapsNV(target, mode);
}
inline void glExecuteProgramNV(GLenum target, GLuint id, const GLfloat * params)
{
return glbinding::Binding::ExecuteProgramNV(target, id, params);
}
inline void glExtractComponentEXT(GLuint res, GLuint src, GLuint num)
{
return glbinding::Binding::ExtractComponentEXT(res, src, num);
}
inline void glFeedbackBufferxOES(GLsizei n, GLenum type, const GLfixed * buffer)
{
return glbinding::Binding::FeedbackBufferxOES(n, type, buffer);
}
inline GLsync glFenceSync(GLenum condition, UnusedMask flags)
{
return glbinding::Binding::FenceSync(condition, flags);
}
inline void glFinalCombinerInputNV(GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage)
{
return glbinding::Binding::FinalCombinerInputNV(variable, input, mapping, componentUsage);
}
inline GLint glFinishAsyncSGIX(GLuint * markerp)
{
return glbinding::Binding::FinishAsyncSGIX(markerp);
}
inline void glFinishFenceAPPLE(GLuint fence)
{
return glbinding::Binding::FinishFenceAPPLE(fence);
}
inline void glFinishFenceNV(GLuint fence)
{
return glbinding::Binding::FinishFenceNV(fence);
}
inline void glFinishObjectAPPLE(GLenum object, GLint name)
{
return glbinding::Binding::FinishObjectAPPLE(object, name);
}
inline void glFinishTextureSUNX()
{
return glbinding::Binding::FinishTextureSUNX();
}
inline void glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
{
return glbinding::Binding::FlushMappedBufferRange(target, offset, length);
}
inline void glFlushMappedBufferRangeAPPLE(GLenum target, GLintptr offset, GLsizeiptr size)
{
return glbinding::Binding::FlushMappedBufferRangeAPPLE(target, offset, size);
}
inline void glFlushMappedNamedBufferRange(GLuint buffer, GLintptr offset, GLsizeiptr length)
{
return glbinding::Binding::FlushMappedNamedBufferRange(buffer, offset, length);
}
inline void glFlushMappedNamedBufferRangeEXT(GLuint buffer, GLintptr offset, GLsizeiptr length)
{
return glbinding::Binding::FlushMappedNamedBufferRangeEXT(buffer, offset, length);
}
inline void glFlushPixelDataRangeNV(GLenum target)
{
return glbinding::Binding::FlushPixelDataRangeNV(target);
}
inline void glFlushRasterSGIX()
{
return glbinding::Binding::FlushRasterSGIX();
}
inline void glFlushStaticDataIBM(GLenum target)
{
return glbinding::Binding::FlushStaticDataIBM(target);
}
inline void glFlushVertexArrayRangeAPPLE(GLsizei length, void * pointer)
{
return glbinding::Binding::FlushVertexArrayRangeAPPLE(length, pointer);
}
inline void glFlushVertexArrayRangeNV()
{
return glbinding::Binding::FlushVertexArrayRangeNV();
}
inline void glFogCoordFormatNV(GLenum type, GLsizei stride)
{
return glbinding::Binding::FogCoordFormatNV(type, stride);
}
inline void glFogCoordPointerEXT(GLenum type, GLsizei stride, const void * pointer)
{
return glbinding::Binding::FogCoordPointerEXT(type, stride, pointer);
}
inline void glFogCoordPointerListIBM(GLenum type, GLint stride, const void ** pointer, GLint ptrstride)
{
return glbinding::Binding::FogCoordPointerListIBM(type, stride, pointer, ptrstride);
}
inline void glFogCoorddEXT(GLdouble coord)
{
return glbinding::Binding::FogCoorddEXT(coord);
}
inline void glFogCoorddvEXT(const GLdouble * coord)
{
return glbinding::Binding::FogCoorddvEXT(coord);
}
inline void glFogCoordfEXT(GLfloat coord)
{
return glbinding::Binding::FogCoordfEXT(coord);
}
inline void glFogCoordfvEXT(const GLfloat * coord)
{
return glbinding::Binding::FogCoordfvEXT(coord);
}
inline void glFogCoordhNV(GLhalfNV fog)
{
return glbinding::Binding::FogCoordhNV(fog);
}
inline void glFogCoordhvNV(const GLhalfNV * fog)
{
return glbinding::Binding::FogCoordhvNV(fog);
}
inline void glFogFuncSGIS(GLsizei n, const GLfloat * points)
{
return glbinding::Binding::FogFuncSGIS(n, points);
}
inline void glFogxOES(GLenum pname, GLfixed param)
{
return glbinding::Binding::FogxOES(pname, param);
}
inline void glFogxvOES(GLenum pname, const GLfixed * param)
{
return glbinding::Binding::FogxvOES(pname, param);
}
inline void glFragmentColorMaterialSGIX(GLenum face, GLenum mode)
{
return glbinding::Binding::FragmentColorMaterialSGIX(face, mode);
}
inline void glFragmentCoverageColorNV(GLuint color)
{
return glbinding::Binding::FragmentCoverageColorNV(color);
}
inline void glFragmentLightModelfSGIX(GLenum pname, GLfloat param)
{
return glbinding::Binding::FragmentLightModelfSGIX(pname, param);
}
inline void glFragmentLightModelfvSGIX(GLenum pname, const GLfloat * params)
{
return glbinding::Binding::FragmentLightModelfvSGIX(pname, params);
}
inline void glFragmentLightModeliSGIX(GLenum pname, GLint param)
{
return glbinding::Binding::FragmentLightModeliSGIX(pname, param);
}
inline void glFragmentLightModelivSGIX(GLenum pname, const GLint * params)
{
return glbinding::Binding::FragmentLightModelivSGIX(pname, params);
}
inline void glFragmentLightfSGIX(GLenum light, GLenum pname, GLfloat param)
{
return glbinding::Binding::FragmentLightfSGIX(light, pname, param);
}
inline void glFragmentLightfvSGIX(GLenum light, GLenum pname, const GLfloat * params)
{
return glbinding::Binding::FragmentLightfvSGIX(light, pname, params);
}
inline void glFragmentLightiSGIX(GLenum light, GLenum pname, GLint param)
{
return glbinding::Binding::FragmentLightiSGIX(light, pname, param);
}
inline void glFragmentLightivSGIX(GLenum light, GLenum pname, const GLint * params)
{
return glbinding::Binding::FragmentLightivSGIX(light, pname, params);
}
inline void glFragmentMaterialfSGIX(GLenum face, GLenum pname, GLfloat param)
{
return glbinding::Binding::FragmentMaterialfSGIX(face, pname, param);
}
inline void glFragmentMaterialfvSGIX(GLenum face, GLenum pname, const GLfloat * params)
{
return glbinding::Binding::FragmentMaterialfvSGIX(face, pname, params);
}
inline void glFragmentMaterialiSGIX(GLenum face, GLenum pname, GLint param)
{
return glbinding::Binding::FragmentMaterialiSGIX(face, pname, param);
}
inline void glFragmentMaterialivSGIX(GLenum face, GLenum pname, const GLint * params)
{
return glbinding::Binding::FragmentMaterialivSGIX(face, pname, params);
}
inline void glFrameTerminatorGREMEDY()
{
return glbinding::Binding::FrameTerminatorGREMEDY();
}
inline void glFrameZoomSGIX(GLint factor)
{
return glbinding::Binding::FrameZoomSGIX(factor);
}
inline void glFramebufferDrawBufferEXT(GLuint framebuffer, GLenum mode)
{
return glbinding::Binding::FramebufferDrawBufferEXT(framebuffer, mode);
}
inline void glFramebufferDrawBuffersEXT(GLuint framebuffer, GLsizei n, const GLenum * bufs)
{
return glbinding::Binding::FramebufferDrawBuffersEXT(framebuffer, n, bufs);
}
inline void glFramebufferParameteri(GLenum target, GLenum pname, GLint param)
{
return glbinding::Binding::FramebufferParameteri(target, pname, param);
}
inline void glFramebufferReadBufferEXT(GLuint framebuffer, GLenum mode)
{
return glbinding::Binding::FramebufferReadBufferEXT(framebuffer, mode);
}
inline void glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
{
return glbinding::Binding::FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
inline void glFramebufferRenderbufferEXT(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
{
return glbinding::Binding::FramebufferRenderbufferEXT(target, attachment, renderbuffertarget, renderbuffer);
}
inline void glFramebufferSampleLocationsfvNV(GLenum target, GLuint start, GLsizei count, const GLfloat * v)
{
return glbinding::Binding::FramebufferSampleLocationsfvNV(target, start, count, v);
}
inline void glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
{
return glbinding::Binding::FramebufferTexture(target, attachment, texture, level);
}
inline void glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
{
return glbinding::Binding::FramebufferTexture1D(target, attachment, textarget, texture, level);
}
inline void glFramebufferTexture1DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
{
return glbinding::Binding::FramebufferTexture1DEXT(target, attachment, textarget, texture, level);
}
inline void glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
{
return glbinding::Binding::FramebufferTexture2D(target, attachment, textarget, texture, level);
}
inline void glFramebufferTexture2DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
{
return glbinding::Binding::FramebufferTexture2DEXT(target, attachment, textarget, texture, level);
}
inline void glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
{
return glbinding::Binding::FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
}
inline void glFramebufferTexture3DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
{
return glbinding::Binding::FramebufferTexture3DEXT(target, attachment, textarget, texture, level, zoffset);
}
inline void glFramebufferTextureARB(GLenum target, GLenum attachment, GLuint texture, GLint level)
{
return glbinding::Binding::FramebufferTextureARB(target, attachment, texture, level);
}
inline void glFramebufferTextureEXT(GLenum target, GLenum attachment, GLuint texture, GLint level)
{
return glbinding::Binding::FramebufferTextureEXT(target, attachment, texture, level);
}
inline void glFramebufferTextureFaceARB(GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face)
{
return glbinding::Binding::FramebufferTextureFaceARB(target, attachment, texture, level, face);
}
inline void glFramebufferTextureFaceEXT(GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face)
{
return glbinding::Binding::FramebufferTextureFaceEXT(target, attachment, texture, level, face);
}
inline void glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
{
return glbinding::Binding::FramebufferTextureLayer(target, attachment, texture, level, layer);
}
inline void glFramebufferTextureLayerARB(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
{
return glbinding::Binding::FramebufferTextureLayerARB(target, attachment, texture, level, layer);
}
inline void glFramebufferTextureLayerEXT(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
{
return glbinding::Binding::FramebufferTextureLayerEXT(target, attachment, texture, level, layer);
}
inline void glFreeObjectBufferATI(GLuint buffer)
{
return glbinding::Binding::FreeObjectBufferATI(buffer);
}
inline void glFrustumfOES(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f)
{
return glbinding::Binding::FrustumfOES(l, r, b, t, n, f);
}
inline void glFrustumxOES(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f)
{
return glbinding::Binding::FrustumxOES(l, r, b, t, n, f);
}
inline GLuint glGenAsyncMarkersSGIX(GLsizei range)
{
return glbinding::Binding::GenAsyncMarkersSGIX(range);
}
inline void glGenBuffers(GLsizei n, GLuint * buffers)
{
return glbinding::Binding::GenBuffers(n, buffers);
}
inline void glGenBuffersARB(GLsizei n, GLuint * buffers)
{
return glbinding::Binding::GenBuffersARB(n, buffers);
}
inline void glGenFencesAPPLE(GLsizei n, GLuint * fences)
{
return glbinding::Binding::GenFencesAPPLE(n, fences);
}
inline void glGenFencesNV(GLsizei n, GLuint * fences)
{
return glbinding::Binding::GenFencesNV(n, fences);
}
inline GLuint glGenFragmentShadersATI(GLuint range)
{
return glbinding::Binding::GenFragmentShadersATI(range);
}
inline void glGenFramebuffers(GLsizei n, GLuint * framebuffers)
{
return glbinding::Binding::GenFramebuffers(n, framebuffers);
}
inline void glGenFramebuffersEXT(GLsizei n, GLuint * framebuffers)
{
return glbinding::Binding::GenFramebuffersEXT(n, framebuffers);
}
inline void glGenNamesAMD(GLenum identifier, GLuint num, GLuint * names)
{
return glbinding::Binding::GenNamesAMD(identifier, num, names);
}
inline void glGenOcclusionQueriesNV(GLsizei n, GLuint * ids)
{
return glbinding::Binding::GenOcclusionQueriesNV(n, ids);
}
inline GLuint glGenPathsNV(GLsizei range)
{
return glbinding::Binding::GenPathsNV(range);
}
inline void glGenPerfMonitorsAMD(GLsizei n, GLuint * monitors)
{
return glbinding::Binding::GenPerfMonitorsAMD(n, monitors);
}
inline void glGenProgramPipelines(GLsizei n, GLuint * pipelines)
{
return glbinding::Binding::GenProgramPipelines(n, pipelines);
}
inline void glGenProgramsARB(GLsizei n, GLuint * programs)
{
return glbinding::Binding::GenProgramsARB(n, programs);
}
inline void glGenProgramsNV(GLsizei n, GLuint * programs)
{
return glbinding::Binding::GenProgramsNV(n, programs);
}
inline void glGenQueries(GLsizei n, GLuint * ids)
{
return glbinding::Binding::GenQueries(n, ids);
}
inline void glGenQueriesARB(GLsizei n, GLuint * ids)
{
return glbinding::Binding::GenQueriesARB(n, ids);
}
inline void glGenRenderbuffers(GLsizei n, GLuint * renderbuffers)
{
return glbinding::Binding::GenRenderbuffers(n, renderbuffers);
}
inline void glGenRenderbuffersEXT(GLsizei n, GLuint * renderbuffers)
{
return glbinding::Binding::GenRenderbuffersEXT(n, renderbuffers);
}
inline void glGenSamplers(GLsizei count, GLuint * samplers)
{
return glbinding::Binding::GenSamplers(count, samplers);
}
inline GLuint glGenSymbolsEXT(GLenum datatype, GLenum storagetype, GLenum range, GLuint components)
{
return glbinding::Binding::GenSymbolsEXT(datatype, storagetype, range, components);
}
inline void glGenTexturesEXT(GLsizei n, GLuint * textures)
{
return glbinding::Binding::GenTexturesEXT(n, textures);
}
inline void glGenTransformFeedbacks(GLsizei n, GLuint * ids)
{
return glbinding::Binding::GenTransformFeedbacks(n, ids);
}
inline void glGenTransformFeedbacksNV(GLsizei n, GLuint * ids)
{
return glbinding::Binding::GenTransformFeedbacksNV(n, ids);
}
inline void glGenVertexArrays(GLsizei n, GLuint * arrays)
{
return glbinding::Binding::GenVertexArrays(n, arrays);
}
inline void glGenVertexArraysAPPLE(GLsizei n, GLuint * arrays)
{
return glbinding::Binding::GenVertexArraysAPPLE(n, arrays);
}
inline GLuint glGenVertexShadersEXT(GLuint range)
{
return glbinding::Binding::GenVertexShadersEXT(range);
}
inline void glGenerateMipmap(GLenum target)
{
return glbinding::Binding::GenerateMipmap(target);
}
inline void glGenerateMipmapEXT(GLenum target)
{
return glbinding::Binding::GenerateMipmapEXT(target);
}
inline void glGenerateMultiTexMipmapEXT(GLenum texunit, GLenum target)
{
return glbinding::Binding::GenerateMultiTexMipmapEXT(texunit, target);
}
inline void glGenerateTextureMipmap(GLuint texture)
{
return glbinding::Binding::GenerateTextureMipmap(texture);
}
inline void glGenerateTextureMipmapEXT(GLuint texture, GLenum target)
{
return glbinding::Binding::GenerateTextureMipmapEXT(texture, target);
}
inline void glGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint * params)
{
return glbinding::Binding::GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
}
inline void glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name)
{
return glbinding::Binding::GetActiveAttrib(program, index, bufSize, length, size, type, name);
}
inline void glGetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei * length, GLint * size, GLenum * type, GLcharARB * name)
{
return glbinding::Binding::GetActiveAttribARB(programObj, index, maxLength, length, size, type, name);
}
inline void glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei * length, GLchar * name)
{
return glbinding::Binding::GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
}
inline void glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei * length, GLchar * name)
{
return glbinding::Binding::GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
}
inline void glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint * values)
{
return glbinding::Binding::GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
}
inline void glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name)
{
return glbinding::Binding::GetActiveUniform(program, index, bufSize, length, size, type, name);
}
inline void glGetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei * length, GLint * size, GLenum * type, GLcharARB * name)
{
return glbinding::Binding::GetActiveUniformARB(programObj, index, maxLength, length, size, type, name);
}
inline void glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformBlockName)
{
return glbinding::Binding::GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
}
inline void glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint * params)
{
return glbinding::Binding::GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
}
inline void glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformName)
{
return glbinding::Binding::GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
}
inline void glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint * uniformIndices, GLenum pname, GLint * params)
{
return glbinding::Binding::GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
}
inline void glGetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name)
{
return glbinding::Binding::GetActiveVaryingNV(program, index, bufSize, length, size, type, name);
}
inline void glGetArrayObjectfvATI(GLenum array, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetArrayObjectfvATI(array, pname, params);
}
inline void glGetArrayObjectivATI(GLenum array, GLenum pname, GLint * params)
{
return glbinding::Binding::GetArrayObjectivATI(array, pname, params);
}
inline void glGetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, GLsizei * count, GLhandleARB * obj)
{
return glbinding::Binding::GetAttachedObjectsARB(containerObj, maxCount, count, obj);
}
inline void glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei * count, GLuint * shaders)
{
return glbinding::Binding::GetAttachedShaders(program, maxCount, count, shaders);
}
inline GLint glGetAttribLocation(GLuint program, const GLchar * name)
{
return glbinding::Binding::GetAttribLocation(program, name);
}
inline GLint glGetAttribLocationARB(GLhandleARB programObj, const GLcharARB * name)
{
return glbinding::Binding::GetAttribLocationARB(programObj, name);
}
inline void glGetBooleanIndexedvEXT(GLenum target, GLuint index, GLboolean * data)
{
return glbinding::Binding::GetBooleanIndexedvEXT(target, index, data);
}
inline void glGetBooleani_v(GLenum target, GLuint index, GLboolean * data)
{
return glbinding::Binding::GetBooleani_v(target, index, data);
}
inline void glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 * params)
{
return glbinding::Binding::GetBufferParameteri64v(target, pname, params);
}
inline void glGetBufferParameteriv(GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetBufferParameteriv(target, pname, params);
}
inline void glGetBufferParameterivARB(GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetBufferParameterivARB(target, pname, params);
}
inline void glGetBufferParameterui64vNV(GLenum target, GLenum pname, GLuint64EXT * params)
{
return glbinding::Binding::GetBufferParameterui64vNV(target, pname, params);
}
inline void glGetBufferPointerv(GLenum target, GLenum pname, void ** params)
{
return glbinding::Binding::GetBufferPointerv(target, pname, params);
}
inline void glGetBufferPointervARB(GLenum target, GLenum pname, void ** params)
{
return glbinding::Binding::GetBufferPointervARB(target, pname, params);
}
inline void glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void * data)
{
return glbinding::Binding::GetBufferSubData(target, offset, size, data);
}
inline void glGetBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, void * data)
{
return glbinding::Binding::GetBufferSubDataARB(target, offset, size, data);
}
inline void glGetClipPlanefOES(GLenum plane, GLfloat * equation)
{
return glbinding::Binding::GetClipPlanefOES(plane, equation);
}
inline void glGetClipPlanexOES(GLenum plane, GLfixed * equation)
{
return glbinding::Binding::GetClipPlanexOES(plane, equation);
}
inline void glGetColorTable(GLenum target, GLenum format, GLenum type, void * table)
{
return glbinding::Binding::GetColorTable(target, format, type, table);
}
inline void glGetColorTableEXT(GLenum target, GLenum format, GLenum type, void * data)
{
return glbinding::Binding::GetColorTableEXT(target, format, type, data);
}
inline void glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetColorTableParameterfv(target, pname, params);
}
inline void glGetColorTableParameterfvEXT(GLenum target, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetColorTableParameterfvEXT(target, pname, params);
}
inline void glGetColorTableParameterfvSGI(GLenum target, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetColorTableParameterfvSGI(target, pname, params);
}
inline void glGetColorTableParameteriv(GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetColorTableParameteriv(target, pname, params);
}
inline void glGetColorTableParameterivEXT(GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetColorTableParameterivEXT(target, pname, params);
}
inline void glGetColorTableParameterivSGI(GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetColorTableParameterivSGI(target, pname, params);
}
inline void glGetColorTableSGI(GLenum target, GLenum format, GLenum type, void * table)
{
return glbinding::Binding::GetColorTableSGI(target, format, type, table);
}
inline void glGetCombinerInputParameterfvNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetCombinerInputParameterfvNV(stage, portion, variable, pname, params);
}
inline void glGetCombinerInputParameterivNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint * params)
{
return glbinding::Binding::GetCombinerInputParameterivNV(stage, portion, variable, pname, params);
}
inline void glGetCombinerOutputParameterfvNV(GLenum stage, GLenum portion, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetCombinerOutputParameterfvNV(stage, portion, pname, params);
}
inline void glGetCombinerOutputParameterivNV(GLenum stage, GLenum portion, GLenum pname, GLint * params)
{
return glbinding::Binding::GetCombinerOutputParameterivNV(stage, portion, pname, params);
}
inline void glGetCombinerStageParameterfvNV(GLenum stage, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetCombinerStageParameterfvNV(stage, pname, params);
}
inline void glGetCompressedMultiTexImageEXT(GLenum texunit, GLenum target, GLint lod, void * img)
{
return glbinding::Binding::GetCompressedMultiTexImageEXT(texunit, target, lod, img);
}
inline void glGetCompressedTexImageARB(GLenum target, GLint level, void * img)
{
return glbinding::Binding::GetCompressedTexImageARB(target, level, img);
}
inline void glGetCompressedTextureImage(GLuint texture, GLint level, GLsizei bufSize, void * pixels)
{
return glbinding::Binding::GetCompressedTextureImage(texture, level, bufSize, pixels);
}
inline void glGetCompressedTextureImageEXT(GLuint texture, GLenum target, GLint lod, void * img)
{
return glbinding::Binding::GetCompressedTextureImageEXT(texture, target, lod, img);
}
inline void glGetCompressedTextureSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void * pixels)
{
return glbinding::Binding::GetCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels);
}
inline void glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, void * image)
{
return glbinding::Binding::GetConvolutionFilter(target, format, type, image);
}
inline void glGetConvolutionFilterEXT(GLenum target, GLenum format, GLenum type, void * image)
{
return glbinding::Binding::GetConvolutionFilterEXT(target, format, type, image);
}
inline void glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetConvolutionParameterfv(target, pname, params);
}
inline void glGetConvolutionParameterfvEXT(GLenum target, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetConvolutionParameterfvEXT(target, pname, params);
}
inline void glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetConvolutionParameteriv(target, pname, params);
}
inline void glGetConvolutionParameterivEXT(GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetConvolutionParameterivEXT(target, pname, params);
}
inline void glGetConvolutionParameterxvOES(GLenum target, GLenum pname, GLfixed * params)
{
return glbinding::Binding::GetConvolutionParameterxvOES(target, pname, params);
}
inline void glGetCoverageModulationTableNV(GLsizei bufsize, GLfloat * v)
{
return glbinding::Binding::GetCoverageModulationTableNV(bufsize, v);
}
inline GLuint glGetDebugMessageLog(GLuint count, GLsizei bufSize, GLenum * sources, GLenum * types, GLuint * ids, GLenum * severities, GLsizei * lengths, GLchar * messageLog)
{
return glbinding::Binding::GetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
}
inline GLuint glGetDebugMessageLogAMD(GLuint count, GLsizei bufsize, GLenum * categories, GLuint * severities, GLuint * ids, GLsizei * lengths, GLchar * message)
{
return glbinding::Binding::GetDebugMessageLogAMD(count, bufsize, categories, severities, ids, lengths, message);
}
inline GLuint glGetDebugMessageLogARB(GLuint count, GLsizei bufSize, GLenum * sources, GLenum * types, GLuint * ids, GLenum * severities, GLsizei * lengths, GLchar * messageLog)
{
return glbinding::Binding::GetDebugMessageLogARB(count, bufSize, sources, types, ids, severities, lengths, messageLog);
}
inline void glGetDetailTexFuncSGIS(GLenum target, GLfloat * points)
{
return glbinding::Binding::GetDetailTexFuncSGIS(target, points);
}
inline void glGetDoubleIndexedvEXT(GLenum target, GLuint index, GLdouble * data)
{
return glbinding::Binding::GetDoubleIndexedvEXT(target, index, data);
}
inline void glGetDoublei_v(GLenum target, GLuint index, GLdouble * data)
{
return glbinding::Binding::GetDoublei_v(target, index, data);
}
inline void glGetDoublei_vEXT(GLenum pname, GLuint index, GLdouble * params)
{
return glbinding::Binding::GetDoublei_vEXT(pname, index, params);
}
inline void glGetFenceivNV(GLuint fence, GLenum pname, GLint * params)
{
return glbinding::Binding::GetFenceivNV(fence, pname, params);
}
inline void glGetFinalCombinerInputParameterfvNV(GLenum variable, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetFinalCombinerInputParameterfvNV(variable, pname, params);
}
inline void glGetFinalCombinerInputParameterivNV(GLenum variable, GLenum pname, GLint * params)
{
return glbinding::Binding::GetFinalCombinerInputParameterivNV(variable, pname, params);
}
inline void glGetFirstPerfQueryIdINTEL(GLuint * queryId)
{
return glbinding::Binding::GetFirstPerfQueryIdINTEL(queryId);
}
inline void glGetFixedvOES(GLenum pname, GLfixed * params)
{
return glbinding::Binding::GetFixedvOES(pname, params);
}
inline void glGetFloatIndexedvEXT(GLenum target, GLuint index, GLfloat * data)
{
return glbinding::Binding::GetFloatIndexedvEXT(target, index, data);
}
inline void glGetFloati_v(GLenum target, GLuint index, GLfloat * data)
{
return glbinding::Binding::GetFloati_v(target, index, data);
}
inline void glGetFloati_vEXT(GLenum pname, GLuint index, GLfloat * params)
{
return glbinding::Binding::GetFloati_vEXT(pname, index, params);
}
inline void glGetFogFuncSGIS(GLfloat * points)
{
return glbinding::Binding::GetFogFuncSGIS(points);
}
inline GLint glGetFragDataIndex(GLuint program, const GLchar * name)
{
return glbinding::Binding::GetFragDataIndex(program, name);
}
inline GLint glGetFragDataLocation(GLuint program, const GLchar * name)
{
return glbinding::Binding::GetFragDataLocation(program, name);
}
inline GLint glGetFragDataLocationEXT(GLuint program, const GLchar * name)
{
return glbinding::Binding::GetFragDataLocationEXT(program, name);
}
inline void glGetFragmentLightfvSGIX(GLenum light, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetFragmentLightfvSGIX(light, pname, params);
}
inline void glGetFragmentLightivSGIX(GLenum light, GLenum pname, GLint * params)
{
return glbinding::Binding::GetFragmentLightivSGIX(light, pname, params);
}
inline void glGetFragmentMaterialfvSGIX(GLenum face, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetFragmentMaterialfvSGIX(face, pname, params);
}
inline void glGetFragmentMaterialivSGIX(GLenum face, GLenum pname, GLint * params)
{
return glbinding::Binding::GetFragmentMaterialivSGIX(face, pname, params);
}
inline void glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint * params)
{
return glbinding::Binding::GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
}
inline void glGetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment, GLenum pname, GLint * params)
{
return glbinding::Binding::GetFramebufferAttachmentParameterivEXT(target, attachment, pname, params);
}
inline void glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetFramebufferParameteriv(target, pname, params);
}
inline void glGetFramebufferParameterivEXT(GLuint framebuffer, GLenum pname, GLint * params)
{
return glbinding::Binding::GetFramebufferParameterivEXT(framebuffer, pname, params);
}
inline GLenum glGetGraphicsResetStatus()
{
return static_cast<gl14ext::GLenum>(glbinding::Binding::GetGraphicsResetStatus());
}
inline GLenum glGetGraphicsResetStatusARB()
{
return static_cast<gl14ext::GLenum>(glbinding::Binding::GetGraphicsResetStatusARB());
}
inline GLhandleARB glGetHandleARB(GLenum pname)
{
return glbinding::Binding::GetHandleARB(pname);
}
inline void glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, void * values)
{
return glbinding::Binding::GetHistogram(target, reset, format, type, values);
}
inline void glGetHistogramEXT(GLenum target, GLboolean reset, GLenum format, GLenum type, void * values)
{
return glbinding::Binding::GetHistogramEXT(target, reset, format, type, values);
}
inline void glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetHistogramParameterfv(target, pname, params);
}
inline void glGetHistogramParameterfvEXT(GLenum target, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetHistogramParameterfvEXT(target, pname, params);
}
inline void glGetHistogramParameteriv(GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetHistogramParameteriv(target, pname, params);
}
inline void glGetHistogramParameterivEXT(GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetHistogramParameterivEXT(target, pname, params);
}
inline void glGetHistogramParameterxvOES(GLenum target, GLenum pname, GLfixed * params)
{
return glbinding::Binding::GetHistogramParameterxvOES(target, pname, params);
}
inline GLuint64 glGetImageHandleARB(GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format)
{
return glbinding::Binding::GetImageHandleARB(texture, level, layered, layer, format);
}
inline GLuint64 glGetImageHandleNV(GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format)
{
return glbinding::Binding::GetImageHandleNV(texture, level, layered, layer, format);
}
inline void glGetImageTransformParameterfvHP(GLenum target, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetImageTransformParameterfvHP(target, pname, params);
}
inline void glGetImageTransformParameterivHP(GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetImageTransformParameterivHP(target, pname, params);
}
inline void glGetInfoLogARB(GLhandleARB obj, GLsizei maxLength, GLsizei * length, GLcharARB * infoLog)
{
return glbinding::Binding::GetInfoLogARB(obj, maxLength, length, infoLog);
}
inline GLint glGetInstrumentsSGIX()
{
return glbinding::Binding::GetInstrumentsSGIX();
}
inline void glGetInteger64i_v(GLenum target, GLuint index, GLint64 * data)
{
return glbinding::Binding::GetInteger64i_v(target, index, data);
}
inline void glGetInteger64v(GLenum pname, GLint64 * data)
{
return glbinding::Binding::GetInteger64v(pname, data);
}
inline void glGetIntegerIndexedvEXT(GLenum target, GLuint index, GLint * data)
{
return glbinding::Binding::GetIntegerIndexedvEXT(target, index, data);
}
inline void glGetIntegeri_v(GLenum target, GLuint index, GLint * data)
{
return glbinding::Binding::GetIntegeri_v(target, index, data);
}
inline void glGetIntegerui64i_vNV(GLenum value, GLuint index, GLuint64EXT * result)
{
return glbinding::Binding::GetIntegerui64i_vNV(value, index, result);
}
inline void glGetIntegerui64vNV(GLenum value, GLuint64EXT * result)
{
return glbinding::Binding::GetIntegerui64vNV(value, result);
}
inline void glGetInternalformatSampleivNV(GLenum target, GLenum internalformat, GLsizei samples, GLenum pname, GLsizei bufSize, GLint * params)
{
return glbinding::Binding::GetInternalformatSampleivNV(target, internalformat, samples, pname, bufSize, params);
}
inline void glGetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 * params)
{
return glbinding::Binding::GetInternalformati64v(target, internalformat, pname, bufSize, params);
}
inline void glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint * params)
{
return glbinding::Binding::GetInternalformativ(target, internalformat, pname, bufSize, params);
}
inline void glGetInvariantBooleanvEXT(GLuint id, GLenum value, GLboolean * data)
{
return glbinding::Binding::GetInvariantBooleanvEXT(id, value, data);
}
inline void glGetInvariantFloatvEXT(GLuint id, GLenum value, GLfloat * data)
{
return glbinding::Binding::GetInvariantFloatvEXT(id, value, data);
}
inline void glGetInvariantIntegervEXT(GLuint id, GLenum value, GLint * data)
{
return glbinding::Binding::GetInvariantIntegervEXT(id, value, data);
}
inline void glGetLightxOES(GLenum light, GLenum pname, GLfixed * params)
{
return glbinding::Binding::GetLightxOES(light, pname, params);
}
inline void glGetListParameterfvSGIX(GLuint list, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetListParameterfvSGIX(list, pname, params);
}
inline void glGetListParameterivSGIX(GLuint list, GLenum pname, GLint * params)
{
return glbinding::Binding::GetListParameterivSGIX(list, pname, params);
}
inline void glGetLocalConstantBooleanvEXT(GLuint id, GLenum value, GLboolean * data)
{
return glbinding::Binding::GetLocalConstantBooleanvEXT(id, value, data);
}
inline void glGetLocalConstantFloatvEXT(GLuint id, GLenum value, GLfloat * data)
{
return glbinding::Binding::GetLocalConstantFloatvEXT(id, value, data);
}
inline void glGetLocalConstantIntegervEXT(GLuint id, GLenum value, GLint * data)
{
return glbinding::Binding::GetLocalConstantIntegervEXT(id, value, data);
}
inline void glGetMapAttribParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetMapAttribParameterfvNV(target, index, pname, params);
}
inline void glGetMapAttribParameterivNV(GLenum target, GLuint index, GLenum pname, GLint * params)
{
return glbinding::Binding::GetMapAttribParameterivNV(target, index, pname, params);
}
inline void glGetMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, void * points)
{
return glbinding::Binding::GetMapControlPointsNV(target, index, type, ustride, vstride, packed, points);
}
inline void glGetMapParameterfvNV(GLenum target, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetMapParameterfvNV(target, pname, params);
}
inline void glGetMapParameterivNV(GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetMapParameterivNV(target, pname, params);
}
inline void glGetMapxvOES(GLenum target, GLenum query, GLfixed * v)
{
return glbinding::Binding::GetMapxvOES(target, query, v);
}
inline void glGetMaterialxOES(GLenum face, GLenum pname, GLfixed param)
{
return glbinding::Binding::GetMaterialxOES(face, pname, param);
}
inline void glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, void * values)
{
return glbinding::Binding::GetMinmax(target, reset, format, type, values);
}
inline void glGetMinmaxEXT(GLenum target, GLboolean reset, GLenum format, GLenum type, void * values)
{
return glbinding::Binding::GetMinmaxEXT(target, reset, format, type, values);
}
inline void glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetMinmaxParameterfv(target, pname, params);
}
inline void glGetMinmaxParameterfvEXT(GLenum target, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetMinmaxParameterfvEXT(target, pname, params);
}
inline void glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetMinmaxParameteriv(target, pname, params);
}
inline void glGetMinmaxParameterivEXT(GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetMinmaxParameterivEXT(target, pname, params);
}
inline void glGetMultiTexEnvfvEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetMultiTexEnvfvEXT(texunit, target, pname, params);
}
inline void glGetMultiTexEnvivEXT(GLenum texunit, GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetMultiTexEnvivEXT(texunit, target, pname, params);
}
inline void glGetMultiTexGendvEXT(GLenum texunit, GLenum coord, GLenum pname, GLdouble * params)
{
return glbinding::Binding::GetMultiTexGendvEXT(texunit, coord, pname, params);
}
inline void glGetMultiTexGenfvEXT(GLenum texunit, GLenum coord, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetMultiTexGenfvEXT(texunit, coord, pname, params);
}
inline void glGetMultiTexGenivEXT(GLenum texunit, GLenum coord, GLenum pname, GLint * params)
{
return glbinding::Binding::GetMultiTexGenivEXT(texunit, coord, pname, params);
}
inline void glGetMultiTexImageEXT(GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, void * pixels)
{
return glbinding::Binding::GetMultiTexImageEXT(texunit, target, level, format, type, pixels);
}
inline void glGetMultiTexLevelParameterfvEXT(GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetMultiTexLevelParameterfvEXT(texunit, target, level, pname, params);
}
inline void glGetMultiTexLevelParameterivEXT(GLenum texunit, GLenum target, GLint level, GLenum pname, GLint * params)
{
return glbinding::Binding::GetMultiTexLevelParameterivEXT(texunit, target, level, pname, params);
}
inline void glGetMultiTexParameterIivEXT(GLenum texunit, GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetMultiTexParameterIivEXT(texunit, target, pname, params);
}
inline void glGetMultiTexParameterIuivEXT(GLenum texunit, GLenum target, GLenum pname, GLuint * params)
{
return glbinding::Binding::GetMultiTexParameterIuivEXT(texunit, target, pname, params);
}
inline void glGetMultiTexParameterfvEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetMultiTexParameterfvEXT(texunit, target, pname, params);
}
inline void glGetMultiTexParameterivEXT(GLenum texunit, GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetMultiTexParameterivEXT(texunit, target, pname, params);
}
inline void glGetMultisamplefv(GLenum pname, GLuint index, GLfloat * val)
{
return glbinding::Binding::GetMultisamplefv(pname, index, val);
}
inline void glGetMultisamplefvNV(GLenum pname, GLuint index, GLfloat * val)
{
return glbinding::Binding::GetMultisamplefvNV(pname, index, val);
}
inline void glGetNamedBufferParameteri64v(GLuint buffer, GLenum pname, GLint64 * params)
{
return glbinding::Binding::GetNamedBufferParameteri64v(buffer, pname, params);
}
inline void glGetNamedBufferParameteriv(GLuint buffer, GLenum pname, GLint * params)
{
return glbinding::Binding::GetNamedBufferParameteriv(buffer, pname, params);
}
inline void glGetNamedBufferParameterivEXT(GLuint buffer, GLenum pname, GLint * params)
{
return glbinding::Binding::GetNamedBufferParameterivEXT(buffer, pname, params);
}
inline void glGetNamedBufferParameterui64vNV(GLuint buffer, GLenum pname, GLuint64EXT * params)
{
return glbinding::Binding::GetNamedBufferParameterui64vNV(buffer, pname, params);
}
inline void glGetNamedBufferPointerv(GLuint buffer, GLenum pname, void ** params)
{
return glbinding::Binding::GetNamedBufferPointerv(buffer, pname, params);
}
inline void glGetNamedBufferPointervEXT(GLuint buffer, GLenum pname, void ** params)
{
return glbinding::Binding::GetNamedBufferPointervEXT(buffer, pname, params);
}
inline void glGetNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr size, void * data)
{
return glbinding::Binding::GetNamedBufferSubData(buffer, offset, size, data);
}
inline void glGetNamedBufferSubDataEXT(GLuint buffer, GLintptr offset, GLsizeiptr size, void * data)
{
return glbinding::Binding::GetNamedBufferSubDataEXT(buffer, offset, size, data);
}
inline void glGetNamedFramebufferAttachmentParameteriv(GLuint framebuffer, GLenum attachment, GLenum pname, GLint * params)
{
return glbinding::Binding::GetNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params);
}
inline void glGetNamedFramebufferAttachmentParameterivEXT(GLuint framebuffer, GLenum attachment, GLenum pname, GLint * params)
{
return glbinding::Binding::GetNamedFramebufferAttachmentParameterivEXT(framebuffer, attachment, pname, params);
}
inline void glGetNamedFramebufferParameteriv(GLuint framebuffer, GLenum pname, GLint * param)
{
return glbinding::Binding::GetNamedFramebufferParameteriv(framebuffer, pname, param);
}
inline void glGetNamedFramebufferParameterivEXT(GLuint framebuffer, GLenum pname, GLint * params)
{
return glbinding::Binding::GetNamedFramebufferParameterivEXT(framebuffer, pname, params);
}
inline void glGetNamedProgramLocalParameterIivEXT(GLuint program, GLenum target, GLuint index, GLint * params)
{
return glbinding::Binding::GetNamedProgramLocalParameterIivEXT(program, target, index, params);
}
inline void glGetNamedProgramLocalParameterIuivEXT(GLuint program, GLenum target, GLuint index, GLuint * params)
{
return glbinding::Binding::GetNamedProgramLocalParameterIuivEXT(program, target, index, params);
}
inline void glGetNamedProgramLocalParameterdvEXT(GLuint program, GLenum target, GLuint index, GLdouble * params)
{
return glbinding::Binding::GetNamedProgramLocalParameterdvEXT(program, target, index, params);
}
inline void glGetNamedProgramLocalParameterfvEXT(GLuint program, GLenum target, GLuint index, GLfloat * params)
{
return glbinding::Binding::GetNamedProgramLocalParameterfvEXT(program, target, index, params);
}
inline void glGetNamedProgramStringEXT(GLuint program, GLenum target, GLenum pname, void * string)
{
return glbinding::Binding::GetNamedProgramStringEXT(program, target, pname, string);
}
inline void glGetNamedProgramivEXT(GLuint program, GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetNamedProgramivEXT(program, target, pname, params);
}
inline void glGetNamedRenderbufferParameteriv(GLuint renderbuffer, GLenum pname, GLint * params)
{
return glbinding::Binding::GetNamedRenderbufferParameteriv(renderbuffer, pname, params);
}
inline void glGetNamedRenderbufferParameterivEXT(GLuint renderbuffer, GLenum pname, GLint * params)
{
return glbinding::Binding::GetNamedRenderbufferParameterivEXT(renderbuffer, pname, params);
}
inline void glGetNamedStringARB(GLint namelen, const GLchar * name, GLsizei bufSize, GLint * stringlen, GLchar * string)
{
return glbinding::Binding::GetNamedStringARB(namelen, name, bufSize, stringlen, string);
}
inline void glGetNamedStringivARB(GLint namelen, const GLchar * name, GLenum pname, GLint * params)
{
return glbinding::Binding::GetNamedStringivARB(namelen, name, pname, params);
}
inline void glGetNextPerfQueryIdINTEL(GLuint queryId, GLuint * nextQueryId)
{
return glbinding::Binding::GetNextPerfQueryIdINTEL(queryId, nextQueryId);
}
inline void glGetObjectBufferfvATI(GLuint buffer, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetObjectBufferfvATI(buffer, pname, params);
}
inline void glGetObjectBufferivATI(GLuint buffer, GLenum pname, GLint * params)
{
return glbinding::Binding::GetObjectBufferivATI(buffer, pname, params);
}
inline void glGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei * length, GLchar * label)
{
return glbinding::Binding::GetObjectLabel(identifier, name, bufSize, length, label);
}
inline void glGetObjectLabelEXT(GLenum type, GLuint object, GLsizei bufSize, GLsizei * length, GLchar * label)
{
return glbinding::Binding::GetObjectLabelEXT(type, object, bufSize, length, label);
}
inline void glGetObjectParameterfvARB(GLhandleARB obj, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetObjectParameterfvARB(obj, pname, params);
}
inline void glGetObjectParameterivAPPLE(GLenum objectType, GLuint name, GLenum pname, GLint * params)
{
return glbinding::Binding::GetObjectParameterivAPPLE(objectType, name, pname, params);
}
inline void glGetObjectParameterivARB(GLhandleARB obj, GLenum pname, GLint * params)
{
return glbinding::Binding::GetObjectParameterivARB(obj, pname, params);
}
inline void glGetObjectPtrLabel(const void * ptr, GLsizei bufSize, GLsizei * length, GLchar * label)
{
return glbinding::Binding::GetObjectPtrLabel(ptr, bufSize, length, label);
}
inline void glGetOcclusionQueryivNV(GLuint id, GLenum pname, GLint * params)
{
return glbinding::Binding::GetOcclusionQueryivNV(id, pname, params);
}
inline void glGetOcclusionQueryuivNV(GLuint id, GLenum pname, GLuint * params)
{
return glbinding::Binding::GetOcclusionQueryuivNV(id, pname, params);
}
inline void glGetPathColorGenfvNV(GLenum color, GLenum pname, GLfloat * value)
{
return glbinding::Binding::GetPathColorGenfvNV(color, pname, value);
}
inline void glGetPathColorGenivNV(GLenum color, GLenum pname, GLint * value)
{
return glbinding::Binding::GetPathColorGenivNV(color, pname, value);
}
inline void glGetPathCommandsNV(GLuint path, GLubyte * commands)
{
return glbinding::Binding::GetPathCommandsNV(path, commands);
}
inline void glGetPathCoordsNV(GLuint path, GLfloat * coords)
{
return glbinding::Binding::GetPathCoordsNV(path, coords);
}
inline void glGetPathDashArrayNV(GLuint path, GLfloat * dashArray)
{
return glbinding::Binding::GetPathDashArrayNV(path, dashArray);
}
inline GLfloat glGetPathLengthNV(GLuint path, GLsizei startSegment, GLsizei numSegments)
{
return glbinding::Binding::GetPathLengthNV(path, startSegment, numSegments);
}
inline void glGetPathMetricRangeNV(PathRenderingMaskNV metricQueryMask, GLuint firstPathName, GLsizei numPaths, GLsizei stride, GLfloat * metrics)
{
return glbinding::Binding::GetPathMetricRangeNV(metricQueryMask, firstPathName, numPaths, stride, metrics);
}
inline void glGetPathMetricsNV(PathRenderingMaskNV metricQueryMask, GLsizei numPaths, GLenum pathNameType, const void * paths, GLuint pathBase, GLsizei stride, GLfloat * metrics)
{
return glbinding::Binding::GetPathMetricsNV(metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics);
}
inline void glGetPathParameterfvNV(GLuint path, GLenum pname, GLfloat * value)
{
return glbinding::Binding::GetPathParameterfvNV(path, pname, value);
}
inline void glGetPathParameterivNV(GLuint path, GLenum pname, GLint * value)
{
return glbinding::Binding::GetPathParameterivNV(path, pname, value);
}
inline void glGetPathSpacingNV(GLenum pathListMode, GLsizei numPaths, GLenum pathNameType, const void * paths, GLuint pathBase, GLfloat advanceScale, GLfloat kerningScale, GLenum transformType, GLfloat * returnedSpacing)
{
return glbinding::Binding::GetPathSpacingNV(pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, returnedSpacing);
}
inline void glGetPathTexGenfvNV(GLenum texCoordSet, GLenum pname, GLfloat * value)
{
return glbinding::Binding::GetPathTexGenfvNV(texCoordSet, pname, value);
}
inline void glGetPathTexGenivNV(GLenum texCoordSet, GLenum pname, GLint * value)
{
return glbinding::Binding::GetPathTexGenivNV(texCoordSet, pname, value);
}
inline void glGetPerfCounterInfoINTEL(GLuint queryId, GLuint counterId, GLuint counterNameLength, GLchar * counterName, GLuint counterDescLength, GLchar * counterDesc, GLuint * counterOffset, GLuint * counterDataSize, GLuint * counterTypeEnum, GLuint * counterDataTypeEnum, GLuint64 * rawCounterMaxValue)
{
return glbinding::Binding::GetPerfCounterInfoINTEL(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue);
}
inline void glGetPerfMonitorCounterDataAMD(GLuint monitor, GLenum pname, GLsizei dataSize, GLuint * data, GLint * bytesWritten)
{
return glbinding::Binding::GetPerfMonitorCounterDataAMD(monitor, pname, dataSize, data, bytesWritten);
}
inline void glGetPerfMonitorCounterInfoAMD(GLuint group, GLuint counter, GLenum pname, void * data)
{
return glbinding::Binding::GetPerfMonitorCounterInfoAMD(group, counter, pname, data);
}
inline void glGetPerfMonitorCounterStringAMD(GLuint group, GLuint counter, GLsizei bufSize, GLsizei * length, GLchar * counterString)
{
return glbinding::Binding::GetPerfMonitorCounterStringAMD(group, counter, bufSize, length, counterString);
}
inline void glGetPerfMonitorCountersAMD(GLuint group, GLint * numCounters, GLint * maxActiveCounters, GLsizei counterSize, GLuint * counters)
{
return glbinding::Binding::GetPerfMonitorCountersAMD(group, numCounters, maxActiveCounters, counterSize, counters);
}
inline void glGetPerfMonitorGroupStringAMD(GLuint group, GLsizei bufSize, GLsizei * length, GLchar * groupString)
{
return glbinding::Binding::GetPerfMonitorGroupStringAMD(group, bufSize, length, groupString);
}
inline void glGetPerfMonitorGroupsAMD(GLint * numGroups, GLsizei groupsSize, GLuint * groups)
{
return glbinding::Binding::GetPerfMonitorGroupsAMD(numGroups, groupsSize, groups);
}
inline void glGetPerfQueryDataINTEL(GLuint queryHandle, GLuint flags, GLsizei dataSize, GLvoid * data, GLuint * bytesWritten)
{
return glbinding::Binding::GetPerfQueryDataINTEL(queryHandle, flags, dataSize, data, bytesWritten);
}
inline void glGetPerfQueryIdByNameINTEL(GLchar * queryName, GLuint * queryId)
{
return glbinding::Binding::GetPerfQueryIdByNameINTEL(queryName, queryId);
}
inline void glGetPerfQueryInfoINTEL(GLuint queryId, GLuint queryNameLength, GLchar * queryName, GLuint * dataSize, GLuint * noCounters, GLuint * noInstances, GLuint * capsMask)
{
return glbinding::Binding::GetPerfQueryInfoINTEL(queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, capsMask);
}
inline void glGetPixelMapxv(GLenum map, GLint size, GLfixed * values)
{
return glbinding::Binding::GetPixelMapxv(map, size, values);
}
inline void glGetPixelTexGenParameterfvSGIS(GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetPixelTexGenParameterfvSGIS(pname, params);
}
inline void glGetPixelTexGenParameterivSGIS(GLenum pname, GLint * params)
{
return glbinding::Binding::GetPixelTexGenParameterivSGIS(pname, params);
}
inline void glGetPixelTransformParameterfvEXT(GLenum target, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetPixelTransformParameterfvEXT(target, pname, params);
}
inline void glGetPixelTransformParameterivEXT(GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetPixelTransformParameterivEXT(target, pname, params);
}
inline void glGetPointerIndexedvEXT(GLenum target, GLuint index, void ** data)
{
return glbinding::Binding::GetPointerIndexedvEXT(target, index, data);
}
inline void glGetPointeri_vEXT(GLenum pname, GLuint index, void ** params)
{
return glbinding::Binding::GetPointeri_vEXT(pname, index, params);
}
inline void glGetPointervEXT(GLenum pname, void ** params)
{
return glbinding::Binding::GetPointervEXT(pname, params);
}
inline void glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei * length, GLenum * binaryFormat, void * binary)
{
return glbinding::Binding::GetProgramBinary(program, bufSize, length, binaryFormat, binary);
}
inline void glGetProgramEnvParameterIivNV(GLenum target, GLuint index, GLint * params)
{
return glbinding::Binding::GetProgramEnvParameterIivNV(target, index, params);
}
inline void glGetProgramEnvParameterIuivNV(GLenum target, GLuint index, GLuint * params)
{
return glbinding::Binding::GetProgramEnvParameterIuivNV(target, index, params);
}
inline void glGetProgramEnvParameterdvARB(GLenum target, GLuint index, GLdouble * params)
{
return glbinding::Binding::GetProgramEnvParameterdvARB(target, index, params);
}
inline void glGetProgramEnvParameterfvARB(GLenum target, GLuint index, GLfloat * params)
{
return glbinding::Binding::GetProgramEnvParameterfvARB(target, index, params);
}
inline void glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog)
{
return glbinding::Binding::GetProgramInfoLog(program, bufSize, length, infoLog);
}
inline void glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint * params)
{
return glbinding::Binding::GetProgramInterfaceiv(program, programInterface, pname, params);
}
inline void glGetProgramLocalParameterIivNV(GLenum target, GLuint index, GLint * params)
{
return glbinding::Binding::GetProgramLocalParameterIivNV(target, index, params);
}
inline void glGetProgramLocalParameterIuivNV(GLenum target, GLuint index, GLuint * params)
{
return glbinding::Binding::GetProgramLocalParameterIuivNV(target, index, params);
}
inline void glGetProgramLocalParameterdvARB(GLenum target, GLuint index, GLdouble * params)
{
return glbinding::Binding::GetProgramLocalParameterdvARB(target, index, params);
}
inline void glGetProgramLocalParameterfvARB(GLenum target, GLuint index, GLfloat * params)
{
return glbinding::Binding::GetProgramLocalParameterfvARB(target, index, params);
}
inline void glGetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble * params)
{
return glbinding::Binding::GetProgramNamedParameterdvNV(id, len, name, params);
}
inline void glGetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat * params)
{
return glbinding::Binding::GetProgramNamedParameterfvNV(id, len, name, params);
}
inline void glGetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, GLdouble * params)
{
return glbinding::Binding::GetProgramParameterdvNV(target, index, pname, params);
}
inline void glGetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetProgramParameterfvNV(target, index, pname, params);
}
inline void glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei * length, GLchar * infoLog)
{
return glbinding::Binding::GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
}
inline void glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint * params)
{
return glbinding::Binding::GetProgramPipelineiv(pipeline, pname, params);
}
inline GLuint glGetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar * name)
{
return glbinding::Binding::GetProgramResourceIndex(program, programInterface, name);
}
inline GLint glGetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar * name)
{
return glbinding::Binding::GetProgramResourceLocation(program, programInterface, name);
}
inline GLint glGetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar * name)
{
return glbinding::Binding::GetProgramResourceLocationIndex(program, programInterface, name);
}
inline void glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei * length, GLchar * name)
{
return glbinding::Binding::GetProgramResourceName(program, programInterface, index, bufSize, length, name);
}
inline void glGetProgramResourcefvNV(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum * props, GLsizei bufSize, GLsizei * length, GLfloat * params)
{
return glbinding::Binding::GetProgramResourcefvNV(program, programInterface, index, propCount, props, bufSize, length, params);
}
inline void glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum * props, GLsizei bufSize, GLsizei * length, GLint * params)
{
return glbinding::Binding::GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
}
inline void glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint * values)
{
return glbinding::Binding::GetProgramStageiv(program, shadertype, pname, values);
}
inline void glGetProgramStringARB(GLenum target, GLenum pname, void * string)
{
return glbinding::Binding::GetProgramStringARB(target, pname, string);
}
inline void glGetProgramStringNV(GLuint id, GLenum pname, GLubyte * program)
{
return glbinding::Binding::GetProgramStringNV(id, pname, program);
}
inline void glGetProgramSubroutineParameteruivNV(GLenum target, GLuint index, GLuint * param)
{
return glbinding::Binding::GetProgramSubroutineParameteruivNV(target, index, param);
}
inline void glGetProgramiv(GLuint program, GLenum pname, GLint * params)
{
return glbinding::Binding::GetProgramiv(program, pname, params);
}
inline void glGetProgramivARB(GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetProgramivARB(target, pname, params);
}
inline void glGetProgramivNV(GLuint id, GLenum pname, GLint * params)
{
return glbinding::Binding::GetProgramivNV(id, pname, params);
}
inline void glGetQueryBufferObjecti64v(GLuint id, GLuint buffer, GLenum pname, GLintptr offset)
{
return glbinding::Binding::GetQueryBufferObjecti64v(id, buffer, pname, offset);
}
inline void glGetQueryBufferObjectiv(GLuint id, GLuint buffer, GLenum pname, GLintptr offset)
{
return glbinding::Binding::GetQueryBufferObjectiv(id, buffer, pname, offset);
}
inline void glGetQueryBufferObjectui64v(GLuint id, GLuint buffer, GLenum pname, GLintptr offset)
{
return glbinding::Binding::GetQueryBufferObjectui64v(id, buffer, pname, offset);
}
inline void glGetQueryBufferObjectuiv(GLuint id, GLuint buffer, GLenum pname, GLintptr offset)
{
return glbinding::Binding::GetQueryBufferObjectuiv(id, buffer, pname, offset);
}
inline void glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint * params)
{
return glbinding::Binding::GetQueryIndexediv(target, index, pname, params);
}
inline void glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 * params)
{
return glbinding::Binding::GetQueryObjecti64v(id, pname, params);
}
inline void glGetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64 * params)
{
return glbinding::Binding::GetQueryObjecti64vEXT(id, pname, params);
}
inline void glGetQueryObjectiv(GLuint id, GLenum pname, GLint * params)
{
return glbinding::Binding::GetQueryObjectiv(id, pname, params);
}
inline void glGetQueryObjectivARB(GLuint id, GLenum pname, GLint * params)
{
return glbinding::Binding::GetQueryObjectivARB(id, pname, params);
}
inline void glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 * params)
{
return glbinding::Binding::GetQueryObjectui64v(id, pname, params);
}
inline void glGetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64 * params)
{
return glbinding::Binding::GetQueryObjectui64vEXT(id, pname, params);
}
inline void glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint * params)
{
return glbinding::Binding::GetQueryObjectuiv(id, pname, params);
}
inline void glGetQueryObjectuivARB(GLuint id, GLenum pname, GLuint * params)
{
return glbinding::Binding::GetQueryObjectuivARB(id, pname, params);
}
inline void glGetQueryiv(GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetQueryiv(target, pname, params);
}
inline void glGetQueryivARB(GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetQueryivARB(target, pname, params);
}
inline void glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetRenderbufferParameteriv(target, pname, params);
}
inline void glGetRenderbufferParameterivEXT(GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetRenderbufferParameterivEXT(target, pname, params);
}
inline void glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint * params)
{
return glbinding::Binding::GetSamplerParameterIiv(sampler, pname, params);
}
inline void glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint * params)
{
return glbinding::Binding::GetSamplerParameterIuiv(sampler, pname, params);
}
inline void glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetSamplerParameterfv(sampler, pname, params);
}
inline void glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint * params)
{
return glbinding::Binding::GetSamplerParameteriv(sampler, pname, params);
}
inline void glGetSeparableFilter(GLenum target, GLenum format, GLenum type, void * row, void * column, void * span)
{
return glbinding::Binding::GetSeparableFilter(target, format, type, row, column, span);
}
inline void glGetSeparableFilterEXT(GLenum target, GLenum format, GLenum type, void * row, void * column, void * span)
{
return glbinding::Binding::GetSeparableFilterEXT(target, format, type, row, column, span);
}
inline void glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * infoLog)
{
return glbinding::Binding::GetShaderInfoLog(shader, bufSize, length, infoLog);
}
inline void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint * range, GLint * precision)
{
return glbinding::Binding::GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
}
inline void glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * source)
{
return glbinding::Binding::GetShaderSource(shader, bufSize, length, source);
}
inline void glGetShaderSourceARB(GLhandleARB obj, GLsizei maxLength, GLsizei * length, GLcharARB * source)
{
return glbinding::Binding::GetShaderSourceARB(obj, maxLength, length, source);
}
inline void glGetShaderiv(GLuint shader, GLenum pname, GLint * params)
{
return glbinding::Binding::GetShaderiv(shader, pname, params);
}
inline void glGetSharpenTexFuncSGIS(GLenum target, GLfloat * points)
{
return glbinding::Binding::GetSharpenTexFuncSGIS(target, points);
}
inline const GLubyte * glGetStringi(GLenum name, GLuint index)
{
return glbinding::Binding::GetStringi(name, index);
}
inline GLuint glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar * name)
{
return glbinding::Binding::GetSubroutineIndex(program, shadertype, name);
}
inline GLint glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar * name)
{
return glbinding::Binding::GetSubroutineUniformLocation(program, shadertype, name);
}
inline void glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei * length, GLint * values)
{
return glbinding::Binding::GetSynciv(sync, pname, bufSize, length, values);
}
inline void glGetTexBumpParameterfvATI(GLenum pname, GLfloat * param)
{
return glbinding::Binding::GetTexBumpParameterfvATI(pname, param);
}
inline void glGetTexBumpParameterivATI(GLenum pname, GLint * param)
{
return glbinding::Binding::GetTexBumpParameterivATI(pname, param);
}
inline void glGetTexEnvxvOES(GLenum target, GLenum pname, GLfixed * params)
{
return glbinding::Binding::GetTexEnvxvOES(target, pname, params);
}
inline void glGetTexFilterFuncSGIS(GLenum target, GLenum filter, GLfloat * weights)
{
return glbinding::Binding::GetTexFilterFuncSGIS(target, filter, weights);
}
inline void glGetTexGenxvOES(GLenum coord, GLenum pname, GLfixed * params)
{
return glbinding::Binding::GetTexGenxvOES(coord, pname, params);
}
inline void glGetTexLevelParameterxvOES(GLenum target, GLint level, GLenum pname, GLfixed * params)
{
return glbinding::Binding::GetTexLevelParameterxvOES(target, level, pname, params);
}
inline void glGetTexParameterIiv(GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetTexParameterIiv(target, pname, params);
}
inline void glGetTexParameterIivEXT(GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetTexParameterIivEXT(target, pname, params);
}
inline void glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint * params)
{
return glbinding::Binding::GetTexParameterIuiv(target, pname, params);
}
inline void glGetTexParameterIuivEXT(GLenum target, GLenum pname, GLuint * params)
{
return glbinding::Binding::GetTexParameterIuivEXT(target, pname, params);
}
inline void glGetTexParameterPointervAPPLE(GLenum target, GLenum pname, void ** params)
{
return glbinding::Binding::GetTexParameterPointervAPPLE(target, pname, params);
}
inline void glGetTexParameterxvOES(GLenum target, GLenum pname, GLfixed * params)
{
return glbinding::Binding::GetTexParameterxvOES(target, pname, params);
}
inline GLuint64 glGetTextureHandleARB(GLuint texture)
{
return glbinding::Binding::GetTextureHandleARB(texture);
}
inline GLuint64 glGetTextureHandleNV(GLuint texture)
{
return glbinding::Binding::GetTextureHandleNV(texture);
}
inline void glGetTextureImage(GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void * pixels)
{
return glbinding::Binding::GetTextureImage(texture, level, format, type, bufSize, pixels);
}
inline void glGetTextureImageEXT(GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, void * pixels)
{
return glbinding::Binding::GetTextureImageEXT(texture, target, level, format, type, pixels);
}
inline void glGetTextureLevelParameterfv(GLuint texture, GLint level, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetTextureLevelParameterfv(texture, level, pname, params);
}
inline void glGetTextureLevelParameterfvEXT(GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetTextureLevelParameterfvEXT(texture, target, level, pname, params);
}
inline void glGetTextureLevelParameteriv(GLuint texture, GLint level, GLenum pname, GLint * params)
{
return glbinding::Binding::GetTextureLevelParameteriv(texture, level, pname, params);
}
inline void glGetTextureLevelParameterivEXT(GLuint texture, GLenum target, GLint level, GLenum pname, GLint * params)
{
return glbinding::Binding::GetTextureLevelParameterivEXT(texture, target, level, pname, params);
}
inline void glGetTextureParameterIiv(GLuint texture, GLenum pname, GLint * params)
{
return glbinding::Binding::GetTextureParameterIiv(texture, pname, params);
}
inline void glGetTextureParameterIivEXT(GLuint texture, GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetTextureParameterIivEXT(texture, target, pname, params);
}
inline void glGetTextureParameterIuiv(GLuint texture, GLenum pname, GLuint * params)
{
return glbinding::Binding::GetTextureParameterIuiv(texture, pname, params);
}
inline void glGetTextureParameterIuivEXT(GLuint texture, GLenum target, GLenum pname, GLuint * params)
{
return glbinding::Binding::GetTextureParameterIuivEXT(texture, target, pname, params);
}
inline void glGetTextureParameterfv(GLuint texture, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetTextureParameterfv(texture, pname, params);
}
inline void glGetTextureParameterfvEXT(GLuint texture, GLenum target, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetTextureParameterfvEXT(texture, target, pname, params);
}
inline void glGetTextureParameteriv(GLuint texture, GLenum pname, GLint * params)
{
return glbinding::Binding::GetTextureParameteriv(texture, pname, params);
}
inline void glGetTextureParameterivEXT(GLuint texture, GLenum target, GLenum pname, GLint * params)
{
return glbinding::Binding::GetTextureParameterivEXT(texture, target, pname, params);
}
inline GLuint64 glGetTextureSamplerHandleARB(GLuint texture, GLuint sampler)
{
return glbinding::Binding::GetTextureSamplerHandleARB(texture, sampler);
}
inline GLuint64 glGetTextureSamplerHandleNV(GLuint texture, GLuint sampler)
{
return glbinding::Binding::GetTextureSamplerHandleNV(texture, sampler);
}
inline void glGetTextureSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void * pixels)
{
return glbinding::Binding::GetTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels);
}
inline void glGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, GLint * params)
{
return glbinding::Binding::GetTrackMatrixivNV(target, address, pname, params);
}
inline void glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name)
{
return glbinding::Binding::GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
}
inline void glGetTransformFeedbackVaryingEXT(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name)
{
return glbinding::Binding::GetTransformFeedbackVaryingEXT(program, index, bufSize, length, size, type, name);
}
inline void glGetTransformFeedbackVaryingNV(GLuint program, GLuint index, GLint * location)
{
return glbinding::Binding::GetTransformFeedbackVaryingNV(program, index, location);
}
inline void glGetTransformFeedbacki64_v(GLuint xfb, GLenum pname, GLuint index, GLint64 * param)
{
return glbinding::Binding::GetTransformFeedbacki64_v(xfb, pname, index, param);
}
inline void glGetTransformFeedbacki_v(GLuint xfb, GLenum pname, GLuint index, GLint * param)
{
return glbinding::Binding::GetTransformFeedbacki_v(xfb, pname, index, param);
}
inline void glGetTransformFeedbackiv(GLuint xfb, GLenum pname, GLint * param)
{
return glbinding::Binding::GetTransformFeedbackiv(xfb, pname, param);
}
inline GLuint glGetUniformBlockIndex(GLuint program, const GLchar * uniformBlockName)
{
return glbinding::Binding::GetUniformBlockIndex(program, uniformBlockName);
}
inline GLint glGetUniformBufferSizeEXT(GLuint program, GLint location)
{
return glbinding::Binding::GetUniformBufferSizeEXT(program, location);
}
inline void glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const* uniformNames, GLuint * uniformIndices)
{
return glbinding::Binding::GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
}
inline GLint glGetUniformLocation(GLuint program, const GLchar * name)
{
return glbinding::Binding::GetUniformLocation(program, name);
}
inline GLint glGetUniformLocationARB(GLhandleARB programObj, const GLcharARB * name)
{
return glbinding::Binding::GetUniformLocationARB(programObj, name);
}
inline GLintptr glGetUniformOffsetEXT(GLuint program, GLint location)
{
return glbinding::Binding::GetUniformOffsetEXT(program, location);
}
inline void glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint * params)
{
return glbinding::Binding::GetUniformSubroutineuiv(shadertype, location, params);
}
inline void glGetUniformdv(GLuint program, GLint location, GLdouble * params)
{
return glbinding::Binding::GetUniformdv(program, location, params);
}
inline void glGetUniformfv(GLuint program, GLint location, GLfloat * params)
{
return glbinding::Binding::GetUniformfv(program, location, params);
}
inline void glGetUniformfvARB(GLhandleARB programObj, GLint location, GLfloat * params)
{
return glbinding::Binding::GetUniformfvARB(programObj, location, params);
}
inline void glGetUniformi64vNV(GLuint program, GLint location, GLint64EXT * params)
{
return glbinding::Binding::GetUniformi64vNV(program, location, params);
}
inline void glGetUniformiv(GLuint program, GLint location, GLint * params)
{
return glbinding::Binding::GetUniformiv(program, location, params);
}
inline void glGetUniformivARB(GLhandleARB programObj, GLint location, GLint * params)
{
return glbinding::Binding::GetUniformivARB(programObj, location, params);
}
inline void glGetUniformui64vNV(GLuint program, GLint location, GLuint64EXT * params)
{
return glbinding::Binding::GetUniformui64vNV(program, location, params);
}
inline void glGetUniformuiv(GLuint program, GLint location, GLuint * params)
{
return glbinding::Binding::GetUniformuiv(program, location, params);
}
inline void glGetUniformuivEXT(GLuint program, GLint location, GLuint * params)
{
return glbinding::Binding::GetUniformuivEXT(program, location, params);
}
inline void glGetVariantArrayObjectfvATI(GLuint id, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetVariantArrayObjectfvATI(id, pname, params);
}
inline void glGetVariantArrayObjectivATI(GLuint id, GLenum pname, GLint * params)
{
return glbinding::Binding::GetVariantArrayObjectivATI(id, pname, params);
}
inline void glGetVariantBooleanvEXT(GLuint id, GLenum value, GLboolean * data)
{
return glbinding::Binding::GetVariantBooleanvEXT(id, value, data);
}
inline void glGetVariantFloatvEXT(GLuint id, GLenum value, GLfloat * data)
{
return glbinding::Binding::GetVariantFloatvEXT(id, value, data);
}
inline void glGetVariantIntegervEXT(GLuint id, GLenum value, GLint * data)
{
return glbinding::Binding::GetVariantIntegervEXT(id, value, data);
}
inline void glGetVariantPointervEXT(GLuint id, GLenum value, void ** data)
{
return glbinding::Binding::GetVariantPointervEXT(id, value, data);
}
inline GLint glGetVaryingLocationNV(GLuint program, const GLchar * name)
{
return glbinding::Binding::GetVaryingLocationNV(program, name);
}
inline void glGetVertexArrayIndexed64iv(GLuint vaobj, GLuint index, GLenum pname, GLint64 * param)
{
return glbinding::Binding::GetVertexArrayIndexed64iv(vaobj, index, pname, param);
}
inline void glGetVertexArrayIndexediv(GLuint vaobj, GLuint index, GLenum pname, GLint * param)
{
return glbinding::Binding::GetVertexArrayIndexediv(vaobj, index, pname, param);
}
inline void glGetVertexArrayIntegeri_vEXT(GLuint vaobj, GLuint index, GLenum pname, GLint * param)
{
return glbinding::Binding::GetVertexArrayIntegeri_vEXT(vaobj, index, pname, param);
}
inline void glGetVertexArrayIntegervEXT(GLuint vaobj, GLenum pname, GLint * param)
{
return glbinding::Binding::GetVertexArrayIntegervEXT(vaobj, pname, param);
}
inline void glGetVertexArrayPointeri_vEXT(GLuint vaobj, GLuint index, GLenum pname, void ** param)
{
return glbinding::Binding::GetVertexArrayPointeri_vEXT(vaobj, index, pname, param);
}
inline void glGetVertexArrayPointervEXT(GLuint vaobj, GLenum pname, void ** param)
{
return glbinding::Binding::GetVertexArrayPointervEXT(vaobj, pname, param);
}
inline void glGetVertexArrayiv(GLuint vaobj, GLenum pname, GLint * param)
{
return glbinding::Binding::GetVertexArrayiv(vaobj, pname, param);
}
inline void glGetVertexAttribArrayObjectfvATI(GLuint index, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetVertexAttribArrayObjectfvATI(index, pname, params);
}
inline void glGetVertexAttribArrayObjectivATI(GLuint index, GLenum pname, GLint * params)
{
return glbinding::Binding::GetVertexAttribArrayObjectivATI(index, pname, params);
}
inline void glGetVertexAttribIiv(GLuint index, GLenum pname, GLint * params)
{
return glbinding::Binding::GetVertexAttribIiv(index, pname, params);
}
inline void glGetVertexAttribIivEXT(GLuint index, GLenum pname, GLint * params)
{
return glbinding::Binding::GetVertexAttribIivEXT(index, pname, params);
}
inline void glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint * params)
{
return glbinding::Binding::GetVertexAttribIuiv(index, pname, params);
}
inline void glGetVertexAttribIuivEXT(GLuint index, GLenum pname, GLuint * params)
{
return glbinding::Binding::GetVertexAttribIuivEXT(index, pname, params);
}
inline void glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble * params)
{
return glbinding::Binding::GetVertexAttribLdv(index, pname, params);
}
inline void glGetVertexAttribLdvEXT(GLuint index, GLenum pname, GLdouble * params)
{
return glbinding::Binding::GetVertexAttribLdvEXT(index, pname, params);
}
inline void glGetVertexAttribLi64vNV(GLuint index, GLenum pname, GLint64EXT * params)
{
return glbinding::Binding::GetVertexAttribLi64vNV(index, pname, params);
}
inline void glGetVertexAttribLui64vARB(GLuint index, GLenum pname, GLuint64EXT * params)
{
return glbinding::Binding::GetVertexAttribLui64vARB(index, pname, params);
}
inline void glGetVertexAttribLui64vNV(GLuint index, GLenum pname, GLuint64EXT * params)
{
return glbinding::Binding::GetVertexAttribLui64vNV(index, pname, params);
}
inline void glGetVertexAttribPointerv(GLuint index, GLenum pname, void ** pointer)
{
return glbinding::Binding::GetVertexAttribPointerv(index, pname, pointer);
}
inline void glGetVertexAttribPointervARB(GLuint index, GLenum pname, void ** pointer)
{
return glbinding::Binding::GetVertexAttribPointervARB(index, pname, pointer);
}
inline void glGetVertexAttribPointervNV(GLuint index, GLenum pname, void ** pointer)
{
return glbinding::Binding::GetVertexAttribPointervNV(index, pname, pointer);
}
inline void glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble * params)
{
return glbinding::Binding::GetVertexAttribdv(index, pname, params);
}
inline void glGetVertexAttribdvARB(GLuint index, GLenum pname, GLdouble * params)
{
return glbinding::Binding::GetVertexAttribdvARB(index, pname, params);
}
inline void glGetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble * params)
{
return glbinding::Binding::GetVertexAttribdvNV(index, pname, params);
}
inline void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetVertexAttribfv(index, pname, params);
}
inline void glGetVertexAttribfvARB(GLuint index, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetVertexAttribfvARB(index, pname, params);
}
inline void glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetVertexAttribfvNV(index, pname, params);
}
inline void glGetVertexAttribiv(GLuint index, GLenum pname, GLint * params)
{
return glbinding::Binding::GetVertexAttribiv(index, pname, params);
}
inline void glGetVertexAttribivARB(GLuint index, GLenum pname, GLint * params)
{
return glbinding::Binding::GetVertexAttribivARB(index, pname, params);
}
inline void glGetVertexAttribivNV(GLuint index, GLenum pname, GLint * params)
{
return glbinding::Binding::GetVertexAttribivNV(index, pname, params);
}
inline void glGetVideoCaptureStreamdvNV(GLuint video_capture_slot, GLuint stream, GLenum pname, GLdouble * params)
{
return glbinding::Binding::GetVideoCaptureStreamdvNV(video_capture_slot, stream, pname, params);
}
inline void glGetVideoCaptureStreamfvNV(GLuint video_capture_slot, GLuint stream, GLenum pname, GLfloat * params)
{
return glbinding::Binding::GetVideoCaptureStreamfvNV(video_capture_slot, stream, pname, params);
}
inline void glGetVideoCaptureStreamivNV(GLuint video_capture_slot, GLuint stream, GLenum pname, GLint * params)
{
return glbinding::Binding::GetVideoCaptureStreamivNV(video_capture_slot, stream, pname, params);
}
inline void glGetVideoCaptureivNV(GLuint video_capture_slot, GLenum pname, GLint * params)
{
return glbinding::Binding::GetVideoCaptureivNV(video_capture_slot, pname, params);
}
inline void glGetVideoi64vNV(GLuint video_slot, GLenum pname, GLint64EXT * params)
{
return glbinding::Binding::GetVideoi64vNV(video_slot, pname, params);
}
inline void glGetVideoivNV(GLuint video_slot, GLenum pname, GLint * params)
{
return glbinding::Binding::GetVideoivNV(video_slot, pname, params);
}
inline void glGetVideoui64vNV(GLuint video_slot, GLenum pname, GLuint64EXT * params)
{
return glbinding::Binding::GetVideoui64vNV(video_slot, pname, params);
}
inline void glGetVideouivNV(GLuint video_slot, GLenum pname, GLuint * params)
{
return glbinding::Binding::GetVideouivNV(video_slot, pname, params);
}
inline void glGetnColorTable(GLenum target, GLenum format, GLenum type, GLsizei bufSize, void * table)
{
return glbinding::Binding::GetnColorTable(target, format, type, bufSize, table);
}
inline void glGetnColorTableARB(GLenum target, GLenum format, GLenum type, GLsizei bufSize, void * table)
{
return glbinding::Binding::GetnColorTableARB(target, format, type, bufSize, table);
}
inline void glGetnCompressedTexImage(GLenum target, GLint lod, GLsizei bufSize, void * pixels)
{
return glbinding::Binding::GetnCompressedTexImage(target, lod, bufSize, pixels);
}
inline void glGetnCompressedTexImageARB(GLenum target, GLint lod, GLsizei bufSize, void * img)
{
return glbinding::Binding::GetnCompressedTexImageARB(target, lod, bufSize, img);
}
inline void glGetnConvolutionFilter(GLenum target, GLenum format, GLenum type, GLsizei bufSize, void * image)
{
return glbinding::Binding::GetnConvolutionFilter(target, format, type, bufSize, image);
}
inline void glGetnConvolutionFilterARB(GLenum target, GLenum format, GLenum type, GLsizei bufSize, void * image)
{
return glbinding::Binding::GetnConvolutionFilterARB(target, format, type, bufSize, image);
}
inline void glGetnHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void * values)
{
return glbinding::Binding::GetnHistogram(target, reset, format, type, bufSize, values);
}
inline void glGetnHistogramARB(GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void * values)
{
return glbinding::Binding::GetnHistogramARB(target, reset, format, type, bufSize, values);
}
inline void glGetnMapdv(GLenum target, GLenum query, GLsizei bufSize, GLdouble * v)
{
return glbinding::Binding::GetnMapdv(target, query, bufSize, v);
}
inline void glGetnMapdvARB(GLenum target, GLenum query, GLsizei bufSize, GLdouble * v)
{
return glbinding::Binding::GetnMapdvARB(target, query, bufSize, v);
}
inline void glGetnMapfv(GLenum target, GLenum query, GLsizei bufSize, GLfloat * v)
{
return glbinding::Binding::GetnMapfv(target, query, bufSize, v);
}
inline void glGetnMapfvARB(GLenum target, GLenum query, GLsizei bufSize, GLfloat * v)
{
return glbinding::Binding::GetnMapfvARB(target, query, bufSize, v);
}
inline void glGetnMapiv(GLenum target, GLenum query, GLsizei bufSize, GLint * v)
{
return glbinding::Binding::GetnMapiv(target, query, bufSize, v);
}
inline void glGetnMapivARB(GLenum target, GLenum query, GLsizei bufSize, GLint * v)
{
return glbinding::Binding::GetnMapivARB(target, query, bufSize, v);
}
inline void glGetnMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void * values)
{
return glbinding::Binding::GetnMinmax(target, reset, format, type, bufSize, values);
}
inline void glGetnMinmaxARB(GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void * values)
{
return glbinding::Binding::GetnMinmaxARB(target, reset, format, type, bufSize, values);
}
inline void glGetnPixelMapfv(GLenum map, GLsizei bufSize, GLfloat * values)
{
return glbinding::Binding::GetnPixelMapfv(map, bufSize, values);
}
inline void glGetnPixelMapfvARB(GLenum map, GLsizei bufSize, GLfloat * values)
{
return glbinding::Binding::GetnPixelMapfvARB(map, bufSize, values);
}
inline void glGetnPixelMapuiv(GLenum map, GLsizei bufSize, GLuint * values)
{
return glbinding::Binding::GetnPixelMapuiv(map, bufSize, values);
}
inline void glGetnPixelMapuivARB(GLenum map, GLsizei bufSize, GLuint * values)
{
return glbinding::Binding::GetnPixelMapuivARB(map, bufSize, values);
}
inline void glGetnPixelMapusv(GLenum map, GLsizei bufSize, GLushort * values)
{
return glbinding::Binding::GetnPixelMapusv(map, bufSize, values);
}
inline void glGetnPixelMapusvARB(GLenum map, GLsizei bufSize, GLushort * values)
{
return glbinding::Binding::GetnPixelMapusvARB(map, bufSize, values);
}
inline void glGetnPolygonStipple(GLsizei bufSize, GLubyte * pattern)
{
return glbinding::Binding::GetnPolygonStipple(bufSize, pattern);
}
inline void glGetnPolygonStippleARB(GLsizei bufSize, GLubyte * pattern)
{
return glbinding::Binding::GetnPolygonStippleARB(bufSize, pattern);
}
inline void glGetnSeparableFilter(GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void * row, GLsizei columnBufSize, void * column, void * span)
{
return glbinding::Binding::GetnSeparableFilter(target, format, type, rowBufSize, row, columnBufSize, column, span);
}
inline void glGetnSeparableFilterARB(GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void * row, GLsizei columnBufSize, void * column, void * span)
{
return glbinding::Binding::GetnSeparableFilterARB(target, format, type, rowBufSize, row, columnBufSize, column, span);
}
inline void glGetnTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void * pixels)
{
return glbinding::Binding::GetnTexImage(target, level, format, type, bufSize, pixels);
}
inline void glGetnTexImageARB(GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void * img)
{
return glbinding::Binding::GetnTexImageARB(target, level, format, type, bufSize, img);
}
inline void glGetnUniformdv(GLuint program, GLint location, GLsizei bufSize, GLdouble * params)
{
return glbinding::Binding::GetnUniformdv(program, location, bufSize, params);
}
inline void glGetnUniformdvARB(GLuint program, GLint location, GLsizei bufSize, GLdouble * params)
{
return glbinding::Binding::GetnUniformdvARB(program, location, bufSize, params);
}
inline void glGetnUniformfv(GLuint program, GLint location, GLsizei bufSize, GLfloat * params)
{
return glbinding::Binding::GetnUniformfv(program, location, bufSize, params);
}
inline void glGetnUniformfvARB(GLuint program, GLint location, GLsizei bufSize, GLfloat * params)
{
return glbinding::Binding::GetnUniformfvARB(program, location, bufSize, params);
}
inline void glGetnUniformiv(GLuint program, GLint location, GLsizei bufSize, GLint * params)
{
return glbinding::Binding::GetnUniformiv(program, location, bufSize, params);
}
inline void glGetnUniformivARB(GLuint program, GLint location, GLsizei bufSize, GLint * params)
{
return glbinding::Binding::GetnUniformivARB(program, location, bufSize, params);
}
inline void glGetnUniformuiv(GLuint program, GLint location, GLsizei bufSize, GLuint * params)
{
return glbinding::Binding::GetnUniformuiv(program, location, bufSize, params);
}
inline void glGetnUniformuivARB(GLuint program, GLint location, GLsizei bufSize, GLuint * params)
{
return glbinding::Binding::GetnUniformuivARB(program, location, bufSize, params);
}
inline void glGlobalAlphaFactorbSUN(GLbyte factor)
{
return glbinding::Binding::GlobalAlphaFactorbSUN(factor);
}
inline void glGlobalAlphaFactordSUN(GLdouble factor)
{
return glbinding::Binding::GlobalAlphaFactordSUN(factor);
}
inline void glGlobalAlphaFactorfSUN(GLfloat factor)
{
return glbinding::Binding::GlobalAlphaFactorfSUN(factor);
}
inline void glGlobalAlphaFactoriSUN(GLint factor)
{
return glbinding::Binding::GlobalAlphaFactoriSUN(factor);
}
inline void glGlobalAlphaFactorsSUN(GLshort factor)
{
return glbinding::Binding::GlobalAlphaFactorsSUN(factor);
}
inline void glGlobalAlphaFactorubSUN(GLubyte factor)
{
return glbinding::Binding::GlobalAlphaFactorubSUN(factor);
}
inline void glGlobalAlphaFactoruiSUN(GLuint factor)
{
return glbinding::Binding::GlobalAlphaFactoruiSUN(factor);
}
inline void glGlobalAlphaFactorusSUN(GLushort factor)
{
return glbinding::Binding::GlobalAlphaFactorusSUN(factor);
}
inline void glHintPGI(GLenum target, GLint mode)
{
return glbinding::Binding::HintPGI(target, mode);
}
inline void glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
{
return glbinding::Binding::Histogram(target, width, internalformat, sink);
}
inline void glHistogramEXT(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
{
return glbinding::Binding::HistogramEXT(target, width, internalformat, sink);
}
inline void glIglooInterfaceSGIX(GLenum pname, const void * params)
{
return glbinding::Binding::IglooInterfaceSGIX(pname, params);
}
inline void glImageTransformParameterfHP(GLenum target, GLenum pname, GLfloat param)
{
return glbinding::Binding::ImageTransformParameterfHP(target, pname, param);
}
inline void glImageTransformParameterfvHP(GLenum target, GLenum pname, const GLfloat * params)
{
return glbinding::Binding::ImageTransformParameterfvHP(target, pname, params);
}
inline void glImageTransformParameteriHP(GLenum target, GLenum pname, GLint param)
{
return glbinding::Binding::ImageTransformParameteriHP(target, pname, param);
}
inline void glImageTransformParameterivHP(GLenum target, GLenum pname, const GLint * params)
{
return glbinding::Binding::ImageTransformParameterivHP(target, pname, params);
}
inline GLsync glImportSyncEXT(GLenum external_sync_type, GLintptr external_sync, UnusedMask flags)
{
return glbinding::Binding::ImportSyncEXT(external_sync_type, external_sync, flags);
}
inline void glIndexFormatNV(GLenum type, GLsizei stride)
{
return glbinding::Binding::IndexFormatNV(type, stride);
}
inline void glIndexFuncEXT(GLenum func, GLclampf ref)
{
return glbinding::Binding::IndexFuncEXT(func, ref);
}
inline void glIndexMaterialEXT(GLenum face, GLenum mode)
{
return glbinding::Binding::IndexMaterialEXT(face, mode);
}
inline void glIndexPointerEXT(GLenum type, GLsizei stride, GLsizei count, const void * pointer)
{
return glbinding::Binding::IndexPointerEXT(type, stride, count, pointer);
}
inline void glIndexPointerListIBM(GLenum type, GLint stride, const void ** pointer, GLint ptrstride)
{
return glbinding::Binding::IndexPointerListIBM(type, stride, pointer, ptrstride);
}
inline void glIndexxOES(GLfixed component)
{
return glbinding::Binding::IndexxOES(component);
}
inline void glIndexxvOES(const GLfixed * component)
{
return glbinding::Binding::IndexxvOES(component);
}
inline void glInsertComponentEXT(GLuint res, GLuint src, GLuint num)
{
return glbinding::Binding::InsertComponentEXT(res, src, num);
}
inline void glInsertEventMarkerEXT(GLsizei length, const GLchar * marker)
{
return glbinding::Binding::InsertEventMarkerEXT(length, marker);
}
inline void glInstrumentsBufferSGIX(GLsizei size, GLint * buffer)
{
return glbinding::Binding::InstrumentsBufferSGIX(size, buffer);
}
inline void glInterpolatePathsNV(GLuint resultPath, GLuint pathA, GLuint pathB, GLfloat weight)
{
return glbinding::Binding::InterpolatePathsNV(resultPath, pathA, pathB, weight);
}
inline void glInvalidateBufferData(GLuint buffer)
{
return glbinding::Binding::InvalidateBufferData(buffer);
}
inline void glInvalidateBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr length)
{
return glbinding::Binding::InvalidateBufferSubData(buffer, offset, length);
}
inline void glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum * attachments)
{
return glbinding::Binding::InvalidateFramebuffer(target, numAttachments, attachments);
}
inline void glInvalidateNamedFramebufferData(GLuint framebuffer, GLsizei numAttachments, const GLenum * attachments)
{
return glbinding::Binding::InvalidateNamedFramebufferData(framebuffer, numAttachments, attachments);
}
inline void glInvalidateNamedFramebufferSubData(GLuint framebuffer, GLsizei numAttachments, const GLenum * attachments, GLint x, GLint y, GLsizei width, GLsizei height)
{
return glbinding::Binding::InvalidateNamedFramebufferSubData(framebuffer, numAttachments, attachments, x, y, width, height);
}
inline void glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum * attachments, GLint x, GLint y, GLsizei width, GLsizei height)
{
return glbinding::Binding::InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
}
inline void glInvalidateTexImage(GLuint texture, GLint level)
{
return glbinding::Binding::InvalidateTexImage(texture, level);
}
inline void glInvalidateTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth)
{
return glbinding::Binding::InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
}
inline GLboolean glIsAsyncMarkerSGIX(GLuint marker)
{
return glbinding::Binding::IsAsyncMarkerSGIX(marker);
}
inline GLboolean glIsBuffer(GLuint buffer)
{
return glbinding::Binding::IsBuffer(buffer);
}
inline GLboolean glIsBufferARB(GLuint buffer)
{
return glbinding::Binding::IsBufferARB(buffer);
}
inline GLboolean glIsBufferResidentNV(GLenum target)
{
return glbinding::Binding::IsBufferResidentNV(target);
}
inline GLboolean glIsEnabledIndexedEXT(GLenum target, GLuint index)
{
return glbinding::Binding::IsEnabledIndexedEXT(target, index);
}
inline GLboolean glIsEnabledi(GLenum target, GLuint index)
{
return glbinding::Binding::IsEnabledi(target, index);
}
inline GLboolean glIsFenceAPPLE(GLuint fence)
{
return glbinding::Binding::IsFenceAPPLE(fence);
}
inline GLboolean glIsFenceNV(GLuint fence)
{
return glbinding::Binding::IsFenceNV(fence);
}
inline GLboolean glIsFramebuffer(GLuint framebuffer)
{
return glbinding::Binding::IsFramebuffer(framebuffer);
}
inline GLboolean glIsFramebufferEXT(GLuint framebuffer)
{
return glbinding::Binding::IsFramebufferEXT(framebuffer);
}
inline GLboolean glIsImageHandleResidentARB(GLuint64 handle)
{
return glbinding::Binding::IsImageHandleResidentARB(handle);
}
inline GLboolean glIsImageHandleResidentNV(GLuint64 handle)
{
return glbinding::Binding::IsImageHandleResidentNV(handle);
}
inline GLboolean glIsNameAMD(GLenum identifier, GLuint name)
{
return glbinding::Binding::IsNameAMD(identifier, name);
}
inline GLboolean glIsNamedBufferResidentNV(GLuint buffer)
{
return glbinding::Binding::IsNamedBufferResidentNV(buffer);
}
inline GLboolean glIsNamedStringARB(GLint namelen, const GLchar * name)
{
return glbinding::Binding::IsNamedStringARB(namelen, name);
}
inline GLboolean glIsObjectBufferATI(GLuint buffer)
{
return glbinding::Binding::IsObjectBufferATI(buffer);
}
inline GLboolean glIsOcclusionQueryNV(GLuint id)
{
return glbinding::Binding::IsOcclusionQueryNV(id);
}
inline GLboolean glIsPathNV(GLuint path)
{
return glbinding::Binding::IsPathNV(path);
}
inline GLboolean glIsPointInFillPathNV(GLuint path, GLuint mask, GLfloat x, GLfloat y)
{
return glbinding::Binding::IsPointInFillPathNV(path, mask, x, y);
}
inline GLboolean glIsPointInStrokePathNV(GLuint path, GLfloat x, GLfloat y)
{
return glbinding::Binding::IsPointInStrokePathNV(path, x, y);
}
inline GLboolean glIsProgram(GLuint program)
{
return glbinding::Binding::IsProgram(program);
}
inline GLboolean glIsProgramARB(GLuint program)
{
return glbinding::Binding::IsProgramARB(program);
}
inline GLboolean glIsProgramNV(GLuint id)
{
return glbinding::Binding::IsProgramNV(id);
}
inline GLboolean glIsProgramPipeline(GLuint pipeline)
{
return glbinding::Binding::IsProgramPipeline(pipeline);
}
inline GLboolean glIsQuery(GLuint id)
{
return glbinding::Binding::IsQuery(id);
}
inline GLboolean glIsQueryARB(GLuint id)
{
return glbinding::Binding::IsQueryARB(id);
}
inline GLboolean glIsRenderbuffer(GLuint renderbuffer)
{
return glbinding::Binding::IsRenderbuffer(renderbuffer);
}
inline GLboolean glIsRenderbufferEXT(GLuint renderbuffer)
{
return glbinding::Binding::IsRenderbufferEXT(renderbuffer);
}
inline GLboolean glIsSampler(GLuint sampler)
{
return glbinding::Binding::IsSampler(sampler);
}
inline GLboolean glIsShader(GLuint shader)
{
return glbinding::Binding::IsShader(shader);
}
inline GLboolean glIsSync(GLsync sync)
{
return glbinding::Binding::IsSync(sync);
}
inline GLboolean glIsTextureEXT(GLuint texture)
{
return glbinding::Binding::IsTextureEXT(texture);
}
inline GLboolean glIsTextureHandleResidentARB(GLuint64 handle)
{
return glbinding::Binding::IsTextureHandleResidentARB(handle);
}
inline GLboolean glIsTextureHandleResidentNV(GLuint64 handle)
{
return glbinding::Binding::IsTextureHandleResidentNV(handle);
}
inline GLboolean glIsTransformFeedback(GLuint id)
{
return glbinding::Binding::IsTransformFeedback(id);
}
inline GLboolean glIsTransformFeedbackNV(GLuint id)
{
return glbinding::Binding::IsTransformFeedbackNV(id);
}
inline GLboolean glIsVariantEnabledEXT(GLuint id, GLenum cap)
{
return glbinding::Binding::IsVariantEnabledEXT(id, cap);
}
inline GLboolean glIsVertexArray(GLuint array)
{
return glbinding::Binding::IsVertexArray(array);
}
inline GLboolean glIsVertexArrayAPPLE(GLuint array)
{
return glbinding::Binding::IsVertexArrayAPPLE(array);
}
inline GLboolean glIsVertexAttribEnabledAPPLE(GLuint index, GLenum pname)
{
return glbinding::Binding::IsVertexAttribEnabledAPPLE(index, pname);
}
inline void glLabelObjectEXT(GLenum type, GLuint object, GLsizei length, const GLchar * label)
{
return glbinding::Binding::LabelObjectEXT(type, object, length, label);
}
inline void glLightEnviSGIX(GLenum pname, GLint param)
{
return glbinding::Binding::LightEnviSGIX(pname, param);
}
inline void glLightModelxOES(GLenum pname, GLfixed param)
{
return glbinding::Binding::LightModelxOES(pname, param);
}
inline void glLightModelxvOES(GLenum pname, const GLfixed * param)
{
return glbinding::Binding::LightModelxvOES(pname, param);
}
inline void glLightxOES(GLenum light, GLenum pname, GLfixed param)
{
return glbinding::Binding::LightxOES(light, pname, param);
}
inline void glLightxvOES(GLenum light, GLenum pname, const GLfixed * params)
{
return glbinding::Binding::LightxvOES(light, pname, params);
}
inline void glLineWidthxOES(GLfixed width)
{
return glbinding::Binding::LineWidthxOES(width);
}
inline void glLinkProgram(GLuint program)
{
return glbinding::Binding::LinkProgram(program);
}
inline void glLinkProgramARB(GLhandleARB programObj)
{
return glbinding::Binding::LinkProgramARB(programObj);
}
inline void glListParameterfSGIX(GLuint list, GLenum pname, GLfloat param)
{
return glbinding::Binding::ListParameterfSGIX(list, pname, param);
}
inline void glListParameterfvSGIX(GLuint list, GLenum pname, const GLfloat * params)
{
return glbinding::Binding::ListParameterfvSGIX(list, pname, params);
}
inline void glListParameteriSGIX(GLuint list, GLenum pname, GLint param)
{
return glbinding::Binding::ListParameteriSGIX(list, pname, param);
}
inline void glListParameterivSGIX(GLuint list, GLenum pname, const GLint * params)
{
return glbinding::Binding::ListParameterivSGIX(list, pname, params);
}
inline void glLoadIdentityDeformationMapSGIX(FfdMaskSGIX mask)
{
return glbinding::Binding::LoadIdentityDeformationMapSGIX(mask);
}
inline void glLoadMatrixxOES(const GLfixed * m)
{
return glbinding::Binding::LoadMatrixxOES(m);
}
inline void glLoadProgramNV(GLenum target, GLuint id, GLsizei len, const GLubyte * program)
{
return glbinding::Binding::LoadProgramNV(target, id, len, program);
}
inline void glLoadTransposeMatrixdARB(const GLdouble * m)
{
return glbinding::Binding::LoadTransposeMatrixdARB(m);
}
inline void glLoadTransposeMatrixfARB(const GLfloat * m)
{
return glbinding::Binding::LoadTransposeMatrixfARB(m);
}
inline void glLoadTransposeMatrixxOES(const GLfixed * m)
{
return glbinding::Binding::LoadTransposeMatrixxOES(m);
}
inline void glLockArraysEXT(GLint first, GLsizei count)
{
return glbinding::Binding::LockArraysEXT(first, count);
}
inline void glMakeBufferNonResidentNV(GLenum target)
{
return glbinding::Binding::MakeBufferNonResidentNV(target);
}
inline void glMakeBufferResidentNV(GLenum target, GLenum access)
{
return glbinding::Binding::MakeBufferResidentNV(target, access);
}
inline void glMakeImageHandleNonResidentARB(GLuint64 handle)
{
return glbinding::Binding::MakeImageHandleNonResidentARB(handle);
}
inline void glMakeImageHandleNonResidentNV(GLuint64 handle)
{
return glbinding::Binding::MakeImageHandleNonResidentNV(handle);
}
inline void glMakeImageHandleResidentARB(GLuint64 handle, GLenum access)
{
return glbinding::Binding::MakeImageHandleResidentARB(handle, access);
}
inline void glMakeImageHandleResidentNV(GLuint64 handle, GLenum access)
{
return glbinding::Binding::MakeImageHandleResidentNV(handle, access);
}
inline void glMakeNamedBufferNonResidentNV(GLuint buffer)
{
return glbinding::Binding::MakeNamedBufferNonResidentNV(buffer);
}
inline void glMakeNamedBufferResidentNV(GLuint buffer, GLenum access)
{
return glbinding::Binding::MakeNamedBufferResidentNV(buffer, access);
}
inline void glMakeTextureHandleNonResidentARB(GLuint64 handle)
{
return glbinding::Binding::MakeTextureHandleNonResidentARB(handle);
}
inline void glMakeTextureHandleNonResidentNV(GLuint64 handle)
{
return glbinding::Binding::MakeTextureHandleNonResidentNV(handle);
}
inline void glMakeTextureHandleResidentARB(GLuint64 handle)
{
return glbinding::Binding::MakeTextureHandleResidentARB(handle);
}
inline void glMakeTextureHandleResidentNV(GLuint64 handle)
{
return glbinding::Binding::MakeTextureHandleResidentNV(handle);
}
inline void glMap1xOES(GLenum target, GLfixed u1, GLfixed u2, GLint stride, GLint order, GLfixed points)
{
return glbinding::Binding::Map1xOES(target, u1, u2, stride, order, points);
}
inline void glMap2xOES(GLenum target, GLfixed u1, GLfixed u2, GLint ustride, GLint uorder, GLfixed v1, GLfixed v2, GLint vstride, GLint vorder, GLfixed points)
{
return glbinding::Binding::Map2xOES(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
}
inline void * glMapBuffer(GLenum target, GLenum access)
{
return glbinding::Binding::MapBuffer(target, access);
}
inline void * glMapBufferARB(GLenum target, GLenum access)
{
return glbinding::Binding::MapBufferARB(target, access);
}
inline void * glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, BufferAccessMask access)
{
return glbinding::Binding::MapBufferRange(target, offset, length, access);
}
inline void glMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const void * points)
{
return glbinding::Binding::MapControlPointsNV(target, index, type, ustride, vstride, uorder, vorder, packed, points);
}
inline void glMapGrid1xOES(GLint n, GLfixed u1, GLfixed u2)
{
return glbinding::Binding::MapGrid1xOES(n, u1, u2);
}
inline void glMapGrid2xOES(GLint n, GLfixed u1, GLfixed u2, GLfixed v1, GLfixed v2)
{
return glbinding::Binding::MapGrid2xOES(n, u1, u2, v1, v2);
}
inline void * glMapNamedBuffer(GLuint buffer, GLenum access)
{
return glbinding::Binding::MapNamedBuffer(buffer, access);
}
inline void * glMapNamedBufferEXT(GLuint buffer, GLenum access)
{
return glbinding::Binding::MapNamedBufferEXT(buffer, access);
}
inline void * glMapNamedBufferRange(GLuint buffer, GLintptr offset, GLsizeiptr length, BufferAccessMask access)
{
return glbinding::Binding::MapNamedBufferRange(buffer, offset, length, access);
}
inline void * glMapNamedBufferRangeEXT(GLuint buffer, GLintptr offset, GLsizeiptr length, BufferAccessMask access)
{
return glbinding::Binding::MapNamedBufferRangeEXT(buffer, offset, length, access);
}
inline void * glMapObjectBufferATI(GLuint buffer)
{
return glbinding::Binding::MapObjectBufferATI(buffer);
}
inline void glMapParameterfvNV(GLenum target, GLenum pname, const GLfloat * params)
{
return glbinding::Binding::MapParameterfvNV(target, pname, params);
}
inline void glMapParameterivNV(GLenum target, GLenum pname, const GLint * params)
{
return glbinding::Binding::MapParameterivNV(target, pname, params);
}
inline void * glMapTexture2DINTEL(GLuint texture, GLint level, MapBufferUsageMask access, GLint * stride, GLenum * layout)
{
return glbinding::Binding::MapTexture2DINTEL(texture, level, access, stride, layout);
}
inline void glMapVertexAttrib1dAPPLE(GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble * points)
{
return glbinding::Binding::MapVertexAttrib1dAPPLE(index, size, u1, u2, stride, order, points);
}
inline void glMapVertexAttrib1fAPPLE(GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat * points)
{
return glbinding::Binding::MapVertexAttrib1fAPPLE(index, size, u1, u2, stride, order, points);
}
inline void glMapVertexAttrib2dAPPLE(GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble * points)
{
return glbinding::Binding::MapVertexAttrib2dAPPLE(index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
}
inline void glMapVertexAttrib2fAPPLE(GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat * points)
{
return glbinding::Binding::MapVertexAttrib2fAPPLE(index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
}
inline void glMaterialxOES(GLenum face, GLenum pname, GLfixed param)
{
return glbinding::Binding::MaterialxOES(face, pname, param);
}
inline void glMaterialxvOES(GLenum face, GLenum pname, const GLfixed * param)
{
return glbinding::Binding::MaterialxvOES(face, pname, param);
}
inline void glMatrixFrustumEXT(GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
{
return glbinding::Binding::MatrixFrustumEXT(mode, left, right, bottom, top, zNear, zFar);
}
inline void glMatrixIndexPointerARB(GLint size, GLenum type, GLsizei stride, const void * pointer)
{
return glbinding::Binding::MatrixIndexPointerARB(size, type, stride, pointer);
}
inline void glMatrixIndexubvARB(GLint size, const GLubyte * indices)
{
return glbinding::Binding::MatrixIndexubvARB(size, indices);
}
inline void glMatrixIndexuivARB(GLint size, const GLuint * indices)
{
return glbinding::Binding::MatrixIndexuivARB(size, indices);
}
inline void glMatrixIndexusvARB(GLint size, const GLushort * indices)
{
return glbinding::Binding::MatrixIndexusvARB(size, indices);
}
inline void glMatrixLoad3x2fNV(GLenum matrixMode, const GLfloat * m)
{
return glbinding::Binding::MatrixLoad3x2fNV(matrixMode, m);
}
inline void glMatrixLoad3x3fNV(GLenum matrixMode, const GLfloat * m)
{
return glbinding::Binding::MatrixLoad3x3fNV(matrixMode, m);
}
inline void glMatrixLoadIdentityEXT(GLenum mode)
{
return glbinding::Binding::MatrixLoadIdentityEXT(mode);
}
inline void glMatrixLoadTranspose3x3fNV(GLenum matrixMode, const GLfloat * m)
{
return glbinding::Binding::MatrixLoadTranspose3x3fNV(matrixMode, m);
}
inline void glMatrixLoadTransposedEXT(GLenum mode, const GLdouble * m)
{
return glbinding::Binding::MatrixLoadTransposedEXT(mode, m);
}
inline void glMatrixLoadTransposefEXT(GLenum mode, const GLfloat * m)
{
return glbinding::Binding::MatrixLoadTransposefEXT(mode, m);
}
inline void glMatrixLoaddEXT(GLenum mode, const GLdouble * m)
{
return glbinding::Binding::MatrixLoaddEXT(mode, m);
}
inline void glMatrixLoadfEXT(GLenum mode, const GLfloat * m)
{
return glbinding::Binding::MatrixLoadfEXT(mode, m);
}
inline void glMatrixMult3x2fNV(GLenum matrixMode, const GLfloat * m)
{
return glbinding::Binding::MatrixMult3x2fNV(matrixMode, m);
}
inline void glMatrixMult3x3fNV(GLenum matrixMode, const GLfloat * m)
{
return glbinding::Binding::MatrixMult3x3fNV(matrixMode, m);
}
inline void glMatrixMultTranspose3x3fNV(GLenum matrixMode, const GLfloat * m)
{
return glbinding::Binding::MatrixMultTranspose3x3fNV(matrixMode, m);
}
inline void glMatrixMultTransposedEXT(GLenum mode, const GLdouble * m)
{
return glbinding::Binding::MatrixMultTransposedEXT(mode, m);
}
inline void glMatrixMultTransposefEXT(GLenum mode, const GLfloat * m)
{
return glbinding::Binding::MatrixMultTransposefEXT(mode, m);
}
inline void glMatrixMultdEXT(GLenum mode, const GLdouble * m)
{
return glbinding::Binding::MatrixMultdEXT(mode, m);
}
inline void glMatrixMultfEXT(GLenum mode, const GLfloat * m)
{
return glbinding::Binding::MatrixMultfEXT(mode, m);
}
inline void glMatrixOrthoEXT(GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
{
return glbinding::Binding::MatrixOrthoEXT(mode, left, right, bottom, top, zNear, zFar);
}
inline void glMatrixPopEXT(GLenum mode)
{
return glbinding::Binding::MatrixPopEXT(mode);
}
inline void glMatrixPushEXT(GLenum mode)
{
return glbinding::Binding::MatrixPushEXT(mode);
}
inline void glMatrixRotatedEXT(GLenum mode, GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
{
return glbinding::Binding::MatrixRotatedEXT(mode, angle, x, y, z);
}
inline void glMatrixRotatefEXT(GLenum mode, GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
{
return glbinding::Binding::MatrixRotatefEXT(mode, angle, x, y, z);
}
inline void glMatrixScaledEXT(GLenum mode, GLdouble x, GLdouble y, GLdouble z)
{
return glbinding::Binding::MatrixScaledEXT(mode, x, y, z);
}
inline void glMatrixScalefEXT(GLenum mode, GLfloat x, GLfloat y, GLfloat z)
{
return glbinding::Binding::MatrixScalefEXT(mode, x, y, z);
}
inline void glMatrixTranslatedEXT(GLenum mode, GLdouble x, GLdouble y, GLdouble z)
{
return glbinding::Binding::MatrixTranslatedEXT(mode, x, y, z);
}
inline void glMatrixTranslatefEXT(GLenum mode, GLfloat x, GLfloat y, GLfloat z)
{
return glbinding::Binding::MatrixTranslatefEXT(mode, x, y, z);
}
inline void glMemoryBarrier(MemoryBarrierMask barriers)
{
return glbinding::Binding::MemoryBarrier(barriers);
}
inline void glMemoryBarrierByRegion(MemoryBarrierMask barriers)
{
return glbinding::Binding::MemoryBarrierByRegion(barriers);
}
inline void glMemoryBarrierEXT(MemoryBarrierMask barriers)
{
return glbinding::Binding::MemoryBarrierEXT(barriers);
}
inline void glMinSampleShading(GLfloat value)
{
return glbinding::Binding::MinSampleShading(value);
}
inline void glMinSampleShadingARB(GLfloat value)
{
return glbinding::Binding::MinSampleShadingARB(value);
}
inline void glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
{
return glbinding::Binding::Minmax(target, internalformat, sink);
}
inline void glMinmaxEXT(GLenum target, GLenum internalformat, GLboolean sink)
{
return glbinding::Binding::MinmaxEXT(target, internalformat, sink);
}
inline void glMultMatrixxOES(const GLfixed * m)
{
return glbinding::Binding::MultMatrixxOES(m);
}
inline void glMultTransposeMatrixdARB(const GLdouble * m)
{
return glbinding::Binding::MultTransposeMatrixdARB(m);
}
inline void glMultTransposeMatrixfARB(const GLfloat * m)
{
return glbinding::Binding::MultTransposeMatrixfARB(m);
}
inline void glMultTransposeMatrixxOES(const GLfixed * m)
{
return glbinding::Binding::MultTransposeMatrixxOES(m);
}
inline void glMultiDrawArraysEXT(GLenum mode, const GLint * first, const GLsizei * count, GLsizei primcount)
{
return glbinding::Binding::MultiDrawArraysEXT(mode, first, count, primcount);
}
inline void glMultiDrawArraysIndirect(GLenum mode, const void * indirect, GLsizei drawcount, GLsizei stride)
{
return glbinding::Binding::MultiDrawArraysIndirect(mode, indirect, drawcount, stride);
}
inline void glMultiDrawArraysIndirectAMD(GLenum mode, const void * indirect, GLsizei primcount, GLsizei stride)
{
return glbinding::Binding::MultiDrawArraysIndirectAMD(mode, indirect, primcount, stride);
}
inline void glMultiDrawArraysIndirectBindlessCountNV(GLenum mode, const void * indirect, GLsizei drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount)
{
return glbinding::Binding::MultiDrawArraysIndirectBindlessCountNV(mode, indirect, drawCount, maxDrawCount, stride, vertexBufferCount);
}
inline void glMultiDrawArraysIndirectBindlessNV(GLenum mode, const void * indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount)
{
return glbinding::Binding::MultiDrawArraysIndirectBindlessNV(mode, indirect, drawCount, stride, vertexBufferCount);
}
inline void glMultiDrawArraysIndirectCountARB(GLenum mode, GLintptr indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride)
{
return glbinding::Binding::MultiDrawArraysIndirectCountARB(mode, indirect, drawcount, maxdrawcount, stride);
}
inline void glMultiDrawElementArrayAPPLE(GLenum mode, const GLint * first, const GLsizei * count, GLsizei primcount)
{
return glbinding::Binding::MultiDrawElementArrayAPPLE(mode, first, count, primcount);
}
inline void glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount, const GLint * basevertex)
{
return glbinding::Binding::MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
}
inline void glMultiDrawElementsEXT(GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei primcount)
{
return glbinding::Binding::MultiDrawElementsEXT(mode, count, type, indices, primcount);
}
inline void glMultiDrawElementsIndirect(GLenum mode, GLenum type, const void * indirect, GLsizei drawcount, GLsizei stride)
{
return glbinding::Binding::MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
}
inline void glMultiDrawElementsIndirectAMD(GLenum mode, GLenum type, const void * indirect, GLsizei primcount, GLsizei stride)
{
return glbinding::Binding::MultiDrawElementsIndirectAMD(mode, type, indirect, primcount, stride);
}
inline void glMultiDrawElementsIndirectBindlessCountNV(GLenum mode, GLenum type, const void * indirect, GLsizei drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount)
{
return glbinding::Binding::MultiDrawElementsIndirectBindlessCountNV(mode, type, indirect, drawCount, maxDrawCount, stride, vertexBufferCount);
}
inline void glMultiDrawElementsIndirectBindlessNV(GLenum mode, GLenum type, const void * indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount)
{
return glbinding::Binding::MultiDrawElementsIndirectBindlessNV(mode, type, indirect, drawCount, stride, vertexBufferCount);
}
inline void glMultiDrawElementsIndirectCountARB(GLenum mode, GLenum type, GLintptr indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride)
{
return glbinding::Binding::MultiDrawElementsIndirectCountARB(mode, type, indirect, drawcount, maxdrawcount, stride);
}
inline void glMultiDrawRangeElementArrayAPPLE(GLenum mode, GLuint start, GLuint end, const GLint * first, const GLsizei * count, GLsizei primcount)
{
return glbinding::Binding::MultiDrawRangeElementArrayAPPLE(mode, start, end, first, count, primcount);
}
inline void glMultiModeDrawArraysIBM(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride)
{
return glbinding::Binding::MultiModeDrawArraysIBM(mode, first, count, primcount, modestride);
}
inline void glMultiModeDrawElementsIBM(const GLenum * mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei primcount, GLint modestride)
{
return glbinding::Binding::MultiModeDrawElementsIBM(mode, count, type, indices, primcount, modestride);
}
inline void glMultiTexBufferEXT(GLenum texunit, GLenum target, GLenum internalformat, GLuint buffer)
{
return glbinding::Binding::MultiTexBufferEXT(texunit, target, internalformat, buffer);
}
inline void glMultiTexCoord1bOES(GLenum texture, GLbyte s)
{
return glbinding::Binding::MultiTexCoord1bOES(texture, s);
}
inline void glMultiTexCoord1bvOES(GLenum texture, const GLbyte * coords)
{
return glbinding::Binding::MultiTexCoord1bvOES(texture, coords);
}
inline void glMultiTexCoord1dARB(GLenum target, GLdouble s)
{
return glbinding::Binding::MultiTexCoord1dARB(target, s);
}
inline void glMultiTexCoord1dvARB(GLenum target, const GLdouble * v)
{
return glbinding::Binding::MultiTexCoord1dvARB(target, v);
}
inline void glMultiTexCoord1fARB(GLenum target, GLfloat s)
{
return glbinding::Binding::MultiTexCoord1fARB(target, s);
}
inline void glMultiTexCoord1fvARB(GLenum target, const GLfloat * v)
{
return glbinding::Binding::MultiTexCoord1fvARB(target, v);
}
inline void glMultiTexCoord1hNV(GLenum target, GLhalfNV s)
{
return glbinding::Binding::MultiTexCoord1hNV(target, s);
}
inline void glMultiTexCoord1hvNV(GLenum target, const GLhalfNV * v)
{
return glbinding::Binding::MultiTexCoord1hvNV(target, v);
}
inline void glMultiTexCoord1iARB(GLenum target, GLint s)
{
return glbinding::Binding::MultiTexCoord1iARB(target, s);
}
inline void glMultiTexCoord1ivARB(GLenum target, const GLint * v)
{
return glbinding::Binding::MultiTexCoord1ivARB(target, v);
}
inline void glMultiTexCoord1sARB(GLenum target, GLshort s)
{
return glbinding::Binding::MultiTexCoord1sARB(target, s);
}
inline void glMultiTexCoord1svARB(GLenum target, const GLshort * v)
{
return glbinding::Binding::MultiTexCoord1svARB(target, v);
}
inline void glMultiTexCoord1xOES(GLenum texture, GLfixed s)
{
return glbinding::Binding::MultiTexCoord1xOES(texture, s);
}
inline void glMultiTexCoord1xvOES(GLenum texture, const GLfixed * coords)
{
return glbinding::Binding::MultiTexCoord1xvOES(texture, coords);
}
inline void glMultiTexCoord2bOES(GLenum texture, GLbyte s, GLbyte t)
{
return glbinding::Binding::MultiTexCoord2bOES(texture, s, t);
}
inline void glMultiTexCoord2bvOES(GLenum texture, const GLbyte * coords)
{
return glbinding::Binding::MultiTexCoord2bvOES(texture, coords);
}
inline void glMultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t)
{
return glbinding::Binding::MultiTexCoord2dARB(target, s, t);
}
inline void glMultiTexCoord2dvARB(GLenum target, const GLdouble * v)
{
return glbinding::Binding::MultiTexCoord2dvARB(target, v);
}
inline void glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t)
{
return glbinding::Binding::MultiTexCoord2fARB(target, s, t);
}
inline void glMultiTexCoord2fvARB(GLenum target, const GLfloat * v)
{
return glbinding::Binding::MultiTexCoord2fvARB(target, v);
}
inline void glMultiTexCoord2hNV(GLenum target, GLhalfNV s, GLhalfNV t)
{
return glbinding::Binding::MultiTexCoord2hNV(target, s, t);
}
inline void glMultiTexCoord2hvNV(GLenum target, const GLhalfNV * v)
{
return glbinding::Binding::MultiTexCoord2hvNV(target, v);
}
inline void glMultiTexCoord2iARB(GLenum target, GLint s, GLint t)
{
return glbinding::Binding::MultiTexCoord2iARB(target, s, t);
}
inline void glMultiTexCoord2ivARB(GLenum target, const GLint * v)
{
return glbinding::Binding::MultiTexCoord2ivARB(target, v);
}
inline void glMultiTexCoord2sARB(GLenum target, GLshort s, GLshort t)
{
return glbinding::Binding::MultiTexCoord2sARB(target, s, t);
}
inline void glMultiTexCoord2svARB(GLenum target, const GLshort * v)
{
return glbinding::Binding::MultiTexCoord2svARB(target, v);
}
inline void glMultiTexCoord2xOES(GLenum texture, GLfixed s, GLfixed t)
{
return glbinding::Binding::MultiTexCoord2xOES(texture, s, t);
}
inline void glMultiTexCoord2xvOES(GLenum texture, const GLfixed * coords)
{
return glbinding::Binding::MultiTexCoord2xvOES(texture, coords);
}
inline void glMultiTexCoord3bOES(GLenum texture, GLbyte s, GLbyte t, GLbyte r)
{
return glbinding::Binding::MultiTexCoord3bOES(texture, s, t, r);
}
inline void glMultiTexCoord3bvOES(GLenum texture, const GLbyte * coords)
{
return glbinding::Binding::MultiTexCoord3bvOES(texture, coords);
}
inline void glMultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r)
{
return glbinding::Binding::MultiTexCoord3dARB(target, s, t, r);
}
inline void glMultiTexCoord3dvARB(GLenum target, const GLdouble * v)
{
return glbinding::Binding::MultiTexCoord3dvARB(target, v);
}
inline void glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r)
{
return glbinding::Binding::MultiTexCoord3fARB(target, s, t, r);
}
inline void glMultiTexCoord3fvARB(GLenum target, const GLfloat * v)
{
return glbinding::Binding::MultiTexCoord3fvARB(target, v);
}
inline void glMultiTexCoord3hNV(GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r)
{
return glbinding::Binding::MultiTexCoord3hNV(target, s, t, r);
}
inline void glMultiTexCoord3hvNV(GLenum target, const GLhalfNV * v)
{
return glbinding::Binding::MultiTexCoord3hvNV(target, v);
}
inline void glMultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r)
{
return glbinding::Binding::MultiTexCoord3iARB(target, s, t, r);
}
inline void glMultiTexCoord3ivARB(GLenum target, const GLint * v)
{
return glbinding::Binding::MultiTexCoord3ivARB(target, v);
}
inline void glMultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshort r)
{
return glbinding::Binding::MultiTexCoord3sARB(target, s, t, r);
}
inline void glMultiTexCoord3svARB(GLenum target, const GLshort * v)
{
return glbinding::Binding::MultiTexCoord3svARB(target, v);
}
inline void glMultiTexCoord3xOES(GLenum texture, GLfixed s, GLfixed t, GLfixed r)
{
return glbinding::Binding::MultiTexCoord3xOES(texture, s, t, r);
}
inline void glMultiTexCoord3xvOES(GLenum texture, const GLfixed * coords)
{
return glbinding::Binding::MultiTexCoord3xvOES(texture, coords);
}
inline void glMultiTexCoord4bOES(GLenum texture, GLbyte s, GLbyte t, GLbyte r, GLbyte q)
{
return glbinding::Binding::MultiTexCoord4bOES(texture, s, t, r, q);
}
inline void glMultiTexCoord4bvOES(GLenum texture, const GLbyte * coords)
{
return glbinding::Binding::MultiTexCoord4bvOES(texture, coords);
}
inline void glMultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
{
return glbinding::Binding::MultiTexCoord4dARB(target, s, t, r, q);
}
inline void glMultiTexCoord4dvARB(GLenum target, const GLdouble * v)
{
return glbinding::Binding::MultiTexCoord4dvARB(target, v);
}
inline void glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
{
return glbinding::Binding::MultiTexCoord4fARB(target, s, t, r, q);
}
inline void glMultiTexCoord4fvARB(GLenum target, const GLfloat * v)
{
return glbinding::Binding::MultiTexCoord4fvARB(target, v);
}
inline void glMultiTexCoord4hNV(GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q)
{
return glbinding::Binding::MultiTexCoord4hNV(target, s, t, r, q);
}
inline void glMultiTexCoord4hvNV(GLenum target, const GLhalfNV * v)
{
return glbinding::Binding::MultiTexCoord4hvNV(target, v);
}
inline void glMultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, GLint q)
{
return glbinding::Binding::MultiTexCoord4iARB(target, s, t, r, q);
}
inline void glMultiTexCoord4ivARB(GLenum target, const GLint * v)
{
return glbinding::Binding::MultiTexCoord4ivARB(target, v);
}
inline void glMultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
{
return glbinding::Binding::MultiTexCoord4sARB(target, s, t, r, q);
}
inline void glMultiTexCoord4svARB(GLenum target, const GLshort * v)
{
return glbinding::Binding::MultiTexCoord4svARB(target, v);
}
inline void glMultiTexCoord4xOES(GLenum texture, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
{
return glbinding::Binding::MultiTexCoord4xOES(texture, s, t, r, q);
}
inline void glMultiTexCoord4xvOES(GLenum texture, const GLfixed * coords)
{
return glbinding::Binding::MultiTexCoord4xvOES(texture, coords);
}
inline void glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
{
return glbinding::Binding::MultiTexCoordP1ui(texture, type, coords);
}
inline void glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint * coords)
{
return glbinding::Binding::MultiTexCoordP1uiv(texture, type, coords);
}
inline void glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
{
return glbinding::Binding::MultiTexCoordP2ui(texture, type, coords);
}
inline void glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint * coords)
{
return glbinding::Binding::MultiTexCoordP2uiv(texture, type, coords);
}
inline void glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
{
return glbinding::Binding::MultiTexCoordP3ui(texture, type, coords);
}
inline void glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint * coords)
{
return glbinding::Binding::MultiTexCoordP3uiv(texture, type, coords);
}
inline void glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
{
return glbinding::Binding::MultiTexCoordP4ui(texture, type, coords);
}
inline void glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint * coords)
{
return glbinding::Binding::MultiTexCoordP4uiv(texture, type, coords);
}
inline void glMultiTexCoordPointerEXT(GLenum texunit, GLint size, GLenum type, GLsizei stride, const void * pointer)
{
return glbinding::Binding::MultiTexCoordPointerEXT(texunit, size, type, stride, pointer);
}
inline void glMultiTexEnvfEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat param)
{
return glbinding::Binding::MultiTexEnvfEXT(texunit, target, pname, param);
}
inline void glMultiTexEnvfvEXT(GLenum texunit, GLenum target, GLenum pname, const GLfloat * params)
{
return glbinding::Binding::MultiTexEnvfvEXT(texunit, target, pname, params);
}
inline void glMultiTexEnviEXT(GLenum texunit, GLenum target, GLenum pname, GLint param)
{
return glbinding::Binding::MultiTexEnviEXT(texunit, target, pname, param);
}
inline void glMultiTexEnvivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint * params)
{
return glbinding::Binding::MultiTexEnvivEXT(texunit, target, pname, params);
}
inline void glMultiTexGendEXT(GLenum texunit, GLenum coord, GLenum pname, GLdouble param)
{
return glbinding::Binding::MultiTexGendEXT(texunit, coord, pname, param);
}
inline void glMultiTexGendvEXT(GLenum texunit, GLenum coord, GLenum pname, const GLdouble * params)
{
return glbinding::Binding::MultiTexGendvEXT(texunit, coord, pname, params);
}
inline void glMultiTexGenfEXT(GLenum texunit, GLenum coord, GLenum pname, GLfloat param)
{
return glbinding::Binding::MultiTexGenfEXT(texunit, coord, pname, param);
}
inline void glMultiTexGenfvEXT(GLenum texunit, GLenum coord, GLenum pname, const GLfloat * params)
{
return glbinding::Binding::MultiTexGenfvEXT(texunit, coord, pname, params);
}
inline void glMultiTexGeniEXT(GLenum texunit, GLenum coord, GLenum pname, GLint param)
{
return glbinding::Binding::MultiTexGeniEXT(texunit, coord, pname, param);
}
inline void glMultiTexGenivEXT(GLenum texunit, GLenum coord, GLenum pname, const GLint * params)
{
return glbinding::Binding::MultiTexGenivEXT(texunit, coord, pname, params);
}
inline void glMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels)
{
return glbinding::Binding::MultiTexImage1DEXT(texunit, target, level, internalformat, width, border, format, type, pixels);
}
inline void glMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels)
{
return glbinding::Binding::MultiTexImage2DEXT(texunit, target, level, internalformat, width, height, border, format, type, pixels);
}
inline void glMultiTexImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels)
{
return glbinding::Binding::MultiTexImage3DEXT(texunit, target, level, internalformat, width, height, depth, border, format, type, pixels);
}
inline void glMultiTexParameterIivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint * params)
{
return glbinding::Binding::MultiTexParameterIivEXT(texunit, target, pname, params);
}
inline void glMultiTexParameterIuivEXT(GLenum texunit, GLenum target, GLenum pname, const GLuint * params)
{
return glbinding::Binding::MultiTexParameterIuivEXT(texunit, target, pname, params);
}
inline void glMultiTexParameterfEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat param)
{
return glbinding::Binding::MultiTexParameterfEXT(texunit, target, pname, param);
}
inline void glMultiTexParameterfvEXT(GLenum texunit, GLenum target, GLenum pname, const GLfloat * params)
{
return glbinding::Binding::MultiTexParameterfvEXT(texunit, target, pname, params);
}
inline void glMultiTexParameteriEXT(GLenum texunit, GLenum target, GLenum pname, GLint param)
{
return glbinding::Binding::MultiTexParameteriEXT(texunit, target, pname, param);
}
inline void glMultiTexParameterivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint * params)
{
return glbinding::Binding::MultiTexParameterivEXT(texunit, target, pname, params);
}
inline void glMultiTexRenderbufferEXT(GLenum texunit, GLenum target, GLuint renderbuffer)
{
return glbinding::Binding::MultiTexRenderbufferEXT(texunit, target, renderbuffer);
}
inline void glMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels)
{
return glbinding::Binding::MultiTexSubImage1DEXT(texunit, target, level, xoffset, width, format, type, pixels);
}
inline void glMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels)
{
return glbinding::Binding::MultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, width, height, format, type, pixels);
}
inline void glMultiTexSubImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels)
{
return glbinding::Binding::MultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
}
inline void glNamedBufferData(GLuint buffer, GLsizeiptr size, const void * data, GLenum usage)
{
return glbinding::Binding::NamedBufferData(buffer, size, data, usage);
}
inline void glNamedBufferDataEXT(GLuint buffer, GLsizeiptr size, const void * data, GLenum usage)
{
return glbinding::Binding::NamedBufferDataEXT(buffer, size, data, usage);
}
inline void glNamedBufferPageCommitmentARB(GLuint buffer, GLintptr offset, GLsizeiptr size, GLboolean commit)
{
return glbinding::Binding::NamedBufferPageCommitmentARB(buffer, offset, size, commit);
}
inline void glNamedBufferPageCommitmentEXT(GLuint buffer, GLintptr offset, GLsizeiptr size, GLboolean commit)
{
return glbinding::Binding::NamedBufferPageCommitmentEXT(buffer, offset, size, commit);
}
inline void glNamedBufferStorage(GLuint buffer, GLsizeiptr size, const void * data, MapBufferUsageMask flags)
{
return glbinding::Binding::NamedBufferStorage(buffer, size, data, flags);
}
inline void glNamedBufferStorageEXT(GLuint buffer, GLsizeiptr size, const void * data, MapBufferUsageMask flags)
{
return glbinding::Binding::NamedBufferStorageEXT(buffer, size, data, flags);
}
inline void glNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr size, const void * data)
{
return glbinding::Binding::NamedBufferSubData(buffer, offset, size, data);
}
inline void glNamedBufferSubDataEXT(GLuint buffer, GLintptr offset, GLsizeiptr size, const void * data)
{
return glbinding::Binding::NamedBufferSubDataEXT(buffer, offset, size, data);
}
inline void glNamedCopyBufferSubDataEXT(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
{
return glbinding::Binding::NamedCopyBufferSubDataEXT(readBuffer, writeBuffer, readOffset, writeOffset, size);
}
inline void glNamedFramebufferDrawBuffer(GLuint framebuffer, GLenum buf)
{
return glbinding::Binding::NamedFramebufferDrawBuffer(framebuffer, buf);
}
inline void glNamedFramebufferDrawBuffers(GLuint framebuffer, GLsizei n, const GLenum * bufs)
{
return glbinding::Binding::NamedFramebufferDrawBuffers(framebuffer, n, bufs);
}
inline void glNamedFramebufferParameteri(GLuint framebuffer, GLenum pname, GLint param)
{
return glbinding::Binding::NamedFramebufferParameteri(framebuffer, pname, param);
}
inline void glNamedFramebufferParameteriEXT(GLuint framebuffer, GLenum pname, GLint param)
{
return glbinding::Binding::NamedFramebufferParameteriEXT(framebuffer, pname, param);
}
inline void glNamedFramebufferReadBuffer(GLuint framebuffer, GLenum src)
{
return glbinding::Binding::NamedFramebufferReadBuffer(framebuffer, src);
}
inline void glNamedFramebufferRenderbuffer(GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
{
return glbinding::Binding::NamedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer);
}
inline void glNamedFramebufferRenderbufferEXT(GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
{
return glbinding::Binding::NamedFramebufferRenderbufferEXT(framebuffer, attachment, renderbuffertarget, renderbuffer);
}
inline void glNamedFramebufferSampleLocationsfvNV(GLuint framebuffer, GLuint start, GLsizei count, const GLfloat * v)
{
return glbinding::Binding::NamedFramebufferSampleLocationsfvNV(framebuffer, start, count, v);
}
inline void glNamedFramebufferTexture(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level)
{
return glbinding::Binding::NamedFramebufferTexture(framebuffer, attachment, texture, level);
}
inline void glNamedFramebufferTexture1DEXT(GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
{
return glbinding::Binding::NamedFramebufferTexture1DEXT(framebuffer, attachment, textarget, texture, level);
}
inline void glNamedFramebufferTexture2DEXT(GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
{
return glbinding::Binding::NamedFramebufferTexture2DEXT(framebuffer, attachment, textarget, texture, level);
}
inline void glNamedFramebufferTexture3DEXT(GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
{
return glbinding::Binding::NamedFramebufferTexture3DEXT(framebuffer, attachment, textarget, texture, level, zoffset);
}
inline void glNamedFramebufferTextureEXT(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level)
{
return glbinding::Binding::NamedFramebufferTextureEXT(framebuffer, attachment, texture, level);
}
inline void glNamedFramebufferTextureFaceEXT(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLenum face)
{
return glbinding::Binding::NamedFramebufferTextureFaceEXT(framebuffer, attachment, texture, level, face);
}
inline void glNamedFramebufferTextureLayer(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer)
{
return glbinding::Binding::NamedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer);
}
inline void glNamedFramebufferTextureLayerEXT(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer)
{
return glbinding::Binding::NamedFramebufferTextureLayerEXT(framebuffer, attachment, texture, level, layer);
}
inline void glNamedProgramLocalParameter4dEXT(GLuint program, GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
return glbinding::Binding::NamedProgramLocalParameter4dEXT(program, target, index, x, y, z, w);
}
inline void glNamedProgramLocalParameter4dvEXT(GLuint program, GLenum target, GLuint index, const GLdouble * params)
{
return glbinding::Binding::NamedProgramLocalParameter4dvEXT(program, target, index, params);
}
inline void glNamedProgramLocalParameter4fEXT(GLuint program, GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
return glbinding::Binding::NamedProgramLocalParameter4fEXT(program, target, index, x, y, z, w);
}
inline void glNamedProgramLocalParameter4fvEXT(GLuint program, GLenum target, GLuint index, const GLfloat * params)
{
return glbinding::Binding::NamedProgramLocalParameter4fvEXT(program, target, index, params);
}
inline void glNamedProgramLocalParameterI4iEXT(GLuint program, GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w)
{
return glbinding::Binding::NamedProgramLocalParameterI4iEXT(program, target, index, x, y, z, w);
}
inline void glNamedProgramLocalParameterI4ivEXT(GLuint program, GLenum target, GLuint index, const GLint * params)
{
return glbinding::Binding::NamedProgramLocalParameterI4ivEXT(program, target, index, params);
}
inline void glNamedProgramLocalParameterI4uiEXT(GLuint program, GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
{
return glbinding::Binding::NamedProgramLocalParameterI4uiEXT(program, target, index, x, y, z, w);
}
inline void glNamedProgramLocalParameterI4uivEXT(GLuint program, GLenum target, GLuint index, const GLuint * params)
{
return glbinding::Binding::NamedProgramLocalParameterI4uivEXT(program, target, index, params);
}
inline void glNamedProgramLocalParameters4fvEXT(GLuint program, GLenum target, GLuint index, GLsizei count, const GLfloat * params)
{
return glbinding::Binding::NamedProgramLocalParameters4fvEXT(program, target, index, count, params);
}
inline void glNamedProgramLocalParametersI4ivEXT(GLuint program, GLenum target, GLuint index, GLsizei count, const GLint * params)
{
return glbinding::Binding::NamedProgramLocalParametersI4ivEXT(program, target, index, count, params);
}
inline void glNamedProgramLocalParametersI4uivEXT(GLuint program, GLenum target, GLuint index, GLsizei count, const GLuint * params)
{
return glbinding::Binding::NamedProgramLocalParametersI4uivEXT(program, target, index, count, params);
}
inline void glNamedProgramStringEXT(GLuint program, GLenum target, GLenum format, GLsizei len, const void * string)
{
return glbinding::Binding::NamedProgramStringEXT(program, target, format, len, string);
}
inline void glNamedRenderbufferStorage(GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height)
{
return glbinding::Binding::NamedRenderbufferStorage(renderbuffer, internalformat, width, height);
}
inline void glNamedRenderbufferStorageEXT(GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height)
{
return glbinding::Binding::NamedRenderbufferStorageEXT(renderbuffer, internalformat, width, height);
}
inline void glNamedRenderbufferStorageMultisample(GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
{
return glbinding::Binding::NamedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height);
}
inline void glNamedRenderbufferStorageMultisampleCoverageEXT(GLuint renderbuffer, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height)
{
return glbinding::Binding::NamedRenderbufferStorageMultisampleCoverageEXT(renderbuffer, coverageSamples, colorSamples, internalformat, width, height);
}
inline void glNamedRenderbufferStorageMultisampleEXT(GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
{
return glbinding::Binding::NamedRenderbufferStorageMultisampleEXT(renderbuffer, samples, internalformat, width, height);
}
inline void glNamedStringARB(GLenum type, GLint namelen, const GLchar * name, GLint stringlen, const GLchar * string)
{
return glbinding::Binding::NamedStringARB(type, namelen, name, stringlen, string);
}
inline GLuint glNewObjectBufferATI(GLsizei size, const void * pointer, GLenum usage)
{
return glbinding::Binding::NewObjectBufferATI(size, pointer, usage);
}
inline void glNormal3fVertex3fSUN(GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
{
return glbinding::Binding::Normal3fVertex3fSUN(nx, ny, nz, x, y, z);
}
inline void glNormal3fVertex3fvSUN(const GLfloat * n, const GLfloat * v)
{
return glbinding::Binding::Normal3fVertex3fvSUN(n, v);
}
inline void glNormal3hNV(GLhalfNV nx, GLhalfNV ny, GLhalfNV nz)
{
return glbinding::Binding::Normal3hNV(nx, ny, nz);
}
inline void glNormal3hvNV(const GLhalfNV * v)
{
return glbinding::Binding::Normal3hvNV(v);
}
inline void glNormal3xOES(GLfixed nx, GLfixed ny, GLfixed nz)
{
return glbinding::Binding::Normal3xOES(nx, ny, nz);
}
inline void glNormal3xvOES(const GLfixed * coords)
{
return glbinding::Binding::Normal3xvOES(coords);
}
inline void glNormalFormatNV(GLenum type, GLsizei stride)
{
return glbinding::Binding::NormalFormatNV(type, stride);
}
inline void glNormalP3ui(GLenum type, GLuint coords)
{
return glbinding::Binding::NormalP3ui(type, coords);
}
inline void glNormalP3uiv(GLenum type, const GLuint * coords)
{
return glbinding::Binding::NormalP3uiv(type, coords);
}
inline void glNormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, const void * pointer)
{
return glbinding::Binding::NormalPointerEXT(type, stride, count, pointer);
}
inline void glNormalPointerListIBM(GLenum type, GLint stride, const void ** pointer, GLint ptrstride)
{
return glbinding::Binding::NormalPointerListIBM(type, stride, pointer, ptrstride);
}
inline void glNormalPointervINTEL(GLenum type, const void ** pointer)
{
return glbinding::Binding::NormalPointervINTEL(type, pointer);
}
inline void glNormalStream3bATI(GLenum stream, GLbyte nx, GLbyte ny, GLbyte nz)
{
return glbinding::Binding::NormalStream3bATI(stream, nx, ny, nz);
}
inline void glNormalStream3bvATI(GLenum stream, const GLbyte * coords)
{
return glbinding::Binding::NormalStream3bvATI(stream, coords);
}
inline void glNormalStream3dATI(GLenum stream, GLdouble nx, GLdouble ny, GLdouble nz)
{
return glbinding::Binding::NormalStream3dATI(stream, nx, ny, nz);
}
inline void glNormalStream3dvATI(GLenum stream, const GLdouble * coords)
{
return glbinding::Binding::NormalStream3dvATI(stream, coords);
}
inline void glNormalStream3fATI(GLenum stream, GLfloat nx, GLfloat ny, GLfloat nz)
{
return glbinding::Binding::NormalStream3fATI(stream, nx, ny, nz);
}
inline void glNormalStream3fvATI(GLenum stream, const GLfloat * coords)
{
return glbinding::Binding::NormalStream3fvATI(stream, coords);
}
inline void glNormalStream3iATI(GLenum stream, GLint nx, GLint ny, GLint nz)
{
return glbinding::Binding::NormalStream3iATI(stream, nx, ny, nz);
}
inline void glNormalStream3ivATI(GLenum stream, const GLint * coords)
{
return glbinding::Binding::NormalStream3ivATI(stream, coords);
}
inline void glNormalStream3sATI(GLenum stream, GLshort nx, GLshort ny, GLshort nz)
{
return glbinding::Binding::NormalStream3sATI(stream, nx, ny, nz);
}
inline void glNormalStream3svATI(GLenum stream, const GLshort * coords)
{
return glbinding::Binding::NormalStream3svATI(stream, coords);
}
inline void glObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar * label)
{
return glbinding::Binding::ObjectLabel(identifier, name, length, label);
}
inline void glObjectPtrLabel(const void * ptr, GLsizei length, const GLchar * label)
{
return glbinding::Binding::ObjectPtrLabel(ptr, length, label);
}
inline GLenum glObjectPurgeableAPPLE(GLenum objectType, GLuint name, GLenum option)
{
return static_cast<gl14ext::GLenum>(glbinding::Binding::ObjectPurgeableAPPLE(objectType, name, option));
}
inline GLenum glObjectUnpurgeableAPPLE(GLenum objectType, GLuint name, GLenum option)
{
return static_cast<gl14ext::GLenum>(glbinding::Binding::ObjectUnpurgeableAPPLE(objectType, name, option));
}
inline void glOrthofOES(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f)
{
return glbinding::Binding::OrthofOES(l, r, b, t, n, f);
}
inline void glOrthoxOES(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f)
{
return glbinding::Binding::OrthoxOES(l, r, b, t, n, f);
}
inline void glPNTrianglesfATI(GLenum pname, GLfloat param)
{
return glbinding::Binding::PNTrianglesfATI(pname, param);
}
inline void glPNTrianglesiATI(GLenum pname, GLint param)
{
return glbinding::Binding::PNTrianglesiATI(pname, param);
}
inline void glPassTexCoordATI(GLuint dst, GLuint coord, GLenum swizzle)
{
return glbinding::Binding::PassTexCoordATI(dst, coord, swizzle);
}
inline void glPassThroughxOES(GLfixed token)
{
return glbinding::Binding::PassThroughxOES(token);
}
inline void glPatchParameterfv(GLenum pname, const GLfloat * values)
{
return glbinding::Binding::PatchParameterfv(pname, values);
}
inline void glPatchParameteri(GLenum pname, GLint value)
{
return glbinding::Binding::PatchParameteri(pname, value);
}
inline void glPathColorGenNV(GLenum color, GLenum genMode, GLenum colorFormat, const GLfloat * coeffs)
{
return glbinding::Binding::PathColorGenNV(color, genMode, colorFormat, coeffs);
}
inline void glPathCommandsNV(GLuint path, GLsizei numCommands, const GLubyte * commands, GLsizei numCoords, GLenum coordType, const void * coords)
{
return glbinding::Binding::PathCommandsNV(path, numCommands, commands, numCoords, coordType, coords);
}
inline void glPathCoordsNV(GLuint path, GLsizei numCoords, GLenum coordType, const void * coords)
{
return glbinding::Binding::PathCoordsNV(path, numCoords, coordType, coords);
}
inline void glPathCoverDepthFuncNV(GLenum func)
{
return glbinding::Binding::PathCoverDepthFuncNV(func);
}
inline void glPathDashArrayNV(GLuint path, GLsizei dashCount, const GLfloat * dashArray)
{
return glbinding::Binding::PathDashArrayNV(path, dashCount, dashArray);
}
inline void glPathFogGenNV(GLenum genMode)
{
return glbinding::Binding::PathFogGenNV(genMode);
}
inline GLenum glPathGlyphIndexArrayNV(GLuint firstPathName, GLenum fontTarget, const void * fontName, PathFontStyle fontStyle, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale)
{
return static_cast<gl14ext::GLenum>(glbinding::Binding::PathGlyphIndexArrayNV(firstPathName, fontTarget, fontName, fontStyle, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale));
}
inline GLenum glPathGlyphIndexRangeNV(GLenum fontTarget, const void * fontName, PathFontStyle fontStyle, GLuint pathParameterTemplate, GLfloat emScale, GLuint_array_2 baseAndCount)
{
return static_cast<gl14ext::GLenum>(glbinding::Binding::PathGlyphIndexRangeNV(fontTarget, fontName, fontStyle, pathParameterTemplate, emScale, baseAndCount));
}
inline void glPathGlyphRangeNV(GLuint firstPathName, GLenum fontTarget, const void * fontName, PathFontStyle fontStyle, GLuint firstGlyph, GLsizei numGlyphs, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale)
{
return glbinding::Binding::PathGlyphRangeNV(firstPathName, fontTarget, fontName, fontStyle, firstGlyph, numGlyphs, handleMissingGlyphs, pathParameterTemplate, emScale);
}
inline void glPathGlyphsNV(GLuint firstPathName, GLenum fontTarget, const void * fontName, PathFontStyle fontStyle, GLsizei numGlyphs, GLenum type, const void * charcodes, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale)
{
return glbinding::Binding::PathGlyphsNV(firstPathName, fontTarget, fontName, fontStyle, numGlyphs, type, charcodes, handleMissingGlyphs, pathParameterTemplate, emScale);
}
inline GLenum glPathMemoryGlyphIndexArrayNV(GLuint firstPathName, GLenum fontTarget, GLsizeiptr fontSize, const void * fontData, GLsizei faceIndex, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale)
{
return static_cast<gl14ext::GLenum>(glbinding::Binding::PathMemoryGlyphIndexArrayNV(firstPathName, fontTarget, fontSize, fontData, faceIndex, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale));
}
inline void glPathParameterfNV(GLuint path, GLenum pname, GLfloat value)
{
return glbinding::Binding::PathParameterfNV(path, pname, value);
}
inline void glPathParameterfvNV(GLuint path, GLenum pname, const GLfloat * value)
{
return glbinding::Binding::PathParameterfvNV(path, pname, value);
}
inline void glPathParameteriNV(GLuint path, GLenum pname, GLint value)
{
return glbinding::Binding::PathParameteriNV(path, pname, value);
}
inline void glPathParameterivNV(GLuint path, GLenum pname, const GLint * value)
{
return glbinding::Binding::PathParameterivNV(path, pname, value);
}
inline void glPathStencilDepthOffsetNV(GLfloat factor, GLfloat units)
{
return glbinding::Binding::PathStencilDepthOffsetNV(factor, units);
}
inline void glPathStencilFuncNV(GLenum func, GLint ref, GLuint mask)
{
return glbinding::Binding::PathStencilFuncNV(func, ref, mask);
}
inline void glPathStringNV(GLuint path, GLenum format, GLsizei length, const void * pathString)
{
return glbinding::Binding::PathStringNV(path, format, length, pathString);
}
inline void glPathSubCommandsNV(GLuint path, GLsizei commandStart, GLsizei commandsToDelete, GLsizei numCommands, const GLubyte * commands, GLsizei numCoords, GLenum coordType, const void * coords)
{
return glbinding::Binding::PathSubCommandsNV(path, commandStart, commandsToDelete, numCommands, commands, numCoords, coordType, coords);
}
inline void glPathSubCoordsNV(GLuint path, GLsizei coordStart, GLsizei numCoords, GLenum coordType, const void * coords)
{
return glbinding::Binding::PathSubCoordsNV(path, coordStart, numCoords, coordType, coords);
}
inline void glPathTexGenNV(GLenum texCoordSet, GLenum genMode, GLint components, const GLfloat * coeffs)
{
return glbinding::Binding::PathTexGenNV(texCoordSet, genMode, components, coeffs);
}
inline void glPauseTransformFeedback()
{
return glbinding::Binding::PauseTransformFeedback();
}
inline void glPauseTransformFeedbackNV()
{
return glbinding::Binding::PauseTransformFeedbackNV();
}
inline void glPixelDataRangeNV(GLenum target, GLsizei length, const void * pointer)
{
return glbinding::Binding::PixelDataRangeNV(target, length, pointer);
}
inline void glPixelMapx(GLenum map, GLint size, const GLfixed * values)
{
return glbinding::Binding::PixelMapx(map, size, values);
}
inline void glPixelStorex(GLenum pname, GLfixed param)
{
return glbinding::Binding::PixelStorex(pname, param);
}
inline void glPixelTexGenParameterfSGIS(GLenum pname, GLfloat param)
{
return glbinding::Binding::PixelTexGenParameterfSGIS(pname, param);
}
inline void glPixelTexGenParameterfvSGIS(GLenum pname, const GLfloat * params)
{
return glbinding::Binding::PixelTexGenParameterfvSGIS(pname, params);
}
inline void glPixelTexGenParameteriSGIS(GLenum pname, GLint param)
{
return glbinding::Binding::PixelTexGenParameteriSGIS(pname, param);
}
inline void glPixelTexGenParameterivSGIS(GLenum pname, const GLint * params)
{
return glbinding::Binding::PixelTexGenParameterivSGIS(pname, params);
}
inline void glPixelTexGenSGIX(GLenum mode)
{
return glbinding::Binding::PixelTexGenSGIX(mode);
}
inline void glPixelTransferxOES(GLenum pname, GLfixed param)
{
return glbinding::Binding::PixelTransferxOES(pname, param);
}
inline void glPixelTransformParameterfEXT(GLenum target, GLenum pname, GLfloat param)
{
return glbinding::Binding::PixelTransformParameterfEXT(target, pname, param);
}
inline void glPixelTransformParameterfvEXT(GLenum target, GLenum pname, const GLfloat * params)
{
return glbinding::Binding::PixelTransformParameterfvEXT(target, pname, params);
}
inline void glPixelTransformParameteriEXT(GLenum target, GLenum pname, GLint param)
{
return glbinding::Binding::PixelTransformParameteriEXT(target, pname, param);
}
inline void glPixelTransformParameterivEXT(GLenum target, GLenum pname, const GLint * params)
{
return glbinding::Binding::PixelTransformParameterivEXT(target, pname, params);
}
inline void glPixelZoomxOES(GLfixed xfactor, GLfixed yfactor)
{
return glbinding::Binding::PixelZoomxOES(xfactor, yfactor);
}
inline GLboolean glPointAlongPathNV(GLuint path, GLsizei startSegment, GLsizei numSegments, GLfloat distance, GLfloat * x, GLfloat * y, GLfloat * tangentX, GLfloat * tangentY)
{
return glbinding::Binding::PointAlongPathNV(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
}
inline void glPointParameterfARB(GLenum pname, GLfloat param)
{
return glbinding::Binding::PointParameterfARB(pname, param);
}
inline void glPointParameterfEXT(GLenum pname, GLfloat param)
{
return glbinding::Binding::PointParameterfEXT(pname, param);
}
inline void glPointParameterfSGIS(GLenum pname, GLfloat param)
{
return glbinding::Binding::PointParameterfSGIS(pname, param);
}
inline void glPointParameterfvARB(GLenum pname, const GLfloat * params)
{
return glbinding::Binding::PointParameterfvARB(pname, params);
}
inline void glPointParameterfvEXT(GLenum pname, const GLfloat * params)
{
return glbinding::Binding::PointParameterfvEXT(pname, params);
}
inline void glPointParameterfvSGIS(GLenum pname, const GLfloat * params)
{
return glbinding::Binding::PointParameterfvSGIS(pname, params);
}
inline void glPointParameteriNV(GLenum pname, GLint param)
{
return glbinding::Binding::PointParameteriNV(pname, param);
}
inline void glPointParameterivNV(GLenum pname, const GLint * params)
{
return glbinding::Binding::PointParameterivNV(pname, params);
}
inline void glPointParameterxvOES(GLenum pname, const GLfixed * params)
{
return glbinding::Binding::PointParameterxvOES(pname, params);
}
inline void glPointSizexOES(GLfixed size)
{
return glbinding::Binding::PointSizexOES(size);
}
inline GLint glPollAsyncSGIX(GLuint * markerp)
{
return glbinding::Binding::PollAsyncSGIX(markerp);
}
inline GLint glPollInstrumentsSGIX(GLint * marker_p)
{
return glbinding::Binding::PollInstrumentsSGIX(marker_p);
}
inline void glPolygonOffsetClampEXT(GLfloat factor, GLfloat units, GLfloat clamp)
{
return glbinding::Binding::PolygonOffsetClampEXT(factor, units, clamp);
}
inline void glPolygonOffsetEXT(GLfloat factor, GLfloat bias)
{
return glbinding::Binding::PolygonOffsetEXT(factor, bias);
}
inline void glPolygonOffsetxOES(GLfixed factor, GLfixed units)
{
return glbinding::Binding::PolygonOffsetxOES(factor, units);
}
inline void glPopDebugGroup()
{
return glbinding::Binding::PopDebugGroup();
}
inline void glPopGroupMarkerEXT()
{
return glbinding::Binding::PopGroupMarkerEXT();
}
inline void glPresentFrameDualFillNV(GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLenum target1, GLuint fill1, GLenum target2, GLuint fill2, GLenum target3, GLuint fill3)
{
return glbinding::Binding::PresentFrameDualFillNV(video_slot, minPresentTime, beginPresentTimeId, presentDurationId, type, target0, fill0, target1, fill1, target2, fill2, target3, fill3);
}
inline void glPresentFrameKeyedNV(GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLuint key0, GLenum target1, GLuint fill1, GLuint key1)
{
return glbinding::Binding::PresentFrameKeyedNV(video_slot, minPresentTime, beginPresentTimeId, presentDurationId, type, target0, fill0, key0, target1, fill1, key1);
}
inline void glPrimitiveRestartIndex(GLuint index)
{
return glbinding::Binding::PrimitiveRestartIndex(index);
}
inline void glPrimitiveRestartIndexNV(GLuint index)
{
return glbinding::Binding::PrimitiveRestartIndexNV(index);
}
inline void glPrimitiveRestartNV()
{
return glbinding::Binding::PrimitiveRestartNV();
}
inline void glPrioritizeTexturesEXT(GLsizei n, const GLuint * textures, const GLclampf * priorities)
{
return glbinding::Binding::PrioritizeTexturesEXT(n, textures, priorities);
}
inline void glPrioritizeTexturesxOES(GLsizei n, const GLuint * textures, const GLfixed * priorities)
{
return glbinding::Binding::PrioritizeTexturesxOES(n, textures, priorities);
}
inline void glProgramBinary(GLuint program, GLenum binaryFormat, const void * binary, GLsizei length)
{
return glbinding::Binding::ProgramBinary(program, binaryFormat, binary, length);
}
inline void glProgramBufferParametersIivNV(GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLint * params)
{
return glbinding::Binding::ProgramBufferParametersIivNV(target, bindingIndex, wordIndex, count, params);
}
inline void glProgramBufferParametersIuivNV(GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLuint * params)
{
return glbinding::Binding::ProgramBufferParametersIuivNV(target, bindingIndex, wordIndex, count, params);
}
inline void glProgramBufferParametersfvNV(GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLfloat * params)
{
return glbinding::Binding::ProgramBufferParametersfvNV(target, bindingIndex, wordIndex, count, params);
}
inline void glProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
return glbinding::Binding::ProgramEnvParameter4dARB(target, index, x, y, z, w);
}
inline void glProgramEnvParameter4dvARB(GLenum target, GLuint index, const GLdouble * params)
{
return glbinding::Binding::ProgramEnvParameter4dvARB(target, index, params);
}
inline void glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
return glbinding::Binding::ProgramEnvParameter4fARB(target, index, x, y, z, w);
}
inline void glProgramEnvParameter4fvARB(GLenum target, GLuint index, const GLfloat * params)
{
return glbinding::Binding::ProgramEnvParameter4fvARB(target, index, params);
}
inline void glProgramEnvParameterI4iNV(GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w)
{
return glbinding::Binding::ProgramEnvParameterI4iNV(target, index, x, y, z, w);
}
inline void glProgramEnvParameterI4ivNV(GLenum target, GLuint index, const GLint * params)
{
return glbinding::Binding::ProgramEnvParameterI4ivNV(target, index, params);
}
inline void glProgramEnvParameterI4uiNV(GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
{
return glbinding::Binding::ProgramEnvParameterI4uiNV(target, index, x, y, z, w);
}
inline void glProgramEnvParameterI4uivNV(GLenum target, GLuint index, const GLuint * params)
{
return glbinding::Binding::ProgramEnvParameterI4uivNV(target, index, params);
}
inline void glProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count, const GLfloat * params)
{
return glbinding::Binding::ProgramEnvParameters4fvEXT(target, index, count, params);
}
inline void glProgramEnvParametersI4ivNV(GLenum target, GLuint index, GLsizei count, const GLint * params)
{
return glbinding::Binding::ProgramEnvParametersI4ivNV(target, index, count, params);
}
inline void glProgramEnvParametersI4uivNV(GLenum target, GLuint index, GLsizei count, const GLuint * params)
{
return glbinding::Binding::ProgramEnvParametersI4uivNV(target, index, count, params);
}
inline void glProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
return glbinding::Binding::ProgramLocalParameter4dARB(target, index, x, y, z, w);
}
inline void glProgramLocalParameter4dvARB(GLenum target, GLuint index, const GLdouble * params)
{
return glbinding::Binding::ProgramLocalParameter4dvARB(target, index, params);
}
inline void glProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
return glbinding::Binding::ProgramLocalParameter4fARB(target, index, x, y, z, w);
}
inline void glProgramLocalParameter4fvARB(GLenum target, GLuint index, const GLfloat * params)
{
return glbinding::Binding::ProgramLocalParameter4fvARB(target, index, params);
}
inline void glProgramLocalParameterI4iNV(GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w)
{
return glbinding::Binding::ProgramLocalParameterI4iNV(target, index, x, y, z, w);
}
inline void glProgramLocalParameterI4ivNV(GLenum target, GLuint index, const GLint * params)
{
return glbinding::Binding::ProgramLocalParameterI4ivNV(target, index, params);
}
inline void glProgramLocalParameterI4uiNV(GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
{
return glbinding::Binding::ProgramLocalParameterI4uiNV(target, index, x, y, z, w);
}
inline void glProgramLocalParameterI4uivNV(GLenum target, GLuint index, const GLuint * params)
{
return glbinding::Binding::ProgramLocalParameterI4uivNV(target, index, params);
}
inline void glProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count, const GLfloat * params)
{
return glbinding::Binding::ProgramLocalParameters4fvEXT(target, index, count, params);
}
inline void glProgramLocalParametersI4ivNV(GLenum target, GLuint index, GLsizei count, const GLint * params)
{
return glbinding::Binding::ProgramLocalParametersI4ivNV(target, index, count, params);
}
inline void glProgramLocalParametersI4uivNV(GLenum target, GLuint index, GLsizei count, const GLuint * params)
{
return glbinding::Binding::ProgramLocalParametersI4uivNV(target, index, count, params);
}
inline void glProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
return glbinding::Binding::ProgramNamedParameter4dNV(id, len, name, x, y, z, w);
}
inline void glProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte * name, const GLdouble * v)
{
return glbinding::Binding::ProgramNamedParameter4dvNV(id, len, name, v);
}
inline void glProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
return glbinding::Binding::ProgramNamedParameter4fNV(id, len, name, x, y, z, w);
}
inline void glProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte * name, const GLfloat * v)
{
return glbinding::Binding::ProgramNamedParameter4fvNV(id, len, name, v);
}
inline void glProgramParameter4dNV(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
return glbinding::Binding::ProgramParameter4dNV(target, index, x, y, z, w);
}
inline void glProgramParameter4dvNV(GLenum target, GLuint index, const GLdouble * v)
{
return glbinding::Binding::ProgramParameter4dvNV(target, index, v);
}
inline void glProgramParameter4fNV(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
return glbinding::Binding::ProgramParameter4fNV(target, index, x, y, z, w);
}
inline void glProgramParameter4fvNV(GLenum target, GLuint index, const GLfloat * v)
{
return glbinding::Binding::ProgramParameter4fvNV(target, index, v);
}
inline void glProgramParameteri(GLuint program, GLenum pname, GLint value)
{
return glbinding::Binding::ProgramParameteri(program, pname, value);
}
inline void glProgramParameteriARB(GLuint program, GLenum pname, GLint value)
{
return glbinding::Binding::ProgramParameteriARB(program, pname, value);
}
inline void glProgramParameteriEXT(GLuint program, GLenum pname, GLint value)
{
return glbinding::Binding::ProgramParameteriEXT(program, pname, value);
}
inline void glProgramParameters4dvNV(GLenum target, GLuint index, GLsizei count, const GLdouble * v)
{
return glbinding::Binding::ProgramParameters4dvNV(target, index, count, v);
}
inline void glProgramParameters4fvNV(GLenum target, GLuint index, GLsizei count, const GLfloat * v)
{
return glbinding::Binding::ProgramParameters4fvNV(target, index, count, v);
}
inline void glProgramPathFragmentInputGenNV(GLuint program, GLint location, GLenum genMode, GLint components, const GLfloat * coeffs)
{
return glbinding::Binding::ProgramPathFragmentInputGenNV(program, location, genMode, components, coeffs);
}
inline void glProgramStringARB(GLenum target, GLenum format, GLsizei len, const void * string)
{
return glbinding::Binding::ProgramStringARB(target, format, len, string);
}
inline void glProgramSubroutineParametersuivNV(GLenum target, GLsizei count, const GLuint * params)
{
return glbinding::Binding::ProgramSubroutineParametersuivNV(target, count, params);
}
inline void glProgramUniform1d(GLuint program, GLint location, GLdouble v0)
{
return glbinding::Binding::ProgramUniform1d(program, location, v0);
}
inline void glProgramUniform1dEXT(GLuint program, GLint location, GLdouble x)
{
return glbinding::Binding::ProgramUniform1dEXT(program, location, x);
}
inline void glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble * value)
{
return glbinding::Binding::ProgramUniform1dv(program, location, count, value);
}
inline void glProgramUniform1dvEXT(GLuint program, GLint location, GLsizei count, const GLdouble * value)
{
return glbinding::Binding::ProgramUniform1dvEXT(program, location, count, value);
}
inline void glProgramUniform1f(GLuint program, GLint location, GLfloat v0)
{
return glbinding::Binding::ProgramUniform1f(program, location, v0);
}
inline void glProgramUniform1fEXT(GLuint program, GLint location, GLfloat v0)
{
return glbinding::Binding::ProgramUniform1fEXT(program, location, v0);
}
inline void glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat * value)
{
return glbinding::Binding::ProgramUniform1fv(program, location, count, value);
}
inline void glProgramUniform1fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat * value)
{
return glbinding::Binding::ProgramUniform1fvEXT(program, location, count, value);
}
inline void glProgramUniform1i(GLuint program, GLint location, GLint v0)
{
return glbinding::Binding::ProgramUniform1i(program, location, v0);
}
inline void glProgramUniform1i64NV(GLuint program, GLint location, GLint64EXT x)
{
return glbinding::Binding::ProgramUniform1i64NV(program, location, x);
}
inline void glProgramUniform1i64vNV(GLuint program, GLint location, GLsizei count, const GLint64EXT * value)
{
return glbinding::Binding::ProgramUniform1i64vNV(program, location, count, value);
}
inline void glProgramUniform1iEXT(GLuint program, GLint location, GLint v0)
{
return glbinding::Binding::ProgramUniform1iEXT(program, location, v0);
}
inline void glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint * value)
{
return glbinding::Binding::ProgramUniform1iv(program, location, count, value);
}
inline void glProgramUniform1ivEXT(GLuint program, GLint location, GLsizei count, const GLint * value)
{
return glbinding::Binding::ProgramUniform1ivEXT(program, location, count, value);
}
inline void glProgramUniform1ui(GLuint program, GLint location, GLuint v0)
{
return glbinding::Binding::ProgramUniform1ui(program, location, v0);
}
inline void glProgramUniform1ui64NV(GLuint program, GLint location, GLuint64EXT x)
{
return glbinding::Binding::ProgramUniform1ui64NV(program, location, x);
}
inline void glProgramUniform1ui64vNV(GLuint program, GLint location, GLsizei count, const GLuint64EXT * value)
{
return glbinding::Binding::ProgramUniform1ui64vNV(program, location, count, value);
}
inline void glProgramUniform1uiEXT(GLuint program, GLint location, GLuint v0)
{
return glbinding::Binding::ProgramUniform1uiEXT(program, location, v0);
}
inline void glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint * value)
{
return glbinding::Binding::ProgramUniform1uiv(program, location, count, value);
}
inline void glProgramUniform1uivEXT(GLuint program, GLint location, GLsizei count, const GLuint * value)
{
return glbinding::Binding::ProgramUniform1uivEXT(program, location, count, value);
}
inline void glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
{
return glbinding::Binding::ProgramUniform2d(program, location, v0, v1);
}
inline void glProgramUniform2dEXT(GLuint program, GLint location, GLdouble x, GLdouble y)
{
return glbinding::Binding::ProgramUniform2dEXT(program, location, x, y);
}
inline void glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble * value)
{
return glbinding::Binding::ProgramUniform2dv(program, location, count, value);
}
inline void glProgramUniform2dvEXT(GLuint program, GLint location, GLsizei count, const GLdouble * value)
{
return glbinding::Binding::ProgramUniform2dvEXT(program, location, count, value);
}
inline void glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
{
return glbinding::Binding::ProgramUniform2f(program, location, v0, v1);
}
inline void glProgramUniform2fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1)
{
return glbinding::Binding::ProgramUniform2fEXT(program, location, v0, v1);
}
inline void glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat * value)
{
return glbinding::Binding::ProgramUniform2fv(program, location, count, value);
}
inline void glProgramUniform2fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat * value)
{
return glbinding::Binding::ProgramUniform2fvEXT(program, location, count, value);
}
inline void glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
{
return glbinding::Binding::ProgramUniform2i(program, location, v0, v1);
}
inline void glProgramUniform2i64NV(GLuint program, GLint location, GLint64EXT x, GLint64EXT y)
{
return glbinding::Binding::ProgramUniform2i64NV(program, location, x, y);
}
inline void glProgramUniform2i64vNV(GLuint program, GLint location, GLsizei count, const GLint64EXT * value)
{
return glbinding::Binding::ProgramUniform2i64vNV(program, location, count, value);
}
inline void glProgramUniform2iEXT(GLuint program, GLint location, GLint v0, GLint v1)
{
return glbinding::Binding::ProgramUniform2iEXT(program, location, v0, v1);
}
inline void glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint * value)
{
return glbinding::Binding::ProgramUniform2iv(program, location, count, value);
}
inline void glProgramUniform2ivEXT(GLuint program, GLint location, GLsizei count, const GLint * value)
{
return glbinding::Binding::ProgramUniform2ivEXT(program, location, count, value);
}
inline void glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
{
return glbinding::Binding::ProgramUniform2ui(program, location, v0, v1);
}
inline void glProgramUniform2ui64NV(GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y)
{
return glbinding::Binding::ProgramUniform2ui64NV(program, location, x, y);
}
inline void glProgramUniform2ui64vNV(GLuint program, GLint location, GLsizei count, const GLuint64EXT * value)
{
return glbinding::Binding::ProgramUniform2ui64vNV(program, location, count, value);
}
inline void glProgramUniform2uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1)
{
return glbinding::Binding::ProgramUniform2uiEXT(program, location, v0, v1);
}
inline void glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint * value)
{
return glbinding::Binding::ProgramUniform2uiv(program, location, count, value);
}
inline void glProgramUniform2uivEXT(GLuint program, GLint location, GLsizei count, const GLuint * value)
{
return glbinding::Binding::ProgramUniform2uivEXT(program, location, count, value);
}
inline void glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
{
return glbinding::Binding::ProgramUniform3d(program, location, v0, v1, v2);
}
inline void glProgramUniform3dEXT(GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z)
{
return glbinding::Binding::ProgramUniform3dEXT(program, location, x, y, z);
}
inline void glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble * value)
{
return glbinding::Binding::ProgramUniform3dv(program, location, count, value);
}
inline void glProgramUniform3dvEXT(GLuint program, GLint location, GLsizei count, const GLdouble * value)
{
return glbinding::Binding::ProgramUniform3dvEXT(program, location, count, value);
}
inline void glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
{
return glbinding::Binding::ProgramUniform3f(program, location, v0, v1, v2);
}
inline void glProgramUniform3fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
{
return glbinding::Binding::ProgramUniform3fEXT(program, location, v0, v1, v2);
}
inline void glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat * value)
{
return glbinding::Binding::ProgramUniform3fv(program, location, count, value);
}
inline void glProgramUniform3fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat * value)
{
return glbinding::Binding::ProgramUniform3fvEXT(program, location, count, value);
}
inline void glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
{
return glbinding::Binding::ProgramUniform3i(program, location, v0, v1, v2);
}
inline void glProgramUniform3i64NV(GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z)
{
return glbinding::Binding::ProgramUniform3i64NV(program, location, x, y, z);
}
inline void glProgramUniform3i64vNV(GLuint program, GLint location, GLsizei count, const GLint64EXT * value)
{
return glbinding::Binding::ProgramUniform3i64vNV(program, location, count, value);
}
inline void glProgramUniform3iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
{
return glbinding::Binding::ProgramUniform3iEXT(program, location, v0, v1, v2);
}
inline void glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint * value)
{
return glbinding::Binding::ProgramUniform3iv(program, location, count, value);
}
inline void glProgramUniform3ivEXT(GLuint program, GLint location, GLsizei count, const GLint * value)
{
return glbinding::Binding::ProgramUniform3ivEXT(program, location, count, value);
}
inline void glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
{
return glbinding::Binding::ProgramUniform3ui(program, location, v0, v1, v2);
}
inline void glProgramUniform3ui64NV(GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z)
{
return glbinding::Binding::ProgramUniform3ui64NV(program, location, x, y, z);
}
inline void glProgramUniform3ui64vNV(GLuint program, GLint location, GLsizei count, const GLuint64EXT * value)
{
return glbinding::Binding::ProgramUniform3ui64vNV(program, location, count, value);
}
inline void glProgramUniform3uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
{
return glbinding::Binding::ProgramUniform3uiEXT(program, location, v0, v1, v2);
}
inline void glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint * value)
{
return glbinding::Binding::ProgramUniform3uiv(program, location, count, value);
}
inline void glProgramUniform3uivEXT(GLuint program, GLint location, GLsizei count, const GLuint * value)
{
return glbinding::Binding::ProgramUniform3uivEXT(program, location, count, value);
}
inline void glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
{
return glbinding::Binding::ProgramUniform4d(program, location, v0, v1, v2, v3);
}
inline void glProgramUniform4dEXT(GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
return glbinding::Binding::ProgramUniform4dEXT(program, location, x, y, z, w);
}
inline void glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble * value)
{
return glbinding::Binding::ProgramUniform4dv(program, location, count, value);
}
inline void glProgramUniform4dvEXT(GLuint program, GLint location, GLsizei count, const GLdouble * value)
{
return glbinding::Binding::ProgramUniform4dvEXT(program, location, count, value);
}
inline void glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
{
return glbinding::Binding::ProgramUniform4f(program, location, v0, v1, v2, v3);
}
inline void glProgramUniform4fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
{
return glbinding::Binding::ProgramUniform4fEXT(program, location, v0, v1, v2, v3);
}
inline void glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat * value)
{
return glbinding::Binding::ProgramUniform4fv(program, location, count, value);
}
inline void glProgramUniform4fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat * value)
{
return glbinding::Binding::ProgramUniform4fvEXT(program, location, count, value);
}
inline void glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
{
return glbinding::Binding::ProgramUniform4i(program, location, v0, v1, v2, v3);
}
inline void glProgramUniform4i64NV(GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w)
{
return glbinding::Binding::ProgramUniform4i64NV(program, location, x, y, z, w);
}
inline void glProgramUniform4i64vNV(GLuint program, GLint location, GLsizei count, const GLint64EXT * value)
{
return glbinding::Binding::ProgramUniform4i64vNV(program, location, count, value);
}
inline void glProgramUniform4iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
{
return glbinding::Binding::ProgramUniform4iEXT(program, location, v0, v1, v2, v3);
}
inline void glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint * value)
{
return glbinding::Binding::ProgramUniform4iv(program, location, count, value);
}
inline void glProgramUniform4ivEXT(GLuint program, GLint location, GLsizei count, const GLint * value)
{
return glbinding::Binding::ProgramUniform4ivEXT(program, location, count, value);
}
inline void glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
{
return glbinding::Binding::ProgramUniform4ui(program, location, v0, v1, v2, v3);
}
inline void glProgramUniform4ui64NV(GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w)
{
return glbinding::Binding::ProgramUniform4ui64NV(program, location, x, y, z, w);
}
inline void glProgramUniform4ui64vNV(GLuint program, GLint location, GLsizei count, const GLuint64EXT * value)
{
return glbinding::Binding::ProgramUniform4ui64vNV(program, location, count, value);
}
inline void glProgramUniform4uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
{
return glbinding::Binding::ProgramUniform4uiEXT(program, location, v0, v1, v2, v3);
}
inline void glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint * value)
{
return glbinding::Binding::ProgramUniform4uiv(program, location, count, value);
}
inline void glProgramUniform4uivEXT(GLuint program, GLint location, GLsizei count, const GLuint * value)
{
return glbinding::Binding::ProgramUniform4uivEXT(program, location, count, value);
}
inline void glProgramUniformHandleui64ARB(GLuint program, GLint location, GLuint64 value)
{
return glbinding::Binding::ProgramUniformHandleui64ARB(program, location, value);
}
inline void glProgramUniformHandleui64NV(GLuint program, GLint location, GLuint64 value)
{
return glbinding::Binding::ProgramUniformHandleui64NV(program, location, value);
}
inline void glProgramUniformHandleui64vARB(GLuint program, GLint location, GLsizei count, const GLuint64 * values)
{
return glbinding::Binding::ProgramUniformHandleui64vARB(program, location, count, values);
}
inline void glProgramUniformHandleui64vNV(GLuint program, GLint location, GLsizei count, const GLuint64 * values)
{
return glbinding::Binding::ProgramUniformHandleui64vNV(program, location, count, values);
}
inline void glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
return glbinding::Binding::ProgramUniformMatrix2dv(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix2dvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
return glbinding::Binding::ProgramUniformMatrix2dvEXT(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::ProgramUniformMatrix2fv(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix2fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::ProgramUniformMatrix2fvEXT(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
return glbinding::Binding::ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix2x3dvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
return glbinding::Binding::ProgramUniformMatrix2x3dvEXT(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix2x3fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::ProgramUniformMatrix2x3fvEXT(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
return glbinding::Binding::ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix2x4dvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
return glbinding::Binding::ProgramUniformMatrix2x4dvEXT(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix2x4fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::ProgramUniformMatrix2x4fvEXT(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
return glbinding::Binding::ProgramUniformMatrix3dv(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix3dvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
return glbinding::Binding::ProgramUniformMatrix3dvEXT(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::ProgramUniformMatrix3fv(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix3fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::ProgramUniformMatrix3fvEXT(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
return glbinding::Binding::ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix3x2dvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
return glbinding::Binding::ProgramUniformMatrix3x2dvEXT(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix3x2fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::ProgramUniformMatrix3x2fvEXT(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
return glbinding::Binding::ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix3x4dvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
return glbinding::Binding::ProgramUniformMatrix3x4dvEXT(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix3x4fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::ProgramUniformMatrix3x4fvEXT(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
return glbinding::Binding::ProgramUniformMatrix4dv(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix4dvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
return glbinding::Binding::ProgramUniformMatrix4dvEXT(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::ProgramUniformMatrix4fv(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix4fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::ProgramUniformMatrix4fvEXT(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
return glbinding::Binding::ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix4x2dvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
return glbinding::Binding::ProgramUniformMatrix4x2dvEXT(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix4x2fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::ProgramUniformMatrix4x2fvEXT(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
return glbinding::Binding::ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix4x3dvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
return glbinding::Binding::ProgramUniformMatrix4x3dvEXT(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
}
inline void glProgramUniformMatrix4x3fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::ProgramUniformMatrix4x3fvEXT(program, location, count, transpose, value);
}
inline void glProgramUniformui64NV(GLuint program, GLint location, GLuint64EXT value)
{
return glbinding::Binding::ProgramUniformui64NV(program, location, value);
}
inline void glProgramUniformui64vNV(GLuint program, GLint location, GLsizei count, const GLuint64EXT * value)
{
return glbinding::Binding::ProgramUniformui64vNV(program, location, count, value);
}
inline void glProgramVertexLimitNV(GLenum target, GLint limit)
{
return glbinding::Binding::ProgramVertexLimitNV(target, limit);
}
inline void glProvokingVertex(GLenum mode)
{
return glbinding::Binding::ProvokingVertex(mode);
}
inline void glProvokingVertexEXT(GLenum mode)
{
return glbinding::Binding::ProvokingVertexEXT(mode);
}
inline void glPushClientAttribDefaultEXT(ClientAttribMask mask)
{
return glbinding::Binding::PushClientAttribDefaultEXT(mask);
}
inline void glPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar * message)
{
return glbinding::Binding::PushDebugGroup(source, id, length, message);
}
inline void glPushGroupMarkerEXT(GLsizei length, const GLchar * marker)
{
return glbinding::Binding::PushGroupMarkerEXT(length, marker);
}
inline void glQueryCounter(GLuint id, GLenum target)
{
return glbinding::Binding::QueryCounter(id, target);
}
inline GLbitfield glQueryMatrixxOES(GLfixed * mantissa, GLint * exponent)
{
return static_cast<gl14ext::GLbitfield>(glbinding::Binding::QueryMatrixxOES(mantissa, exponent));
}
inline void glQueryObjectParameteruiAMD(GLenum target, GLuint id, GLenum pname, GLuint param)
{
return glbinding::Binding::QueryObjectParameteruiAMD(target, id, pname, param);
}
inline void glRasterPos2xOES(GLfixed x, GLfixed y)
{
return glbinding::Binding::RasterPos2xOES(x, y);
}
inline void glRasterPos2xvOES(const GLfixed * coords)
{
return glbinding::Binding::RasterPos2xvOES(coords);
}
inline void glRasterPos3xOES(GLfixed x, GLfixed y, GLfixed z)
{
return glbinding::Binding::RasterPos3xOES(x, y, z);
}
inline void glRasterPos3xvOES(const GLfixed * coords)
{
return glbinding::Binding::RasterPos3xvOES(coords);
}
inline void glRasterPos4xOES(GLfixed x, GLfixed y, GLfixed z, GLfixed w)
{
return glbinding::Binding::RasterPos4xOES(x, y, z, w);
}
inline void glRasterPos4xvOES(const GLfixed * coords)
{
return glbinding::Binding::RasterPos4xvOES(coords);
}
inline void glRasterSamplesEXT(GLuint samples, GLboolean fixedsamplelocations)
{
return glbinding::Binding::RasterSamplesEXT(samples, fixedsamplelocations);
}
inline void glReadInstrumentsSGIX(GLint marker)
{
return glbinding::Binding::ReadInstrumentsSGIX(marker);
}
inline void glReadnPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void * data)
{
return glbinding::Binding::ReadnPixels(x, y, width, height, format, type, bufSize, data);
}
inline void glReadnPixelsARB(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void * data)
{
return glbinding::Binding::ReadnPixelsARB(x, y, width, height, format, type, bufSize, data);
}
inline void glRectxOES(GLfixed x1, GLfixed y1, GLfixed x2, GLfixed y2)
{
return glbinding::Binding::RectxOES(x1, y1, x2, y2);
}
inline void glRectxvOES(const GLfixed * v1, const GLfixed * v2)
{
return glbinding::Binding::RectxvOES(v1, v2);
}
inline void glReferencePlaneSGIX(const GLdouble * equation)
{
return glbinding::Binding::ReferencePlaneSGIX(equation);
}
inline void glReleaseShaderCompiler()
{
return glbinding::Binding::ReleaseShaderCompiler();
}
inline void glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
{
return glbinding::Binding::RenderbufferStorage(target, internalformat, width, height);
}
inline void glRenderbufferStorageEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
{
return glbinding::Binding::RenderbufferStorageEXT(target, internalformat, width, height);
}
inline void glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
{
return glbinding::Binding::RenderbufferStorageMultisample(target, samples, internalformat, width, height);
}
inline void glRenderbufferStorageMultisampleCoverageNV(GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height)
{
return glbinding::Binding::RenderbufferStorageMultisampleCoverageNV(target, coverageSamples, colorSamples, internalformat, width, height);
}
inline void glRenderbufferStorageMultisampleEXT(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
{
return glbinding::Binding::RenderbufferStorageMultisampleEXT(target, samples, internalformat, width, height);
}
inline void glReplacementCodePointerSUN(GLenum type, GLsizei stride, const void ** pointer)
{
return glbinding::Binding::ReplacementCodePointerSUN(type, stride, pointer);
}
inline void glReplacementCodeubSUN(GLubyte code)
{
return glbinding::Binding::ReplacementCodeubSUN(code);
}
inline void glReplacementCodeubvSUN(const GLubyte * code)
{
return glbinding::Binding::ReplacementCodeubvSUN(code);
}
inline void glReplacementCodeuiColor3fVertex3fSUN(GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)
{
return glbinding::Binding::ReplacementCodeuiColor3fVertex3fSUN(rc, r, g, b, x, y, z);
}
inline void glReplacementCodeuiColor3fVertex3fvSUN(const GLuint * rc, const GLfloat * c, const GLfloat * v)
{
return glbinding::Binding::ReplacementCodeuiColor3fVertex3fvSUN(rc, c, v);
}
inline void glReplacementCodeuiColor4fNormal3fVertex3fSUN(GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
{
return glbinding::Binding::ReplacementCodeuiColor4fNormal3fVertex3fSUN(rc, r, g, b, a, nx, ny, nz, x, y, z);
}
inline void glReplacementCodeuiColor4fNormal3fVertex3fvSUN(const GLuint * rc, const GLfloat * c, const GLfloat * n, const GLfloat * v)
{
return glbinding::Binding::ReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, c, n, v);
}
inline void glReplacementCodeuiColor4ubVertex3fSUN(GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z)
{
return glbinding::Binding::ReplacementCodeuiColor4ubVertex3fSUN(rc, r, g, b, a, x, y, z);
}
inline void glReplacementCodeuiColor4ubVertex3fvSUN(const GLuint * rc, const GLubyte * c, const GLfloat * v)
{
return glbinding::Binding::ReplacementCodeuiColor4ubVertex3fvSUN(rc, c, v);
}
inline void glReplacementCodeuiNormal3fVertex3fSUN(GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
{
return glbinding::Binding::ReplacementCodeuiNormal3fVertex3fSUN(rc, nx, ny, nz, x, y, z);
}
inline void glReplacementCodeuiNormal3fVertex3fvSUN(const GLuint * rc, const GLfloat * n, const GLfloat * v)
{
return glbinding::Binding::ReplacementCodeuiNormal3fVertex3fvSUN(rc, n, v);
}
inline void glReplacementCodeuiSUN(GLuint code)
{
return glbinding::Binding::ReplacementCodeuiSUN(code);
}
inline void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(GLuint rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
{
return glbinding::Binding::ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(rc, s, t, r, g, b, a, nx, ny, nz, x, y, z);
}
inline void glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(const GLuint * rc, const GLfloat * tc, const GLfloat * c, const GLfloat * n, const GLfloat * v)
{
return glbinding::Binding::ReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, c, n, v);
}
inline void glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
{
return glbinding::Binding::ReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(rc, s, t, nx, ny, nz, x, y, z);
}
inline void glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(const GLuint * rc, const GLfloat * tc, const GLfloat * n, const GLfloat * v)
{
return glbinding::Binding::ReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, tc, n, v);
}
inline void glReplacementCodeuiTexCoord2fVertex3fSUN(GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z)
{
return glbinding::Binding::ReplacementCodeuiTexCoord2fVertex3fSUN(rc, s, t, x, y, z);
}
inline void glReplacementCodeuiTexCoord2fVertex3fvSUN(const GLuint * rc, const GLfloat * tc, const GLfloat * v)
{
return glbinding::Binding::ReplacementCodeuiTexCoord2fVertex3fvSUN(rc, tc, v);
}
inline void glReplacementCodeuiVertex3fSUN(GLuint rc, GLfloat x, GLfloat y, GLfloat z)
{
return glbinding::Binding::ReplacementCodeuiVertex3fSUN(rc, x, y, z);
}
inline void glReplacementCodeuiVertex3fvSUN(const GLuint * rc, const GLfloat * v)
{
return glbinding::Binding::ReplacementCodeuiVertex3fvSUN(rc, v);
}
inline void glReplacementCodeuivSUN(const GLuint * code)
{
return glbinding::Binding::ReplacementCodeuivSUN(code);
}
inline void glReplacementCodeusSUN(GLushort code)
{
return glbinding::Binding::ReplacementCodeusSUN(code);
}
inline void glReplacementCodeusvSUN(const GLushort * code)
{
return glbinding::Binding::ReplacementCodeusvSUN(code);
}
inline void glRequestResidentProgramsNV(GLsizei n, const GLuint * programs)
{
return glbinding::Binding::RequestResidentProgramsNV(n, programs);
}
inline void glResetHistogram(GLenum target)
{
return glbinding::Binding::ResetHistogram(target);
}
inline void glResetHistogramEXT(GLenum target)
{
return glbinding::Binding::ResetHistogramEXT(target);
}
inline void glResetMinmax(GLenum target)
{
return glbinding::Binding::ResetMinmax(target);
}
inline void glResetMinmaxEXT(GLenum target)
{
return glbinding::Binding::ResetMinmaxEXT(target);
}
inline void glResizeBuffersMESA()
{
return glbinding::Binding::ResizeBuffersMESA();
}
inline void glResolveDepthValuesNV()
{
return glbinding::Binding::ResolveDepthValuesNV();
}
inline void glResumeTransformFeedback()
{
return glbinding::Binding::ResumeTransformFeedback();
}
inline void glResumeTransformFeedbackNV()
{
return glbinding::Binding::ResumeTransformFeedbackNV();
}
inline void glRotatexOES(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
{
return glbinding::Binding::RotatexOES(angle, x, y, z);
}
inline void glSampleCoverageARB(GLfloat value, GLboolean invert)
{
return glbinding::Binding::SampleCoverageARB(value, invert);
}
inline void glSampleCoverageOES(GLfixed value, GLboolean invert)
{
return glbinding::Binding::SampleCoverageOES(value, invert);
}
inline void glSampleMapATI(GLuint dst, GLuint interp, GLenum swizzle)
{
return glbinding::Binding::SampleMapATI(dst, interp, swizzle);
}
inline void glSampleMaskEXT(GLclampf value, GLboolean invert)
{
return glbinding::Binding::SampleMaskEXT(value, invert);
}
inline void glSampleMaskIndexedNV(GLuint index, GLbitfield mask)
{
return glbinding::Binding::SampleMaskIndexedNV(index, mask);
}
inline void glSampleMaskSGIS(GLclampf value, GLboolean invert)
{
return glbinding::Binding::SampleMaskSGIS(value, invert);
}
inline void glSampleMaski(GLuint maskNumber, GLbitfield mask)
{
return glbinding::Binding::SampleMaski(maskNumber, mask);
}
inline void glSamplePatternEXT(GLenum pattern)
{
return glbinding::Binding::SamplePatternEXT(pattern);
}
inline void glSamplePatternSGIS(GLenum pattern)
{
return glbinding::Binding::SamplePatternSGIS(pattern);
}
inline void glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint * param)
{
return glbinding::Binding::SamplerParameterIiv(sampler, pname, param);
}
inline void glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint * param)
{
return glbinding::Binding::SamplerParameterIuiv(sampler, pname, param);
}
inline void glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
{
return glbinding::Binding::SamplerParameterf(sampler, pname, param);
}
inline void glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat * param)
{
return glbinding::Binding::SamplerParameterfv(sampler, pname, param);
}
inline void glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
{
return glbinding::Binding::SamplerParameteri(sampler, pname, param);
}
inline void glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint * param)
{
return glbinding::Binding::SamplerParameteriv(sampler, pname, param);
}
inline void glScalexOES(GLfixed x, GLfixed y, GLfixed z)
{
return glbinding::Binding::ScalexOES(x, y, z);
}
inline void glScissorArrayv(GLuint first, GLsizei count, const GLint * v)
{
return glbinding::Binding::ScissorArrayv(first, count, v);
}
inline void glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
{
return glbinding::Binding::ScissorIndexed(index, left, bottom, width, height);
}
inline void glScissorIndexedv(GLuint index, const GLint * v)
{
return glbinding::Binding::ScissorIndexedv(index, v);
}
inline void glSecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue)
{
return glbinding::Binding::SecondaryColor3bEXT(red, green, blue);
}
inline void glSecondaryColor3bvEXT(const GLbyte * v)
{
return glbinding::Binding::SecondaryColor3bvEXT(v);
}
inline void glSecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue)
{
return glbinding::Binding::SecondaryColor3dEXT(red, green, blue);
}
inline void glSecondaryColor3dvEXT(const GLdouble * v)
{
return glbinding::Binding::SecondaryColor3dvEXT(v);
}
inline void glSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue)
{
return glbinding::Binding::SecondaryColor3fEXT(red, green, blue);
}
inline void glSecondaryColor3fvEXT(const GLfloat * v)
{
return glbinding::Binding::SecondaryColor3fvEXT(v);
}
inline void glSecondaryColor3hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue)
{
return glbinding::Binding::SecondaryColor3hNV(red, green, blue);
}
inline void glSecondaryColor3hvNV(const GLhalfNV * v)
{
return glbinding::Binding::SecondaryColor3hvNV(v);
}
inline void glSecondaryColor3iEXT(GLint red, GLint green, GLint blue)
{
return glbinding::Binding::SecondaryColor3iEXT(red, green, blue);
}
inline void glSecondaryColor3ivEXT(const GLint * v)
{
return glbinding::Binding::SecondaryColor3ivEXT(v);
}
inline void glSecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue)
{
return glbinding::Binding::SecondaryColor3sEXT(red, green, blue);
}
inline void glSecondaryColor3svEXT(const GLshort * v)
{
return glbinding::Binding::SecondaryColor3svEXT(v);
}
inline void glSecondaryColor3ubEXT(GLubyte red, GLubyte green, GLubyte blue)
{
return glbinding::Binding::SecondaryColor3ubEXT(red, green, blue);
}
inline void glSecondaryColor3ubvEXT(const GLubyte * v)
{
return glbinding::Binding::SecondaryColor3ubvEXT(v);
}
inline void glSecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue)
{
return glbinding::Binding::SecondaryColor3uiEXT(red, green, blue);
}
inline void glSecondaryColor3uivEXT(const GLuint * v)
{
return glbinding::Binding::SecondaryColor3uivEXT(v);
}
inline void glSecondaryColor3usEXT(GLushort red, GLushort green, GLushort blue)
{
return glbinding::Binding::SecondaryColor3usEXT(red, green, blue);
}
inline void glSecondaryColor3usvEXT(const GLushort * v)
{
return glbinding::Binding::SecondaryColor3usvEXT(v);
}
inline void glSecondaryColorFormatNV(GLint size, GLenum type, GLsizei stride)
{
return glbinding::Binding::SecondaryColorFormatNV(size, type, stride);
}
inline void glSecondaryColorP3ui(GLenum type, GLuint color)
{
return glbinding::Binding::SecondaryColorP3ui(type, color);
}
inline void glSecondaryColorP3uiv(GLenum type, const GLuint * color)
{
return glbinding::Binding::SecondaryColorP3uiv(type, color);
}
inline void glSecondaryColorPointerEXT(GLint size, GLenum type, GLsizei stride, const void * pointer)
{
return glbinding::Binding::SecondaryColorPointerEXT(size, type, stride, pointer);
}
inline void glSecondaryColorPointerListIBM(GLint size, GLenum type, GLint stride, const void ** pointer, GLint ptrstride)
{
return glbinding::Binding::SecondaryColorPointerListIBM(size, type, stride, pointer, ptrstride);
}
inline void glSelectPerfMonitorCountersAMD(GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint * counterList)
{
return glbinding::Binding::SelectPerfMonitorCountersAMD(monitor, enable, group, numCounters, counterList);
}
inline void glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * row, const void * column)
{
return glbinding::Binding::SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
}
inline void glSeparableFilter2DEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * row, const void * column)
{
return glbinding::Binding::SeparableFilter2DEXT(target, internalformat, width, height, format, type, row, column);
}
inline void glSetFenceAPPLE(GLuint fence)
{
return glbinding::Binding::SetFenceAPPLE(fence);
}
inline void glSetFenceNV(GLuint fence, GLenum condition)
{
return glbinding::Binding::SetFenceNV(fence, condition);
}
inline void glSetFragmentShaderConstantATI(GLuint dst, const GLfloat * value)
{
return glbinding::Binding::SetFragmentShaderConstantATI(dst, value);
}
inline void glSetInvariantEXT(GLuint id, GLenum type, const void * addr)
{
return glbinding::Binding::SetInvariantEXT(id, type, addr);
}
inline void glSetLocalConstantEXT(GLuint id, GLenum type, const void * addr)
{
return glbinding::Binding::SetLocalConstantEXT(id, type, addr);
}
inline void glSetMultisamplefvAMD(GLenum pname, GLuint index, const GLfloat * val)
{
return glbinding::Binding::SetMultisamplefvAMD(pname, index, val);
}
inline void glShaderBinary(GLsizei count, const GLuint * shaders, GLenum binaryformat, const void * binary, GLsizei length)
{
return glbinding::Binding::ShaderBinary(count, shaders, binaryformat, binary, length);
}
inline void glShaderOp1EXT(GLenum op, GLuint res, GLuint arg1)
{
return glbinding::Binding::ShaderOp1EXT(op, res, arg1);
}
inline void glShaderOp2EXT(GLenum op, GLuint res, GLuint arg1, GLuint arg2)
{
return glbinding::Binding::ShaderOp2EXT(op, res, arg1, arg2);
}
inline void glShaderOp3EXT(GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3)
{
return glbinding::Binding::ShaderOp3EXT(op, res, arg1, arg2, arg3);
}
inline void glShaderSource(GLuint shader, GLsizei count, const GLchar *const* string, const GLint * length)
{
return glbinding::Binding::ShaderSource(shader, count, string, length);
}
inline void glShaderSourceARB(GLhandleARB shaderObj, GLsizei count, const GLcharARB ** string, const GLint * length)
{
return glbinding::Binding::ShaderSourceARB(shaderObj, count, string, length);
}
inline void glShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding)
{
return glbinding::Binding::ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
}
inline void glSharpenTexFuncSGIS(GLenum target, GLsizei n, const GLfloat * points)
{
return glbinding::Binding::SharpenTexFuncSGIS(target, n, points);
}
inline void glSpriteParameterfSGIX(GLenum pname, GLfloat param)
{
return glbinding::Binding::SpriteParameterfSGIX(pname, param);
}
inline void glSpriteParameterfvSGIX(GLenum pname, const GLfloat * params)
{
return glbinding::Binding::SpriteParameterfvSGIX(pname, params);
}
inline void glSpriteParameteriSGIX(GLenum pname, GLint param)
{
return glbinding::Binding::SpriteParameteriSGIX(pname, param);
}
inline void glSpriteParameterivSGIX(GLenum pname, const GLint * params)
{
return glbinding::Binding::SpriteParameterivSGIX(pname, params);
}
inline void glStartInstrumentsSGIX()
{
return glbinding::Binding::StartInstrumentsSGIX();
}
inline void glStencilClearTagEXT(GLsizei stencilTagBits, GLuint stencilClearTag)
{
return glbinding::Binding::StencilClearTagEXT(stencilTagBits, stencilClearTag);
}
inline void glStencilFillPathInstancedNV(GLsizei numPaths, GLenum pathNameType, const void * paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum transformType, const GLfloat * transformValues)
{
return glbinding::Binding::StencilFillPathInstancedNV(numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues);
}
inline void glStencilFillPathNV(GLuint path, GLenum fillMode, GLuint mask)
{
return glbinding::Binding::StencilFillPathNV(path, fillMode, mask);
}
inline void glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
{
return glbinding::Binding::StencilFuncSeparate(face, func, ref, mask);
}
inline void glStencilFuncSeparateATI(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask)
{
return glbinding::Binding::StencilFuncSeparateATI(frontfunc, backfunc, ref, mask);
}
inline void glStencilMaskSeparate(GLenum face, GLuint mask)
{
return glbinding::Binding::StencilMaskSeparate(face, mask);
}
inline void glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
{
return glbinding::Binding::StencilOpSeparate(face, sfail, dpfail, dppass);
}
inline void glStencilOpSeparateATI(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
{
return glbinding::Binding::StencilOpSeparateATI(face, sfail, dpfail, dppass);
}
inline void glStencilOpValueAMD(GLenum face, GLuint value)
{
return glbinding::Binding::StencilOpValueAMD(face, value);
}
inline void glStencilStrokePathInstancedNV(GLsizei numPaths, GLenum pathNameType, const void * paths, GLuint pathBase, GLint reference, GLuint mask, GLenum transformType, const GLfloat * transformValues)
{
return glbinding::Binding::StencilStrokePathInstancedNV(numPaths, pathNameType, paths, pathBase, reference, mask, transformType, transformValues);
}
inline void glStencilStrokePathNV(GLuint path, GLint reference, GLuint mask)
{
return glbinding::Binding::StencilStrokePathNV(path, reference, mask);
}
inline void glStencilThenCoverFillPathInstancedNV(GLsizei numPaths, GLenum pathNameType, const void * paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat * transformValues)
{
return glbinding::Binding::StencilThenCoverFillPathInstancedNV(numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode, transformType, transformValues);
}
inline void glStencilThenCoverFillPathNV(GLuint path, GLenum fillMode, GLuint mask, GLenum coverMode)
{
return glbinding::Binding::StencilThenCoverFillPathNV(path, fillMode, mask, coverMode);
}
inline void glStencilThenCoverStrokePathInstancedNV(GLsizei numPaths, GLenum pathNameType, const void * paths, GLuint pathBase, GLint reference, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat * transformValues)
{
return glbinding::Binding::StencilThenCoverStrokePathInstancedNV(numPaths, pathNameType, paths, pathBase, reference, mask, coverMode, transformType, transformValues);
}
inline void glStencilThenCoverStrokePathNV(GLuint path, GLint reference, GLuint mask, GLenum coverMode)
{
return glbinding::Binding::StencilThenCoverStrokePathNV(path, reference, mask, coverMode);
}
inline void glStopInstrumentsSGIX(GLint marker)
{
return glbinding::Binding::StopInstrumentsSGIX(marker);
}
inline void glStringMarkerGREMEDY(GLsizei len, const void * string)
{
return glbinding::Binding::StringMarkerGREMEDY(len, string);
}
inline void glSubpixelPrecisionBiasNV(GLuint xbits, GLuint ybits)
{
return glbinding::Binding::SubpixelPrecisionBiasNV(xbits, ybits);
}
inline void glSwizzleEXT(GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW)
{
return glbinding::Binding::SwizzleEXT(res, in, outX, outY, outZ, outW);
}
inline void glSyncTextureINTEL(GLuint texture)
{
return glbinding::Binding::SyncTextureINTEL(texture);
}
inline void glTagSampleBufferSGIX()
{
return glbinding::Binding::TagSampleBufferSGIX();
}
inline void glTangent3bEXT(GLbyte tx, GLbyte ty, GLbyte tz)
{
return glbinding::Binding::Tangent3bEXT(tx, ty, tz);
}
inline void glTangent3bvEXT(const GLbyte * v)
{
return glbinding::Binding::Tangent3bvEXT(v);
}
inline void glTangent3dEXT(GLdouble tx, GLdouble ty, GLdouble tz)
{
return glbinding::Binding::Tangent3dEXT(tx, ty, tz);
}
inline void glTangent3dvEXT(const GLdouble * v)
{
return glbinding::Binding::Tangent3dvEXT(v);
}
inline void glTangent3fEXT(GLfloat tx, GLfloat ty, GLfloat tz)
{
return glbinding::Binding::Tangent3fEXT(tx, ty, tz);
}
inline void glTangent3fvEXT(const GLfloat * v)
{
return glbinding::Binding::Tangent3fvEXT(v);
}
inline void glTangent3iEXT(GLint tx, GLint ty, GLint tz)
{
return glbinding::Binding::Tangent3iEXT(tx, ty, tz);
}
inline void glTangent3ivEXT(const GLint * v)
{
return glbinding::Binding::Tangent3ivEXT(v);
}
inline void glTangent3sEXT(GLshort tx, GLshort ty, GLshort tz)
{
return glbinding::Binding::Tangent3sEXT(tx, ty, tz);
}
inline void glTangent3svEXT(const GLshort * v)
{
return glbinding::Binding::Tangent3svEXT(v);
}
inline void glTangentPointerEXT(GLenum type, GLsizei stride, const void * pointer)
{
return glbinding::Binding::TangentPointerEXT(type, stride, pointer);
}
inline void glTbufferMask3DFX(GLuint mask)
{
return glbinding::Binding::TbufferMask3DFX(mask);
}
inline void glTessellationFactorAMD(GLfloat factor)
{
return glbinding::Binding::TessellationFactorAMD(factor);
}
inline void glTessellationModeAMD(GLenum mode)
{
return glbinding::Binding::TessellationModeAMD(mode);
}
inline GLboolean glTestFenceAPPLE(GLuint fence)
{
return glbinding::Binding::TestFenceAPPLE(fence);
}
inline GLboolean glTestFenceNV(GLuint fence)
{
return glbinding::Binding::TestFenceNV(fence);
}
inline GLboolean glTestObjectAPPLE(GLenum object, GLuint name)
{
return glbinding::Binding::TestObjectAPPLE(object, name);
}
inline void glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
{
return glbinding::Binding::TexBuffer(target, internalformat, buffer);
}
inline void glTexBufferARB(GLenum target, GLenum internalformat, GLuint buffer)
{
return glbinding::Binding::TexBufferARB(target, internalformat, buffer);
}
inline void glTexBufferEXT(GLenum target, GLenum internalformat, GLuint buffer)
{
return glbinding::Binding::TexBufferEXT(target, internalformat, buffer);
}
inline void glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
{
return glbinding::Binding::TexBufferRange(target, internalformat, buffer, offset, size);
}
inline void glTexBumpParameterfvATI(GLenum pname, const GLfloat * param)
{
return glbinding::Binding::TexBumpParameterfvATI(pname, param);
}
inline void glTexBumpParameterivATI(GLenum pname, const GLint * param)
{
return glbinding::Binding::TexBumpParameterivATI(pname, param);
}
inline void glTexCoord1bOES(GLbyte s)
{
return glbinding::Binding::TexCoord1bOES(s);
}
inline void glTexCoord1bvOES(const GLbyte * coords)
{
return glbinding::Binding::TexCoord1bvOES(coords);
}
inline void glTexCoord1hNV(GLhalfNV s)
{
return glbinding::Binding::TexCoord1hNV(s);
}
inline void glTexCoord1hvNV(const GLhalfNV * v)
{
return glbinding::Binding::TexCoord1hvNV(v);
}
inline void glTexCoord1xOES(GLfixed s)
{
return glbinding::Binding::TexCoord1xOES(s);
}
inline void glTexCoord1xvOES(const GLfixed * coords)
{
return glbinding::Binding::TexCoord1xvOES(coords);
}
inline void glTexCoord2bOES(GLbyte s, GLbyte t)
{
return glbinding::Binding::TexCoord2bOES(s, t);
}
inline void glTexCoord2bvOES(const GLbyte * coords)
{
return glbinding::Binding::TexCoord2bvOES(coords);
}
inline void glTexCoord2fColor3fVertex3fSUN(GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)
{
return glbinding::Binding::TexCoord2fColor3fVertex3fSUN(s, t, r, g, b, x, y, z);
}
inline void glTexCoord2fColor3fVertex3fvSUN(const GLfloat * tc, const GLfloat * c, const GLfloat * v)
{
return glbinding::Binding::TexCoord2fColor3fVertex3fvSUN(tc, c, v);
}
inline void glTexCoord2fColor4fNormal3fVertex3fSUN(GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
{
return glbinding::Binding::TexCoord2fColor4fNormal3fVertex3fSUN(s, t, r, g, b, a, nx, ny, nz, x, y, z);
}
inline void glTexCoord2fColor4fNormal3fVertex3fvSUN(const GLfloat * tc, const GLfloat * c, const GLfloat * n, const GLfloat * v)
{
return glbinding::Binding::TexCoord2fColor4fNormal3fVertex3fvSUN(tc, c, n, v);
}
inline void glTexCoord2fColor4ubVertex3fSUN(GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z)
{
return glbinding::Binding::TexCoord2fColor4ubVertex3fSUN(s, t, r, g, b, a, x, y, z);
}
inline void glTexCoord2fColor4ubVertex3fvSUN(const GLfloat * tc, const GLubyte * c, const GLfloat * v)
{
return glbinding::Binding::TexCoord2fColor4ubVertex3fvSUN(tc, c, v);
}
inline void glTexCoord2fNormal3fVertex3fSUN(GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
{
return glbinding::Binding::TexCoord2fNormal3fVertex3fSUN(s, t, nx, ny, nz, x, y, z);
}
inline void glTexCoord2fNormal3fVertex3fvSUN(const GLfloat * tc, const GLfloat * n, const GLfloat * v)
{
return glbinding::Binding::TexCoord2fNormal3fVertex3fvSUN(tc, n, v);
}
inline void glTexCoord2fVertex3fSUN(GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z)
{
return glbinding::Binding::TexCoord2fVertex3fSUN(s, t, x, y, z);
}
inline void glTexCoord2fVertex3fvSUN(const GLfloat * tc, const GLfloat * v)
{
return glbinding::Binding::TexCoord2fVertex3fvSUN(tc, v);
}
inline void glTexCoord2hNV(GLhalfNV s, GLhalfNV t)
{
return glbinding::Binding::TexCoord2hNV(s, t);
}
inline void glTexCoord2hvNV(const GLhalfNV * v)
{
return glbinding::Binding::TexCoord2hvNV(v);
}
inline void glTexCoord2xOES(GLfixed s, GLfixed t)
{
return glbinding::Binding::TexCoord2xOES(s, t);
}
inline void glTexCoord2xvOES(const GLfixed * coords)
{
return glbinding::Binding::TexCoord2xvOES(coords);
}
inline void glTexCoord3bOES(GLbyte s, GLbyte t, GLbyte r)
{
return glbinding::Binding::TexCoord3bOES(s, t, r);
}
inline void glTexCoord3bvOES(const GLbyte * coords)
{
return glbinding::Binding::TexCoord3bvOES(coords);
}
inline void glTexCoord3hNV(GLhalfNV s, GLhalfNV t, GLhalfNV r)
{
return glbinding::Binding::TexCoord3hNV(s, t, r);
}
inline void glTexCoord3hvNV(const GLhalfNV * v)
{
return glbinding::Binding::TexCoord3hvNV(v);
}
inline void glTexCoord3xOES(GLfixed s, GLfixed t, GLfixed r)
{
return glbinding::Binding::TexCoord3xOES(s, t, r);
}
inline void glTexCoord3xvOES(const GLfixed * coords)
{
return glbinding::Binding::TexCoord3xvOES(coords);
}
inline void glTexCoord4bOES(GLbyte s, GLbyte t, GLbyte r, GLbyte q)
{
return glbinding::Binding::TexCoord4bOES(s, t, r, q);
}
inline void glTexCoord4bvOES(const GLbyte * coords)
{
return glbinding::Binding::TexCoord4bvOES(coords);
}
inline void glTexCoord4fColor4fNormal3fVertex4fSUN(GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
return glbinding::Binding::TexCoord4fColor4fNormal3fVertex4fSUN(s, t, p, q, r, g, b, a, nx, ny, nz, x, y, z, w);
}
inline void glTexCoord4fColor4fNormal3fVertex4fvSUN(const GLfloat * tc, const GLfloat * c, const GLfloat * n, const GLfloat * v)
{
return glbinding::Binding::TexCoord4fColor4fNormal3fVertex4fvSUN(tc, c, n, v);
}
inline void glTexCoord4fVertex4fSUN(GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
return glbinding::Binding::TexCoord4fVertex4fSUN(s, t, p, q, x, y, z, w);
}
inline void glTexCoord4fVertex4fvSUN(const GLfloat * tc, const GLfloat * v)
{
return glbinding::Binding::TexCoord4fVertex4fvSUN(tc, v);
}
inline void glTexCoord4hNV(GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q)
{
return glbinding::Binding::TexCoord4hNV(s, t, r, q);
}
inline void glTexCoord4hvNV(const GLhalfNV * v)
{
return glbinding::Binding::TexCoord4hvNV(v);
}
inline void glTexCoord4xOES(GLfixed s, GLfixed t, GLfixed r, GLfixed q)
{
return glbinding::Binding::TexCoord4xOES(s, t, r, q);
}
inline void glTexCoord4xvOES(const GLfixed * coords)
{
return glbinding::Binding::TexCoord4xvOES(coords);
}
inline void glTexCoordFormatNV(GLint size, GLenum type, GLsizei stride)
{
return glbinding::Binding::TexCoordFormatNV(size, type, stride);
}
inline void glTexCoordP1ui(GLenum type, GLuint coords)
{
return glbinding::Binding::TexCoordP1ui(type, coords);
}
inline void glTexCoordP1uiv(GLenum type, const GLuint * coords)
{
return glbinding::Binding::TexCoordP1uiv(type, coords);
}
inline void glTexCoordP2ui(GLenum type, GLuint coords)
{
return glbinding::Binding::TexCoordP2ui(type, coords);
}
inline void glTexCoordP2uiv(GLenum type, const GLuint * coords)
{
return glbinding::Binding::TexCoordP2uiv(type, coords);
}
inline void glTexCoordP3ui(GLenum type, GLuint coords)
{
return glbinding::Binding::TexCoordP3ui(type, coords);
}
inline void glTexCoordP3uiv(GLenum type, const GLuint * coords)
{
return glbinding::Binding::TexCoordP3uiv(type, coords);
}
inline void glTexCoordP4ui(GLenum type, GLuint coords)
{
return glbinding::Binding::TexCoordP4ui(type, coords);
}
inline void glTexCoordP4uiv(GLenum type, const GLuint * coords)
{
return glbinding::Binding::TexCoordP4uiv(type, coords);
}
inline void glTexCoordPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const void * pointer)
{
return glbinding::Binding::TexCoordPointerEXT(size, type, stride, count, pointer);
}
inline void glTexCoordPointerListIBM(GLint size, GLenum type, GLint stride, const void ** pointer, GLint ptrstride)
{
return glbinding::Binding::TexCoordPointerListIBM(size, type, stride, pointer, ptrstride);
}
inline void glTexCoordPointervINTEL(GLint size, GLenum type, const void ** pointer)
{
return glbinding::Binding::TexCoordPointervINTEL(size, type, pointer);
}
inline void glTexEnvxOES(GLenum target, GLenum pname, GLfixed param)
{
return glbinding::Binding::TexEnvxOES(target, pname, param);
}
inline void glTexEnvxvOES(GLenum target, GLenum pname, const GLfixed * params)
{
return glbinding::Binding::TexEnvxvOES(target, pname, params);
}
inline void glTexFilterFuncSGIS(GLenum target, GLenum filter, GLsizei n, const GLfloat * weights)
{
return glbinding::Binding::TexFilterFuncSGIS(target, filter, n, weights);
}
inline void glTexGenxOES(GLenum coord, GLenum pname, GLfixed param)
{
return glbinding::Binding::TexGenxOES(coord, pname, param);
}
inline void glTexGenxvOES(GLenum coord, GLenum pname, const GLfixed * params)
{
return glbinding::Binding::TexGenxvOES(coord, pname, params);
}
inline void glTexImage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
{
return glbinding::Binding::TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
}
inline void glTexImage2DMultisampleCoverageNV(GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations)
{
return glbinding::Binding::TexImage2DMultisampleCoverageNV(target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations);
}
inline void glTexImage3DEXT(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels)
{
return glbinding::Binding::TexImage3DEXT(target, level, internalformat, width, height, depth, border, format, type, pixels);
}
inline void glTexImage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
{
return glbinding::Binding::TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
}
inline void glTexImage3DMultisampleCoverageNV(GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations)
{
return glbinding::Binding::TexImage3DMultisampleCoverageNV(target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations);
}
inline void glTexImage4DSGIS(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, const void * pixels)
{
return glbinding::Binding::TexImage4DSGIS(target, level, internalformat, width, height, depth, size4d, border, format, type, pixels);
}
inline void glTexPageCommitmentARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean resident)
{
return glbinding::Binding::TexPageCommitmentARB(target, level, xoffset, yoffset, zoffset, width, height, depth, resident);
}
inline void glTexParameterIiv(GLenum target, GLenum pname, const GLint * params)
{
return glbinding::Binding::TexParameterIiv(target, pname, params);
}
inline void glTexParameterIivEXT(GLenum target, GLenum pname, const GLint * params)
{
return glbinding::Binding::TexParameterIivEXT(target, pname, params);
}
inline void glTexParameterIuiv(GLenum target, GLenum pname, const GLuint * params)
{
return glbinding::Binding::TexParameterIuiv(target, pname, params);
}
inline void glTexParameterIuivEXT(GLenum target, GLenum pname, const GLuint * params)
{
return glbinding::Binding::TexParameterIuivEXT(target, pname, params);
}
inline void glTexParameterxOES(GLenum target, GLenum pname, GLfixed param)
{
return glbinding::Binding::TexParameterxOES(target, pname, param);
}
inline void glTexParameterxvOES(GLenum target, GLenum pname, const GLfixed * params)
{
return glbinding::Binding::TexParameterxvOES(target, pname, params);
}
inline void glTexRenderbufferNV(GLenum target, GLuint renderbuffer)
{
return glbinding::Binding::TexRenderbufferNV(target, renderbuffer);
}
inline void glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
{
return glbinding::Binding::TexStorage1D(target, levels, internalformat, width);
}
inline void glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
{
return glbinding::Binding::TexStorage2D(target, levels, internalformat, width, height);
}
inline void glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
{
return glbinding::Binding::TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
}
inline void glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
{
return glbinding::Binding::TexStorage3D(target, levels, internalformat, width, height, depth);
}
inline void glTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
{
return glbinding::Binding::TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
}
inline void glTexStorageSparseAMD(GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLsizei layers, TextureStorageMaskAMD flags)
{
return glbinding::Binding::TexStorageSparseAMD(target, internalFormat, width, height, depth, layers, flags);
}
inline void glTexSubImage1DEXT(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels)
{
return glbinding::Binding::TexSubImage1DEXT(target, level, xoffset, width, format, type, pixels);
}
inline void glTexSubImage2DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels)
{
return glbinding::Binding::TexSubImage2DEXT(target, level, xoffset, yoffset, width, height, format, type, pixels);
}
inline void glTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels)
{
return glbinding::Binding::TexSubImage3DEXT(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
}
inline void glTexSubImage4DSGIS(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, const void * pixels)
{
return glbinding::Binding::TexSubImage4DSGIS(target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, pixels);
}
inline void glTextureBarrier()
{
return glbinding::Binding::TextureBarrier();
}
inline void glTextureBarrierNV()
{
return glbinding::Binding::TextureBarrierNV();
}
inline void glTextureBuffer(GLuint texture, GLenum internalformat, GLuint buffer)
{
return glbinding::Binding::TextureBuffer(texture, internalformat, buffer);
}
inline void glTextureBufferEXT(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer)
{
return glbinding::Binding::TextureBufferEXT(texture, target, internalformat, buffer);
}
inline void glTextureBufferRange(GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
{
return glbinding::Binding::TextureBufferRange(texture, internalformat, buffer, offset, size);
}
inline void glTextureBufferRangeEXT(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
{
return glbinding::Binding::TextureBufferRangeEXT(texture, target, internalformat, buffer, offset, size);
}
inline void glTextureColorMaskSGIS(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
{
return glbinding::Binding::TextureColorMaskSGIS(red, green, blue, alpha);
}
inline void glTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels)
{
return glbinding::Binding::TextureImage1DEXT(texture, target, level, internalformat, width, border, format, type, pixels);
}
inline void glTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels)
{
return glbinding::Binding::TextureImage2DEXT(texture, target, level, internalformat, width, height, border, format, type, pixels);
}
inline void glTextureImage2DMultisampleCoverageNV(GLuint texture, GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations)
{
return glbinding::Binding::TextureImage2DMultisampleCoverageNV(texture, target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations);
}
inline void glTextureImage2DMultisampleNV(GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations)
{
return glbinding::Binding::TextureImage2DMultisampleNV(texture, target, samples, internalFormat, width, height, fixedSampleLocations);
}
inline void glTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels)
{
return glbinding::Binding::TextureImage3DEXT(texture, target, level, internalformat, width, height, depth, border, format, type, pixels);
}
inline void glTextureImage3DMultisampleCoverageNV(GLuint texture, GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations)
{
return glbinding::Binding::TextureImage3DMultisampleCoverageNV(texture, target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations);
}
inline void glTextureImage3DMultisampleNV(GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations)
{
return glbinding::Binding::TextureImage3DMultisampleNV(texture, target, samples, internalFormat, width, height, depth, fixedSampleLocations);
}
inline void glTextureLightEXT(GLenum pname)
{
return glbinding::Binding::TextureLightEXT(pname);
}
inline void glTextureMaterialEXT(GLenum face, GLenum mode)
{
return glbinding::Binding::TextureMaterialEXT(face, mode);
}
inline void glTextureNormalEXT(GLenum mode)
{
return glbinding::Binding::TextureNormalEXT(mode);
}
inline void glTexturePageCommitmentEXT(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean resident)
{
return glbinding::Binding::TexturePageCommitmentEXT(texture, level, xoffset, yoffset, zoffset, width, height, depth, resident);
}
inline void glTextureParameterIiv(GLuint texture, GLenum pname, const GLint * params)
{
return glbinding::Binding::TextureParameterIiv(texture, pname, params);
}
inline void glTextureParameterIivEXT(GLuint texture, GLenum target, GLenum pname, const GLint * params)
{
return glbinding::Binding::TextureParameterIivEXT(texture, target, pname, params);
}
inline void glTextureParameterIuiv(GLuint texture, GLenum pname, const GLuint * params)
{
return glbinding::Binding::TextureParameterIuiv(texture, pname, params);
}
inline void glTextureParameterIuivEXT(GLuint texture, GLenum target, GLenum pname, const GLuint * params)
{
return glbinding::Binding::TextureParameterIuivEXT(texture, target, pname, params);
}
inline void glTextureParameterf(GLuint texture, GLenum pname, GLfloat param)
{
return glbinding::Binding::TextureParameterf(texture, pname, param);
}
inline void glTextureParameterfEXT(GLuint texture, GLenum target, GLenum pname, GLfloat param)
{
return glbinding::Binding::TextureParameterfEXT(texture, target, pname, param);
}
inline void glTextureParameterfv(GLuint texture, GLenum pname, const GLfloat * param)
{
return glbinding::Binding::TextureParameterfv(texture, pname, param);
}
inline void glTextureParameterfvEXT(GLuint texture, GLenum target, GLenum pname, const GLfloat * params)
{
return glbinding::Binding::TextureParameterfvEXT(texture, target, pname, params);
}
inline void glTextureParameteri(GLuint texture, GLenum pname, GLint param)
{
return glbinding::Binding::TextureParameteri(texture, pname, param);
}
inline void glTextureParameteriEXT(GLuint texture, GLenum target, GLenum pname, GLint param)
{
return glbinding::Binding::TextureParameteriEXT(texture, target, pname, param);
}
inline void glTextureParameteriv(GLuint texture, GLenum pname, const GLint * param)
{
return glbinding::Binding::TextureParameteriv(texture, pname, param);
}
inline void glTextureParameterivEXT(GLuint texture, GLenum target, GLenum pname, const GLint * params)
{
return glbinding::Binding::TextureParameterivEXT(texture, target, pname, params);
}
inline void glTextureRangeAPPLE(GLenum target, GLsizei length, const void * pointer)
{
return glbinding::Binding::TextureRangeAPPLE(target, length, pointer);
}
inline void glTextureRenderbufferEXT(GLuint texture, GLenum target, GLuint renderbuffer)
{
return glbinding::Binding::TextureRenderbufferEXT(texture, target, renderbuffer);
}
inline void glTextureStorage1D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width)
{
return glbinding::Binding::TextureStorage1D(texture, levels, internalformat, width);
}
inline void glTextureStorage1DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
{
return glbinding::Binding::TextureStorage1DEXT(texture, target, levels, internalformat, width);
}
inline void glTextureStorage2D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
{
return glbinding::Binding::TextureStorage2D(texture, levels, internalformat, width, height);
}
inline void glTextureStorage2DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
{
return glbinding::Binding::TextureStorage2DEXT(texture, target, levels, internalformat, width, height);
}
inline void glTextureStorage2DMultisample(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
{
return glbinding::Binding::TextureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations);
}
inline void glTextureStorage2DMultisampleEXT(GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
{
return glbinding::Binding::TextureStorage2DMultisampleEXT(texture, target, samples, internalformat, width, height, fixedsamplelocations);
}
inline void glTextureStorage3D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
{
return glbinding::Binding::TextureStorage3D(texture, levels, internalformat, width, height, depth);
}
inline void glTextureStorage3DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
{
return glbinding::Binding::TextureStorage3DEXT(texture, target, levels, internalformat, width, height, depth);
}
inline void glTextureStorage3DMultisample(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
{
return glbinding::Binding::TextureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations);
}
inline void glTextureStorage3DMultisampleEXT(GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
{
return glbinding::Binding::TextureStorage3DMultisampleEXT(texture, target, samples, internalformat, width, height, depth, fixedsamplelocations);
}
inline void glTextureStorageSparseAMD(GLuint texture, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLsizei layers, TextureStorageMaskAMD flags)
{
return glbinding::Binding::TextureStorageSparseAMD(texture, target, internalFormat, width, height, depth, layers, flags);
}
inline void glTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels)
{
return glbinding::Binding::TextureSubImage1D(texture, level, xoffset, width, format, type, pixels);
}
inline void glTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels)
{
return glbinding::Binding::TextureSubImage1DEXT(texture, target, level, xoffset, width, format, type, pixels);
}
inline void glTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels)
{
return glbinding::Binding::TextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, pixels);
}
inline void glTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels)
{
return glbinding::Binding::TextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, type, pixels);
}
inline void glTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels)
{
return glbinding::Binding::TextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
}
inline void glTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels)
{
return glbinding::Binding::TextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
}
inline void glTextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers)
{
return glbinding::Binding::TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
}
inline void glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GLenum transform)
{
return glbinding::Binding::TrackMatrixNV(target, address, matrix, transform);
}
inline void glTransformFeedbackAttribsNV(GLsizei count, const GLint * attribs, GLenum bufferMode)
{
return glbinding::Binding::TransformFeedbackAttribsNV(count, attribs, bufferMode);
}
inline void glTransformFeedbackBufferBase(GLuint xfb, GLuint index, GLuint buffer)
{
return glbinding::Binding::TransformFeedbackBufferBase(xfb, index, buffer);
}
inline void glTransformFeedbackBufferRange(GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
{
return glbinding::Binding::TransformFeedbackBufferRange(xfb, index, buffer, offset, size);
}
inline void glTransformFeedbackStreamAttribsNV(GLsizei count, const GLint * attribs, GLsizei nbuffers, const GLint * bufstreams, GLenum bufferMode)
{
return glbinding::Binding::TransformFeedbackStreamAttribsNV(count, attribs, nbuffers, bufstreams, bufferMode);
}
inline void glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const* varyings, GLenum bufferMode)
{
return glbinding::Binding::TransformFeedbackVaryings(program, count, varyings, bufferMode);
}
inline void glTransformFeedbackVaryingsEXT(GLuint program, GLsizei count, const GLchar *const* varyings, GLenum bufferMode)
{
return glbinding::Binding::TransformFeedbackVaryingsEXT(program, count, varyings, bufferMode);
}
inline void glTransformFeedbackVaryingsNV(GLuint program, GLsizei count, const GLint * locations, GLenum bufferMode)
{
return glbinding::Binding::TransformFeedbackVaryingsNV(program, count, locations, bufferMode);
}
inline void glTransformPathNV(GLuint resultPath, GLuint srcPath, GLenum transformType, const GLfloat * transformValues)
{
return glbinding::Binding::TransformPathNV(resultPath, srcPath, transformType, transformValues);
}
inline void glTranslatexOES(GLfixed x, GLfixed y, GLfixed z)
{
return glbinding::Binding::TranslatexOES(x, y, z);
}
inline void glUniform1d(GLint location, GLdouble x)
{
return glbinding::Binding::Uniform1d(location, x);
}
inline void glUniform1dv(GLint location, GLsizei count, const GLdouble * value)
{
return glbinding::Binding::Uniform1dv(location, count, value);
}
inline void glUniform1f(GLint location, GLfloat v0)
{
return glbinding::Binding::Uniform1f(location, v0);
}
inline void glUniform1fARB(GLint location, GLfloat v0)
{
return glbinding::Binding::Uniform1fARB(location, v0);
}
inline void glUniform1fv(GLint location, GLsizei count, const GLfloat * value)
{
return glbinding::Binding::Uniform1fv(location, count, value);
}
inline void glUniform1fvARB(GLint location, GLsizei count, const GLfloat * value)
{
return glbinding::Binding::Uniform1fvARB(location, count, value);
}
inline void glUniform1i(GLint location, GLint v0)
{
return glbinding::Binding::Uniform1i(location, v0);
}
inline void glUniform1i64NV(GLint location, GLint64EXT x)
{
return glbinding::Binding::Uniform1i64NV(location, x);
}
inline void glUniform1i64vNV(GLint location, GLsizei count, const GLint64EXT * value)
{
return glbinding::Binding::Uniform1i64vNV(location, count, value);
}
inline void glUniform1iARB(GLint location, GLint v0)
{
return glbinding::Binding::Uniform1iARB(location, v0);
}
inline void glUniform1iv(GLint location, GLsizei count, const GLint * value)
{
return glbinding::Binding::Uniform1iv(location, count, value);
}
inline void glUniform1ivARB(GLint location, GLsizei count, const GLint * value)
{
return glbinding::Binding::Uniform1ivARB(location, count, value);
}
inline void glUniform1ui(GLint location, GLuint v0)
{
return glbinding::Binding::Uniform1ui(location, v0);
}
inline void glUniform1ui64NV(GLint location, GLuint64EXT x)
{
return glbinding::Binding::Uniform1ui64NV(location, x);
}
inline void glUniform1ui64vNV(GLint location, GLsizei count, const GLuint64EXT * value)
{
return glbinding::Binding::Uniform1ui64vNV(location, count, value);
}
inline void glUniform1uiEXT(GLint location, GLuint v0)
{
return glbinding::Binding::Uniform1uiEXT(location, v0);
}
inline void glUniform1uiv(GLint location, GLsizei count, const GLuint * value)
{
return glbinding::Binding::Uniform1uiv(location, count, value);
}
inline void glUniform1uivEXT(GLint location, GLsizei count, const GLuint * value)
{
return glbinding::Binding::Uniform1uivEXT(location, count, value);
}
inline void glUniform2d(GLint location, GLdouble x, GLdouble y)
{
return glbinding::Binding::Uniform2d(location, x, y);
}
inline void glUniform2dv(GLint location, GLsizei count, const GLdouble * value)
{
return glbinding::Binding::Uniform2dv(location, count, value);
}
inline void glUniform2f(GLint location, GLfloat v0, GLfloat v1)
{
return glbinding::Binding::Uniform2f(location, v0, v1);
}
inline void glUniform2fARB(GLint location, GLfloat v0, GLfloat v1)
{
return glbinding::Binding::Uniform2fARB(location, v0, v1);
}
inline void glUniform2fv(GLint location, GLsizei count, const GLfloat * value)
{
return glbinding::Binding::Uniform2fv(location, count, value);
}
inline void glUniform2fvARB(GLint location, GLsizei count, const GLfloat * value)
{
return glbinding::Binding::Uniform2fvARB(location, count, value);
}
inline void glUniform2i(GLint location, GLint v0, GLint v1)
{
return glbinding::Binding::Uniform2i(location, v0, v1);
}
inline void glUniform2i64NV(GLint location, GLint64EXT x, GLint64EXT y)
{
return glbinding::Binding::Uniform2i64NV(location, x, y);
}
inline void glUniform2i64vNV(GLint location, GLsizei count, const GLint64EXT * value)
{
return glbinding::Binding::Uniform2i64vNV(location, count, value);
}
inline void glUniform2iARB(GLint location, GLint v0, GLint v1)
{
return glbinding::Binding::Uniform2iARB(location, v0, v1);
}
inline void glUniform2iv(GLint location, GLsizei count, const GLint * value)
{
return glbinding::Binding::Uniform2iv(location, count, value);
}
inline void glUniform2ivARB(GLint location, GLsizei count, const GLint * value)
{
return glbinding::Binding::Uniform2ivARB(location, count, value);
}
inline void glUniform2ui(GLint location, GLuint v0, GLuint v1)
{
return glbinding::Binding::Uniform2ui(location, v0, v1);
}
inline void glUniform2ui64NV(GLint location, GLuint64EXT x, GLuint64EXT y)
{
return glbinding::Binding::Uniform2ui64NV(location, x, y);
}
inline void glUniform2ui64vNV(GLint location, GLsizei count, const GLuint64EXT * value)
{
return glbinding::Binding::Uniform2ui64vNV(location, count, value);
}
inline void glUniform2uiEXT(GLint location, GLuint v0, GLuint v1)
{
return glbinding::Binding::Uniform2uiEXT(location, v0, v1);
}
inline void glUniform2uiv(GLint location, GLsizei count, const GLuint * value)
{
return glbinding::Binding::Uniform2uiv(location, count, value);
}
inline void glUniform2uivEXT(GLint location, GLsizei count, const GLuint * value)
{
return glbinding::Binding::Uniform2uivEXT(location, count, value);
}
inline void glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
{
return glbinding::Binding::Uniform3d(location, x, y, z);
}
inline void glUniform3dv(GLint location, GLsizei count, const GLdouble * value)
{
return glbinding::Binding::Uniform3dv(location, count, value);
}
inline void glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
{
return glbinding::Binding::Uniform3f(location, v0, v1, v2);
}
inline void glUniform3fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
{
return glbinding::Binding::Uniform3fARB(location, v0, v1, v2);
}
inline void glUniform3fv(GLint location, GLsizei count, const GLfloat * value)
{
return glbinding::Binding::Uniform3fv(location, count, value);
}
inline void glUniform3fvARB(GLint location, GLsizei count, const GLfloat * value)
{
return glbinding::Binding::Uniform3fvARB(location, count, value);
}
inline void glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
{
return glbinding::Binding::Uniform3i(location, v0, v1, v2);
}
inline void glUniform3i64NV(GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z)
{
return glbinding::Binding::Uniform3i64NV(location, x, y, z);
}
inline void glUniform3i64vNV(GLint location, GLsizei count, const GLint64EXT * value)
{
return glbinding::Binding::Uniform3i64vNV(location, count, value);
}
inline void glUniform3iARB(GLint location, GLint v0, GLint v1, GLint v2)
{
return glbinding::Binding::Uniform3iARB(location, v0, v1, v2);
}
inline void glUniform3iv(GLint location, GLsizei count, const GLint * value)
{
return glbinding::Binding::Uniform3iv(location, count, value);
}
inline void glUniform3ivARB(GLint location, GLsizei count, const GLint * value)
{
return glbinding::Binding::Uniform3ivARB(location, count, value);
}
inline void glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
{
return glbinding::Binding::Uniform3ui(location, v0, v1, v2);
}
inline void glUniform3ui64NV(GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z)
{
return glbinding::Binding::Uniform3ui64NV(location, x, y, z);
}
inline void glUniform3ui64vNV(GLint location, GLsizei count, const GLuint64EXT * value)
{
return glbinding::Binding::Uniform3ui64vNV(location, count, value);
}
inline void glUniform3uiEXT(GLint location, GLuint v0, GLuint v1, GLuint v2)
{
return glbinding::Binding::Uniform3uiEXT(location, v0, v1, v2);
}
inline void glUniform3uiv(GLint location, GLsizei count, const GLuint * value)
{
return glbinding::Binding::Uniform3uiv(location, count, value);
}
inline void glUniform3uivEXT(GLint location, GLsizei count, const GLuint * value)
{
return glbinding::Binding::Uniform3uivEXT(location, count, value);
}
inline void glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
return glbinding::Binding::Uniform4d(location, x, y, z, w);
}
inline void glUniform4dv(GLint location, GLsizei count, const GLdouble * value)
{
return glbinding::Binding::Uniform4dv(location, count, value);
}
inline void glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
{
return glbinding::Binding::Uniform4f(location, v0, v1, v2, v3);
}
inline void glUniform4fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
{
return glbinding::Binding::Uniform4fARB(location, v0, v1, v2, v3);
}
inline void glUniform4fv(GLint location, GLsizei count, const GLfloat * value)
{
return glbinding::Binding::Uniform4fv(location, count, value);
}
inline void glUniform4fvARB(GLint location, GLsizei count, const GLfloat * value)
{
return glbinding::Binding::Uniform4fvARB(location, count, value);
}
inline void glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
{
return glbinding::Binding::Uniform4i(location, v0, v1, v2, v3);
}
inline void glUniform4i64NV(GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w)
{
return glbinding::Binding::Uniform4i64NV(location, x, y, z, w);
}
inline void glUniform4i64vNV(GLint location, GLsizei count, const GLint64EXT * value)
{
return glbinding::Binding::Uniform4i64vNV(location, count, value);
}
inline void glUniform4iARB(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
{
return glbinding::Binding::Uniform4iARB(location, v0, v1, v2, v3);
}
inline void glUniform4iv(GLint location, GLsizei count, const GLint * value)
{
return glbinding::Binding::Uniform4iv(location, count, value);
}
inline void glUniform4ivARB(GLint location, GLsizei count, const GLint * value)
{
return glbinding::Binding::Uniform4ivARB(location, count, value);
}
inline void glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
{
return glbinding::Binding::Uniform4ui(location, v0, v1, v2, v3);
}
inline void glUniform4ui64NV(GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w)
{
return glbinding::Binding::Uniform4ui64NV(location, x, y, z, w);
}
inline void glUniform4ui64vNV(GLint location, GLsizei count, const GLuint64EXT * value)
{
return glbinding::Binding::Uniform4ui64vNV(location, count, value);
}
inline void glUniform4uiEXT(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
{
return glbinding::Binding::Uniform4uiEXT(location, v0, v1, v2, v3);
}
inline void glUniform4uiv(GLint location, GLsizei count, const GLuint * value)
{
return glbinding::Binding::Uniform4uiv(location, count, value);
}
inline void glUniform4uivEXT(GLint location, GLsizei count, const GLuint * value)
{
return glbinding::Binding::Uniform4uivEXT(location, count, value);
}
inline void glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
{
return glbinding::Binding::UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}
inline void glUniformBufferEXT(GLuint program, GLint location, GLuint buffer)
{
return glbinding::Binding::UniformBufferEXT(program, location, buffer);
}
inline void glUniformHandleui64ARB(GLint location, GLuint64 value)
{
return glbinding::Binding::UniformHandleui64ARB(location, value);
}
inline void glUniformHandleui64NV(GLint location, GLuint64 value)
{
return glbinding::Binding::UniformHandleui64NV(location, value);
}
inline void glUniformHandleui64vARB(GLint location, GLsizei count, const GLuint64 * value)
{
return glbinding::Binding::UniformHandleui64vARB(location, count, value);
}
inline void glUniformHandleui64vNV(GLint location, GLsizei count, const GLuint64 * value)
{
return glbinding::Binding::UniformHandleui64vNV(location, count, value);
}
inline void glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
return glbinding::Binding::UniformMatrix2dv(location, count, transpose, value);
}
inline void glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::UniformMatrix2fv(location, count, transpose, value);
}
inline void glUniformMatrix2fvARB(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::UniformMatrix2fvARB(location, count, transpose, value);
}
inline void glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
return glbinding::Binding::UniformMatrix2x3dv(location, count, transpose, value);
}
inline void glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::UniformMatrix2x3fv(location, count, transpose, value);
}
inline void glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
return glbinding::Binding::UniformMatrix2x4dv(location, count, transpose, value);
}
inline void glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::UniformMatrix2x4fv(location, count, transpose, value);
}
inline void glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
return glbinding::Binding::UniformMatrix3dv(location, count, transpose, value);
}
inline void glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::UniformMatrix3fv(location, count, transpose, value);
}
inline void glUniformMatrix3fvARB(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::UniformMatrix3fvARB(location, count, transpose, value);
}
inline void glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
return glbinding::Binding::UniformMatrix3x2dv(location, count, transpose, value);
}
inline void glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::UniformMatrix3x2fv(location, count, transpose, value);
}
inline void glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
return glbinding::Binding::UniformMatrix3x4dv(location, count, transpose, value);
}
inline void glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::UniformMatrix3x4fv(location, count, transpose, value);
}
inline void glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
return glbinding::Binding::UniformMatrix4dv(location, count, transpose, value);
}
inline void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::UniformMatrix4fv(location, count, transpose, value);
}
inline void glUniformMatrix4fvARB(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::UniformMatrix4fvARB(location, count, transpose, value);
}
inline void glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
return glbinding::Binding::UniformMatrix4x2dv(location, count, transpose, value);
}
inline void glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::UniformMatrix4x2fv(location, count, transpose, value);
}
inline void glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
return glbinding::Binding::UniformMatrix4x3dv(location, count, transpose, value);
}
inline void glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
return glbinding::Binding::UniformMatrix4x3fv(location, count, transpose, value);
}
inline void glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint * indices)
{
return glbinding::Binding::UniformSubroutinesuiv(shadertype, count, indices);
}
inline void glUniformui64NV(GLint location, GLuint64EXT value)
{
return glbinding::Binding::Uniformui64NV(location, value);
}
inline void glUniformui64vNV(GLint location, GLsizei count, const GLuint64EXT * value)
{
return glbinding::Binding::Uniformui64vNV(location, count, value);
}
inline void glUnlockArraysEXT()
{
return glbinding::Binding::UnlockArraysEXT();
}
inline GLboolean glUnmapBuffer(GLenum target)
{
return glbinding::Binding::UnmapBuffer(target);
}
inline GLboolean glUnmapBufferARB(GLenum target)
{
return glbinding::Binding::UnmapBufferARB(target);
}
inline GLboolean glUnmapNamedBuffer(GLuint buffer)
{
return glbinding::Binding::UnmapNamedBuffer(buffer);
}
inline GLboolean glUnmapNamedBufferEXT(GLuint buffer)
{
return glbinding::Binding::UnmapNamedBufferEXT(buffer);
}
inline void glUnmapObjectBufferATI(GLuint buffer)
{
return glbinding::Binding::UnmapObjectBufferATI(buffer);
}
inline void glUnmapTexture2DINTEL(GLuint texture, GLint level)
{
return glbinding::Binding::UnmapTexture2DINTEL(texture, level);
}
inline void glUpdateObjectBufferATI(GLuint buffer, GLuint offset, GLsizei size, const void * pointer, GLenum preserve)
{
return glbinding::Binding::UpdateObjectBufferATI(buffer, offset, size, pointer, preserve);
}
inline void glUseProgram(GLuint program)
{
return glbinding::Binding::UseProgram(program);
}
inline void glUseProgramObjectARB(GLhandleARB programObj)
{
return glbinding::Binding::UseProgramObjectARB(programObj);
}
inline void glUseProgramStages(GLuint pipeline, UseProgramStageMask stages, GLuint program)
{
return glbinding::Binding::UseProgramStages(pipeline, stages, program);
}
inline void glUseShaderProgramEXT(GLenum type, GLuint program)
{
return glbinding::Binding::UseShaderProgramEXT(type, program);
}
inline void glVDPAUFiniNV()
{
return glbinding::Binding::VDPAUFiniNV();
}
inline void glVDPAUGetSurfaceivNV(GLvdpauSurfaceNV surface, GLenum pname, GLsizei bufSize, GLsizei * length, GLint * values)
{
return glbinding::Binding::VDPAUGetSurfaceivNV(surface, pname, bufSize, length, values);
}
inline void glVDPAUInitNV(const void * vdpDevice, const void * getProcAddress)
{
return glbinding::Binding::VDPAUInitNV(vdpDevice, getProcAddress);
}
inline GLboolean glVDPAUIsSurfaceNV(GLvdpauSurfaceNV surface)
{
return glbinding::Binding::VDPAUIsSurfaceNV(surface);
}
inline void glVDPAUMapSurfacesNV(GLsizei numSurfaces, const GLvdpauSurfaceNV * surfaces)
{
return glbinding::Binding::VDPAUMapSurfacesNV(numSurfaces, surfaces);
}
inline GLvdpauSurfaceNV glVDPAURegisterOutputSurfaceNV(const void * vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint * textureNames)
{
return glbinding::Binding::VDPAURegisterOutputSurfaceNV(vdpSurface, target, numTextureNames, textureNames);
}
inline GLvdpauSurfaceNV glVDPAURegisterVideoSurfaceNV(const void * vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint * textureNames)
{
return glbinding::Binding::VDPAURegisterVideoSurfaceNV(vdpSurface, target, numTextureNames, textureNames);
}
inline void glVDPAUSurfaceAccessNV(GLvdpauSurfaceNV surface, GLenum access)
{
return glbinding::Binding::VDPAUSurfaceAccessNV(surface, access);
}
inline void glVDPAUUnmapSurfacesNV(GLsizei numSurface, const GLvdpauSurfaceNV * surfaces)
{
return glbinding::Binding::VDPAUUnmapSurfacesNV(numSurface, surfaces);
}
inline void glVDPAUUnregisterSurfaceNV(GLvdpauSurfaceNV surface)
{
return glbinding::Binding::VDPAUUnregisterSurfaceNV(surface);
}
inline void glValidateProgram(GLuint program)
{
return glbinding::Binding::ValidateProgram(program);
}
inline void glValidateProgramARB(GLhandleARB programObj)
{
return glbinding::Binding::ValidateProgramARB(programObj);
}
inline void glValidateProgramPipeline(GLuint pipeline)
{
return glbinding::Binding::ValidateProgramPipeline(pipeline);
}
inline void glVariantArrayObjectATI(GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset)
{
return glbinding::Binding::VariantArrayObjectATI(id, type, stride, buffer, offset);
}
inline void glVariantPointerEXT(GLuint id, GLenum type, GLuint stride, const void * addr)
{
return glbinding::Binding::VariantPointerEXT(id, type, stride, addr);
}
inline void glVariantbvEXT(GLuint id, const GLbyte * addr)
{
return glbinding::Binding::VariantbvEXT(id, addr);
}
inline void glVariantdvEXT(GLuint id, const GLdouble * addr)
{
return glbinding::Binding::VariantdvEXT(id, addr);
}
inline void glVariantfvEXT(GLuint id, const GLfloat * addr)
{
return glbinding::Binding::VariantfvEXT(id, addr);
}
inline void glVariantivEXT(GLuint id, const GLint * addr)
{
return glbinding::Binding::VariantivEXT(id, addr);
}
inline void glVariantsvEXT(GLuint id, const GLshort * addr)
{
return glbinding::Binding::VariantsvEXT(id, addr);
}
inline void glVariantubvEXT(GLuint id, const GLubyte * addr)
{
return glbinding::Binding::VariantubvEXT(id, addr);
}
inline void glVariantuivEXT(GLuint id, const GLuint * addr)
{
return glbinding::Binding::VariantuivEXT(id, addr);
}
inline void glVariantusvEXT(GLuint id, const GLushort * addr)
{
return glbinding::Binding::VariantusvEXT(id, addr);
}
inline void glVertex2bOES(GLbyte x, GLbyte y)
{
return glbinding::Binding::Vertex2bOES(x, y);
}
inline void glVertex2bvOES(const GLbyte * coords)
{
return glbinding::Binding::Vertex2bvOES(coords);
}
inline void glVertex2hNV(GLhalfNV x, GLhalfNV y)
{
return glbinding::Binding::Vertex2hNV(x, y);
}
inline void glVertex2hvNV(const GLhalfNV * v)
{
return glbinding::Binding::Vertex2hvNV(v);
}
inline void glVertex2xOES(GLfixed x)
{
return glbinding::Binding::Vertex2xOES(x);
}
inline void glVertex2xvOES(const GLfixed * coords)
{
return glbinding::Binding::Vertex2xvOES(coords);
}
inline void glVertex3bOES(GLbyte x, GLbyte y, GLbyte z)
{
return glbinding::Binding::Vertex3bOES(x, y, z);
}
inline void glVertex3bvOES(const GLbyte * coords)
{
return glbinding::Binding::Vertex3bvOES(coords);
}
inline void glVertex3hNV(GLhalfNV x, GLhalfNV y, GLhalfNV z)
{
return glbinding::Binding::Vertex3hNV(x, y, z);
}
inline void glVertex3hvNV(const GLhalfNV * v)
{
return glbinding::Binding::Vertex3hvNV(v);
}
inline void glVertex3xOES(GLfixed x, GLfixed y)
{
return glbinding::Binding::Vertex3xOES(x, y);
}
inline void glVertex3xvOES(const GLfixed * coords)
{
return glbinding::Binding::Vertex3xvOES(coords);
}
inline void glVertex4bOES(GLbyte x, GLbyte y, GLbyte z, GLbyte w)
{
return glbinding::Binding::Vertex4bOES(x, y, z, w);
}
inline void glVertex4bvOES(const GLbyte * coords)
{
return glbinding::Binding::Vertex4bvOES(coords);
}
inline void glVertex4hNV(GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w)
{
return glbinding::Binding::Vertex4hNV(x, y, z, w);
}
inline void glVertex4hvNV(const GLhalfNV * v)
{
return glbinding::Binding::Vertex4hvNV(v);
}
inline void glVertex4xOES(GLfixed x, GLfixed y, GLfixed z)
{
return glbinding::Binding::Vertex4xOES(x, y, z);
}
inline void glVertex4xvOES(const GLfixed * coords)
{
return glbinding::Binding::Vertex4xvOES(coords);
}
inline void glVertexArrayAttribBinding(GLuint vaobj, GLuint attribindex, GLuint bindingindex)
{
return glbinding::Binding::VertexArrayAttribBinding(vaobj, attribindex, bindingindex);
}
inline void glVertexArrayAttribFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
{
return glbinding::Binding::VertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset);
}
inline void glVertexArrayAttribIFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
{
return glbinding::Binding::VertexArrayAttribIFormat(vaobj, attribindex, size, type, relativeoffset);
}
inline void glVertexArrayAttribLFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
{
return glbinding::Binding::VertexArrayAttribLFormat(vaobj, attribindex, size, type, relativeoffset);
}
inline void glVertexArrayBindVertexBufferEXT(GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
{
return glbinding::Binding::VertexArrayBindVertexBufferEXT(vaobj, bindingindex, buffer, offset, stride);
}
inline void glVertexArrayBindingDivisor(GLuint vaobj, GLuint bindingindex, GLuint divisor)
{
return glbinding::Binding::VertexArrayBindingDivisor(vaobj, bindingindex, divisor);
}
inline void glVertexArrayColorOffsetEXT(GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset)
{
return glbinding::Binding::VertexArrayColorOffsetEXT(vaobj, buffer, size, type, stride, offset);
}
inline void glVertexArrayEdgeFlagOffsetEXT(GLuint vaobj, GLuint buffer, GLsizei stride, GLintptr offset)
{
return glbinding::Binding::VertexArrayEdgeFlagOffsetEXT(vaobj, buffer, stride, offset);
}
inline void glVertexArrayElementBuffer(GLuint vaobj, GLuint buffer)
{
return glbinding::Binding::VertexArrayElementBuffer(vaobj, buffer);
}
inline void glVertexArrayFogCoordOffsetEXT(GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset)
{
return glbinding::Binding::VertexArrayFogCoordOffsetEXT(vaobj, buffer, type, stride, offset);
}
inline void glVertexArrayIndexOffsetEXT(GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset)
{
return glbinding::Binding::VertexArrayIndexOffsetEXT(vaobj, buffer, type, stride, offset);
}
inline void glVertexArrayMultiTexCoordOffsetEXT(GLuint vaobj, GLuint buffer, GLenum texunit, GLint size, GLenum type, GLsizei stride, GLintptr offset)
{
return glbinding::Binding::VertexArrayMultiTexCoordOffsetEXT(vaobj, buffer, texunit, size, type, stride, offset);
}
inline void glVertexArrayNormalOffsetEXT(GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset)
{
return glbinding::Binding::VertexArrayNormalOffsetEXT(vaobj, buffer, type, stride, offset);
}
inline void glVertexArrayParameteriAPPLE(GLenum pname, GLint param)
{
return glbinding::Binding::VertexArrayParameteriAPPLE(pname, param);
}
inline void glVertexArrayRangeAPPLE(GLsizei length, void * pointer)
{
return glbinding::Binding::VertexArrayRangeAPPLE(length, pointer);
}
inline void glVertexArrayRangeNV(GLsizei length, const void * pointer)
{
return glbinding::Binding::VertexArrayRangeNV(length, pointer);
}
inline void glVertexArraySecondaryColorOffsetEXT(GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset)
{
return glbinding::Binding::VertexArraySecondaryColorOffsetEXT(vaobj, buffer, size, type, stride, offset);
}
inline void glVertexArrayTexCoordOffsetEXT(GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset)
{
return glbinding::Binding::VertexArrayTexCoordOffsetEXT(vaobj, buffer, size, type, stride, offset);
}
inline void glVertexArrayVertexAttribBindingEXT(GLuint vaobj, GLuint attribindex, GLuint bindingindex)
{
return glbinding::Binding::VertexArrayVertexAttribBindingEXT(vaobj, attribindex, bindingindex);
}
inline void glVertexArrayVertexAttribDivisorEXT(GLuint vaobj, GLuint index, GLuint divisor)
{
return glbinding::Binding::VertexArrayVertexAttribDivisorEXT(vaobj, index, divisor);
}
inline void glVertexArrayVertexAttribFormatEXT(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
{
return glbinding::Binding::VertexArrayVertexAttribFormatEXT(vaobj, attribindex, size, type, normalized, relativeoffset);
}
inline void glVertexArrayVertexAttribIFormatEXT(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
{
return glbinding::Binding::VertexArrayVertexAttribIFormatEXT(vaobj, attribindex, size, type, relativeoffset);
}
inline void glVertexArrayVertexAttribIOffsetEXT(GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset)
{
return glbinding::Binding::VertexArrayVertexAttribIOffsetEXT(vaobj, buffer, index, size, type, stride, offset);
}
inline void glVertexArrayVertexAttribLFormatEXT(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
{
return glbinding::Binding::VertexArrayVertexAttribLFormatEXT(vaobj, attribindex, size, type, relativeoffset);
}
inline void glVertexArrayVertexAttribLOffsetEXT(GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset)
{
return glbinding::Binding::VertexArrayVertexAttribLOffsetEXT(vaobj, buffer, index, size, type, stride, offset);
}
inline void glVertexArrayVertexAttribOffsetEXT(GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLintptr offset)
{
return glbinding::Binding::VertexArrayVertexAttribOffsetEXT(vaobj, buffer, index, size, type, normalized, stride, offset);
}
inline void glVertexArrayVertexBindingDivisorEXT(GLuint vaobj, GLuint bindingindex, GLuint divisor)
{
return glbinding::Binding::VertexArrayVertexBindingDivisorEXT(vaobj, bindingindex, divisor);
}
inline void glVertexArrayVertexBuffer(GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
{
return glbinding::Binding::VertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride);
}
inline void glVertexArrayVertexBuffers(GLuint vaobj, GLuint first, GLsizei count, const GLuint * buffers, const GLintptr * offsets, const GLsizei * strides)
{
return glbinding::Binding::VertexArrayVertexBuffers(vaobj, first, count, buffers, offsets, strides);
}
inline void glVertexArrayVertexOffsetEXT(GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset)
{
return glbinding::Binding::VertexArrayVertexOffsetEXT(vaobj, buffer, size, type, stride, offset);
}
inline void glVertexAttrib1d(GLuint index, GLdouble x)
{
return glbinding::Binding::VertexAttrib1d(index, x);
}
inline void glVertexAttrib1dARB(GLuint index, GLdouble x)
{
return glbinding::Binding::VertexAttrib1dARB(index, x);
}
inline void glVertexAttrib1dNV(GLuint index, GLdouble x)
{
return glbinding::Binding::VertexAttrib1dNV(index, x);
}
inline void glVertexAttrib1dv(GLuint index, const GLdouble * v)
{
return glbinding::Binding::VertexAttrib1dv(index, v);
}
inline void glVertexAttrib1dvARB(GLuint index, const GLdouble * v)
{
return glbinding::Binding::VertexAttrib1dvARB(index, v);
}
inline void glVertexAttrib1dvNV(GLuint index, const GLdouble * v)
{
return glbinding::Binding::VertexAttrib1dvNV(index, v);
}
inline void glVertexAttrib1f(GLuint index, GLfloat x)
{
return glbinding::Binding::VertexAttrib1f(index, x);
}
inline void glVertexAttrib1fARB(GLuint index, GLfloat x)
{
return glbinding::Binding::VertexAttrib1fARB(index, x);
}
inline void glVertexAttrib1fNV(GLuint index, GLfloat x)
{
return glbinding::Binding::VertexAttrib1fNV(index, x);
}
inline void glVertexAttrib1fv(GLuint index, const GLfloat * v)
{
return glbinding::Binding::VertexAttrib1fv(index, v);
}
inline void glVertexAttrib1fvARB(GLuint index, const GLfloat * v)
{
return glbinding::Binding::VertexAttrib1fvARB(index, v);
}
inline void glVertexAttrib1fvNV(GLuint index, const GLfloat * v)
{
return glbinding::Binding::VertexAttrib1fvNV(index, v);
}
inline void glVertexAttrib1hNV(GLuint index, GLhalfNV x)
{
return glbinding::Binding::VertexAttrib1hNV(index, x);
}
inline void glVertexAttrib1hvNV(GLuint index, const GLhalfNV * v)
{
return glbinding::Binding::VertexAttrib1hvNV(index, v);
}
inline void glVertexAttrib1s(GLuint index, GLshort x)
{
return glbinding::Binding::VertexAttrib1s(index, x);
}
inline void glVertexAttrib1sARB(GLuint index, GLshort x)
{
return glbinding::Binding::VertexAttrib1sARB(index, x);
}
inline void glVertexAttrib1sNV(GLuint index, GLshort x)
{
return glbinding::Binding::VertexAttrib1sNV(index, x);
}
inline void glVertexAttrib1sv(GLuint index, const GLshort * v)
{
return glbinding::Binding::VertexAttrib1sv(index, v);
}
inline void glVertexAttrib1svARB(GLuint index, const GLshort * v)
{
return glbinding::Binding::VertexAttrib1svARB(index, v);
}
inline void glVertexAttrib1svNV(GLuint index, const GLshort * v)
{
return glbinding::Binding::VertexAttrib1svNV(index, v);
}
inline void glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
{
return glbinding::Binding::VertexAttrib2d(index, x, y);
}
inline void glVertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y)
{
return glbinding::Binding::VertexAttrib2dARB(index, x, y);
}
inline void glVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y)
{
return glbinding::Binding::VertexAttrib2dNV(index, x, y);
}
inline void glVertexAttrib2dv(GLuint index, const GLdouble * v)
{
return glbinding::Binding::VertexAttrib2dv(index, v);
}
inline void glVertexAttrib2dvARB(GLuint index, const GLdouble * v)
{
return glbinding::Binding::VertexAttrib2dvARB(index, v);
}
inline void glVertexAttrib2dvNV(GLuint index, const GLdouble * v)
{
return glbinding::Binding::VertexAttrib2dvNV(index, v);
}
inline void glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
{
return glbinding::Binding::VertexAttrib2f(index, x, y);
}
inline void glVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)
{
return glbinding::Binding::VertexAttrib2fARB(index, x, y);
}
inline void glVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y)
{
return glbinding::Binding::VertexAttrib2fNV(index, x, y);
}
inline void glVertexAttrib2fv(GLuint index, const GLfloat * v)
{
return glbinding::Binding::VertexAttrib2fv(index, v);
}
inline void glVertexAttrib2fvARB(GLuint index, const GLfloat * v)
{
return glbinding::Binding::VertexAttrib2fvARB(index, v);
}
inline void glVertexAttrib2fvNV(GLuint index, const GLfloat * v)
{
return glbinding::Binding::VertexAttrib2fvNV(index, v);
}
inline void glVertexAttrib2hNV(GLuint index, GLhalfNV x, GLhalfNV y)
{
return glbinding::Binding::VertexAttrib2hNV(index, x, y);
}
inline void glVertexAttrib2hvNV(GLuint index, const GLhalfNV * v)
{
return glbinding::Binding::VertexAttrib2hvNV(index, v);
}
inline void glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
{
return glbinding::Binding::VertexAttrib2s(index, x, y);
}
inline void glVertexAttrib2sARB(GLuint index, GLshort x, GLshort y)
{
return glbinding::Binding::VertexAttrib2sARB(index, x, y);
}
inline void glVertexAttrib2sNV(GLuint index, GLshort x, GLshort y)
{
return glbinding::Binding::VertexAttrib2sNV(index, x, y);
}
inline void glVertexAttrib2sv(GLuint index, const GLshort * v)
{
return glbinding::Binding::VertexAttrib2sv(index, v);
}
inline void glVertexAttrib2svARB(GLuint index, const GLshort * v)
{
return glbinding::Binding::VertexAttrib2svARB(index, v);
}
inline void glVertexAttrib2svNV(GLuint index, const GLshort * v)
{
return glbinding::Binding::VertexAttrib2svNV(index, v);
}
inline void glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
return glbinding::Binding::VertexAttrib3d(index, x, y, z);
}
inline void glVertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
return glbinding::Binding::VertexAttrib3dARB(index, x, y, z);
}
inline void glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
return glbinding::Binding::VertexAttrib3dNV(index, x, y, z);
}
inline void glVertexAttrib3dv(GLuint index, const GLdouble * v)
{
return glbinding::Binding::VertexAttrib3dv(index, v);
}
inline void glVertexAttrib3dvARB(GLuint index, const GLdouble * v)
{
return glbinding::Binding::VertexAttrib3dvARB(index, v);
}
inline void glVertexAttrib3dvNV(GLuint index, const GLdouble * v)
{
return glbinding::Binding::VertexAttrib3dvNV(index, v);
}
inline void glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
{
return glbinding::Binding::VertexAttrib3f(index, x, y, z);
}
inline void glVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)
{
return glbinding::Binding::VertexAttrib3fARB(index, x, y, z);
}
inline void glVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z)
{
return glbinding::Binding::VertexAttrib3fNV(index, x, y, z);
}
inline void glVertexAttrib3fv(GLuint index, const GLfloat * v)
{
return glbinding::Binding::VertexAttrib3fv(index, v);
}
inline void glVertexAttrib3fvARB(GLuint index, const GLfloat * v)
{
return glbinding::Binding::VertexAttrib3fvARB(index, v);
}
inline void glVertexAttrib3fvNV(GLuint index, const GLfloat * v)
{
return glbinding::Binding::VertexAttrib3fvNV(index, v);
}
inline void glVertexAttrib3hNV(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z)
{
return glbinding::Binding::VertexAttrib3hNV(index, x, y, z);
}
inline void glVertexAttrib3hvNV(GLuint index, const GLhalfNV * v)
{
return glbinding::Binding::VertexAttrib3hvNV(index, v);
}
inline void glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
{
return glbinding::Binding::VertexAttrib3s(index, x, y, z);
}
inline void glVertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z)
{
return glbinding::Binding::VertexAttrib3sARB(index, x, y, z);
}
inline void glVertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z)
{
return glbinding::Binding::VertexAttrib3sNV(index, x, y, z);
}
inline void glVertexAttrib3sv(GLuint index, const GLshort * v)
{
return glbinding::Binding::VertexAttrib3sv(index, v);
}
inline void glVertexAttrib3svARB(GLuint index, const GLshort * v)
{
return glbinding::Binding::VertexAttrib3svARB(index, v);
}
inline void glVertexAttrib3svNV(GLuint index, const GLshort * v)
{
return glbinding::Binding::VertexAttrib3svNV(index, v);
}
inline void glVertexAttrib4Nbv(GLuint index, const GLbyte * v)
{
return glbinding::Binding::VertexAttrib4Nbv(index, v);
}
inline void glVertexAttrib4NbvARB(GLuint index, const GLbyte * v)
{
return glbinding::Binding::VertexAttrib4NbvARB(index, v);
}
inline void glVertexAttrib4Niv(GLuint index, const GLint * v)
{
return glbinding::Binding::VertexAttrib4Niv(index, v);
}
inline void glVertexAttrib4NivARB(GLuint index, const GLint * v)
{
return glbinding::Binding::VertexAttrib4NivARB(index, v);
}
inline void glVertexAttrib4Nsv(GLuint index, const GLshort * v)
{
return glbinding::Binding::VertexAttrib4Nsv(index, v);
}
inline void glVertexAttrib4NsvARB(GLuint index, const GLshort * v)
{
return glbinding::Binding::VertexAttrib4NsvARB(index, v);
}
inline void glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
{
return glbinding::Binding::VertexAttrib4Nub(index, x, y, z, w);
}
inline void glVertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
{
return glbinding::Binding::VertexAttrib4NubARB(index, x, y, z, w);
}
inline void glVertexAttrib4Nubv(GLuint index, const GLubyte * v)
{
return glbinding::Binding::VertexAttrib4Nubv(index, v);
}
inline void glVertexAttrib4NubvARB(GLuint index, const GLubyte * v)
{
return glbinding::Binding::VertexAttrib4NubvARB(index, v);
}
inline void glVertexAttrib4Nuiv(GLuint index, const GLuint * v)
{
return glbinding::Binding::VertexAttrib4Nuiv(index, v);
}
inline void glVertexAttrib4NuivARB(GLuint index, const GLuint * v)
{
return glbinding::Binding::VertexAttrib4NuivARB(index, v);
}
inline void glVertexAttrib4Nusv(GLuint index, const GLushort * v)
{
return glbinding::Binding::VertexAttrib4Nusv(index, v);
}
inline void glVertexAttrib4NusvARB(GLuint index, const GLushort * v)
{
return glbinding::Binding::VertexAttrib4NusvARB(index, v);
}
inline void glVertexAttrib4bv(GLuint index, const GLbyte * v)
{
return glbinding::Binding::VertexAttrib4bv(index, v);
}
inline void glVertexAttrib4bvARB(GLuint index, const GLbyte * v)
{
return glbinding::Binding::VertexAttrib4bvARB(index, v);
}
inline void glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
return glbinding::Binding::VertexAttrib4d(index, x, y, z, w);
}
inline void glVertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
return glbinding::Binding::VertexAttrib4dARB(index, x, y, z, w);
}
inline void glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
return glbinding::Binding::VertexAttrib4dNV(index, x, y, z, w);
}
inline void glVertexAttrib4dv(GLuint index, const GLdouble * v)
{
return glbinding::Binding::VertexAttrib4dv(index, v);
}
inline void glVertexAttrib4dvARB(GLuint index, const GLdouble * v)
{
return glbinding::Binding::VertexAttrib4dvARB(index, v);
}
inline void glVertexAttrib4dvNV(GLuint index, const GLdouble * v)
{
return glbinding::Binding::VertexAttrib4dvNV(index, v);
}
inline void glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
return glbinding::Binding::VertexAttrib4f(index, x, y, z, w);
}
inline void glVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
return glbinding::Binding::VertexAttrib4fARB(index, x, y, z, w);
}
inline void glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
return glbinding::Binding::VertexAttrib4fNV(index, x, y, z, w);
}
inline void glVertexAttrib4fv(GLuint index, const GLfloat * v)
{
return glbinding::Binding::VertexAttrib4fv(index, v);
}
inline void glVertexAttrib4fvARB(GLuint index, const GLfloat * v)
{
return glbinding::Binding::VertexAttrib4fvARB(index, v);
}
inline void glVertexAttrib4fvNV(GLuint index, const GLfloat * v)
{
return glbinding::Binding::VertexAttrib4fvNV(index, v);
}
inline void glVertexAttrib4hNV(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w)
{
return glbinding::Binding::VertexAttrib4hNV(index, x, y, z, w);
}
inline void glVertexAttrib4hvNV(GLuint index, const GLhalfNV * v)
{
return glbinding::Binding::VertexAttrib4hvNV(index, v);
}
inline void glVertexAttrib4iv(GLuint index, const GLint * v)
{
return glbinding::Binding::VertexAttrib4iv(index, v);
}
inline void glVertexAttrib4ivARB(GLuint index, const GLint * v)
{
return glbinding::Binding::VertexAttrib4ivARB(index, v);
}
inline void glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
{
return glbinding::Binding::VertexAttrib4s(index, x, y, z, w);
}
inline void glVertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
{
return glbinding::Binding::VertexAttrib4sARB(index, x, y, z, w);
}
inline void glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
{
return glbinding::Binding::VertexAttrib4sNV(index, x, y, z, w);
}
inline void glVertexAttrib4sv(GLuint index, const GLshort * v)
{
return glbinding::Binding::VertexAttrib4sv(index, v);
}
inline void glVertexAttrib4svARB(GLuint index, const GLshort * v)
{
return glbinding::Binding::VertexAttrib4svARB(index, v);
}
inline void glVertexAttrib4svNV(GLuint index, const GLshort * v)
{
return glbinding::Binding::VertexAttrib4svNV(index, v);
}
inline void glVertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
{
return glbinding::Binding::VertexAttrib4ubNV(index, x, y, z, w);
}
inline void glVertexAttrib4ubv(GLuint index, const GLubyte * v)
{
return glbinding::Binding::VertexAttrib4ubv(index, v);
}
inline void glVertexAttrib4ubvARB(GLuint index, const GLubyte * v)
{
return glbinding::Binding::VertexAttrib4ubvARB(index, v);
}
inline void glVertexAttrib4ubvNV(GLuint index, const GLubyte * v)
{
return glbinding::Binding::VertexAttrib4ubvNV(index, v);
}
inline void glVertexAttrib4uiv(GLuint index, const GLuint * v)
{
return glbinding::Binding::VertexAttrib4uiv(index, v);
}
inline void glVertexAttrib4uivARB(GLuint index, const GLuint * v)
{
return glbinding::Binding::VertexAttrib4uivARB(index, v);
}
inline void glVertexAttrib4usv(GLuint index, const GLushort * v)
{
return glbinding::Binding::VertexAttrib4usv(index, v);
}
inline void glVertexAttrib4usvARB(GLuint index, const GLushort * v)
{
return glbinding::Binding::VertexAttrib4usvARB(index, v);
}
inline void glVertexAttribArrayObjectATI(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint buffer, GLuint offset)
{
return glbinding::Binding::VertexAttribArrayObjectATI(index, size, type, normalized, stride, buffer, offset);
}
inline void glVertexAttribBinding(GLuint attribindex, GLuint bindingindex)
{
return glbinding::Binding::VertexAttribBinding(attribindex, bindingindex);
}
inline void glVertexAttribDivisor(GLuint index, GLuint divisor)
{
return glbinding::Binding::VertexAttribDivisor(index, divisor);
}
inline void glVertexAttribDivisorARB(GLuint index, GLuint divisor)
{
return glbinding::Binding::VertexAttribDivisorARB(index, divisor);
}
inline void glVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
{
return glbinding::Binding::VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
}
inline void glVertexAttribFormatNV(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride)
{
return glbinding::Binding::VertexAttribFormatNV(index, size, type, normalized, stride);
}
inline void glVertexAttribI1i(GLuint index, GLint x)
{
return glbinding::Binding::VertexAttribI1i(index, x);
}
inline void glVertexAttribI1iEXT(GLuint index, GLint x)
{
return glbinding::Binding::VertexAttribI1iEXT(index, x);
}
inline void glVertexAttribI1iv(GLuint index, const GLint * v)
{
return glbinding::Binding::VertexAttribI1iv(index, v);
}
inline void glVertexAttribI1ivEXT(GLuint index, const GLint * v)
{
return glbinding::Binding::VertexAttribI1ivEXT(index, v);
}
inline void glVertexAttribI1ui(GLuint index, GLuint x)
{
return glbinding::Binding::VertexAttribI1ui(index, x);
}
inline void glVertexAttribI1uiEXT(GLuint index, GLuint x)
{
return glbinding::Binding::VertexAttribI1uiEXT(index, x);
}
inline void glVertexAttribI1uiv(GLuint index, const GLuint * v)
{
return glbinding::Binding::VertexAttribI1uiv(index, v);
}
inline void glVertexAttribI1uivEXT(GLuint index, const GLuint * v)
{
return glbinding::Binding::VertexAttribI1uivEXT(index, v);
}
inline void glVertexAttribI2i(GLuint index, GLint x, GLint y)
{
return glbinding::Binding::VertexAttribI2i(index, x, y);
}
inline void glVertexAttribI2iEXT(GLuint index, GLint x, GLint y)
{
return glbinding::Binding::VertexAttribI2iEXT(index, x, y);
}
inline void glVertexAttribI2iv(GLuint index, const GLint * v)
{
return glbinding::Binding::VertexAttribI2iv(index, v);
}
inline void glVertexAttribI2ivEXT(GLuint index, const GLint * v)
{
return glbinding::Binding::VertexAttribI2ivEXT(index, v);
}
inline void glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
{
return glbinding::Binding::VertexAttribI2ui(index, x, y);
}
inline void glVertexAttribI2uiEXT(GLuint index, GLuint x, GLuint y)
{
return glbinding::Binding::VertexAttribI2uiEXT(index, x, y);
}
inline void glVertexAttribI2uiv(GLuint index, const GLuint * v)
{
return glbinding::Binding::VertexAttribI2uiv(index, v);
}
inline void glVertexAttribI2uivEXT(GLuint index, const GLuint * v)
{
return glbinding::Binding::VertexAttribI2uivEXT(index, v);
}
inline void glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
{
return glbinding::Binding::VertexAttribI3i(index, x, y, z);
}
inline void glVertexAttribI3iEXT(GLuint index, GLint x, GLint y, GLint z)
{
return glbinding::Binding::VertexAttribI3iEXT(index, x, y, z);
}
inline void glVertexAttribI3iv(GLuint index, const GLint * v)
{
return glbinding::Binding::VertexAttribI3iv(index, v);
}
inline void glVertexAttribI3ivEXT(GLuint index, const GLint * v)
{
return glbinding::Binding::VertexAttribI3ivEXT(index, v);
}
inline void glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
{
return glbinding::Binding::VertexAttribI3ui(index, x, y, z);
}
inline void glVertexAttribI3uiEXT(GLuint index, GLuint x, GLuint y, GLuint z)
{
return glbinding::Binding::VertexAttribI3uiEXT(index, x, y, z);
}
inline void glVertexAttribI3uiv(GLuint index, const GLuint * v)
{
return glbinding::Binding::VertexAttribI3uiv(index, v);
}
inline void glVertexAttribI3uivEXT(GLuint index, const GLuint * v)
{
return glbinding::Binding::VertexAttribI3uivEXT(index, v);
}
inline void glVertexAttribI4bv(GLuint index, const GLbyte * v)
{
return glbinding::Binding::VertexAttribI4bv(index, v);
}
inline void glVertexAttribI4bvEXT(GLuint index, const GLbyte * v)
{
return glbinding::Binding::VertexAttribI4bvEXT(index, v);
}
inline void glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
{
return glbinding::Binding::VertexAttribI4i(index, x, y, z, w);
}
inline void glVertexAttribI4iEXT(GLuint index, GLint x, GLint y, GLint z, GLint w)
{
return glbinding::Binding::VertexAttribI4iEXT(index, x, y, z, w);
}
inline void glVertexAttribI4iv(GLuint index, const GLint * v)
{
return glbinding::Binding::VertexAttribI4iv(index, v);
}
inline void glVertexAttribI4ivEXT(GLuint index, const GLint * v)
{
return glbinding::Binding::VertexAttribI4ivEXT(index, v);
}
inline void glVertexAttribI4sv(GLuint index, const GLshort * v)
{
return glbinding::Binding::VertexAttribI4sv(index, v);
}
inline void glVertexAttribI4svEXT(GLuint index, const GLshort * v)
{
return glbinding::Binding::VertexAttribI4svEXT(index, v);
}
inline void glVertexAttribI4ubv(GLuint index, const GLubyte * v)
{
return glbinding::Binding::VertexAttribI4ubv(index, v);
}
inline void glVertexAttribI4ubvEXT(GLuint index, const GLubyte * v)
{
return glbinding::Binding::VertexAttribI4ubvEXT(index, v);
}
inline void glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
{
return glbinding::Binding::VertexAttribI4ui(index, x, y, z, w);
}
inline void glVertexAttribI4uiEXT(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
{
return glbinding::Binding::VertexAttribI4uiEXT(index, x, y, z, w);
}
inline void glVertexAttribI4uiv(GLuint index, const GLuint * v)
{
return glbinding::Binding::VertexAttribI4uiv(index, v);
}
inline void glVertexAttribI4uivEXT(GLuint index, const GLuint * v)
{
return glbinding::Binding::VertexAttribI4uivEXT(index, v);
}
inline void glVertexAttribI4usv(GLuint index, const GLushort * v)
{
return glbinding::Binding::VertexAttribI4usv(index, v);
}
inline void glVertexAttribI4usvEXT(GLuint index, const GLushort * v)
{
return glbinding::Binding::VertexAttribI4usvEXT(index, v);
}
inline void glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
{
return glbinding::Binding::VertexAttribIFormat(attribindex, size, type, relativeoffset);
}
inline void glVertexAttribIFormatNV(GLuint index, GLint size, GLenum type, GLsizei stride)
{
return glbinding::Binding::VertexAttribIFormatNV(index, size, type, stride);
}
inline void glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer)
{
return glbinding::Binding::VertexAttribIPointer(index, size, type, stride, pointer);
}
inline void glVertexAttribIPointerEXT(GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer)
{
return glbinding::Binding::VertexAttribIPointerEXT(index, size, type, stride, pointer);
}
inline void glVertexAttribL1d(GLuint index, GLdouble x)
{
return glbinding::Binding::VertexAttribL1d(index, x);
}
inline void glVertexAttribL1dEXT(GLuint index, GLdouble x)
{
return glbinding::Binding::VertexAttribL1dEXT(index, x);
}
inline void glVertexAttribL1dv(GLuint index, const GLdouble * v)
{
return glbinding::Binding::VertexAttribL1dv(index, v);
}
inline void glVertexAttribL1dvEXT(GLuint index, const GLdouble * v)
{
return glbinding::Binding::VertexAttribL1dvEXT(index, v);
}
inline void glVertexAttribL1i64NV(GLuint index, GLint64EXT x)
{
return glbinding::Binding::VertexAttribL1i64NV(index, x);
}
inline void glVertexAttribL1i64vNV(GLuint index, const GLint64EXT * v)
{
return glbinding::Binding::VertexAttribL1i64vNV(index, v);
}
inline void glVertexAttribL1ui64ARB(GLuint index, GLuint64EXT x)
{
return glbinding::Binding::VertexAttribL1ui64ARB(index, x);
}
inline void glVertexAttribL1ui64NV(GLuint index, GLuint64EXT x)
{
return glbinding::Binding::VertexAttribL1ui64NV(index, x);
}
inline void glVertexAttribL1ui64vARB(GLuint index, const GLuint64EXT * v)
{
return glbinding::Binding::VertexAttribL1ui64vARB(index, v);
}
inline void glVertexAttribL1ui64vNV(GLuint index, const GLuint64EXT * v)
{
return glbinding::Binding::VertexAttribL1ui64vNV(index, v);
}
inline void glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
{
return glbinding::Binding::VertexAttribL2d(index, x, y);
}
inline void glVertexAttribL2dEXT(GLuint index, GLdouble x, GLdouble y)
{
return glbinding::Binding::VertexAttribL2dEXT(index, x, y);
}
inline void glVertexAttribL2dv(GLuint index, const GLdouble * v)
{
return glbinding::Binding::VertexAttribL2dv(index, v);
}
inline void glVertexAttribL2dvEXT(GLuint index, const GLdouble * v)
{
return glbinding::Binding::VertexAttribL2dvEXT(index, v);
}
inline void glVertexAttribL2i64NV(GLuint index, GLint64EXT x, GLint64EXT y)
{
return glbinding::Binding::VertexAttribL2i64NV(index, x, y);
}
inline void glVertexAttribL2i64vNV(GLuint index, const GLint64EXT * v)
{
return glbinding::Binding::VertexAttribL2i64vNV(index, v);
}
inline void glVertexAttribL2ui64NV(GLuint index, GLuint64EXT x, GLuint64EXT y)
{
return glbinding::Binding::VertexAttribL2ui64NV(index, x, y);
}
inline void glVertexAttribL2ui64vNV(GLuint index, const GLuint64EXT * v)
{
return glbinding::Binding::VertexAttribL2ui64vNV(index, v);
}
inline void glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
return glbinding::Binding::VertexAttribL3d(index, x, y, z);
}
inline void glVertexAttribL3dEXT(GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
return glbinding::Binding::VertexAttribL3dEXT(index, x, y, z);
}
inline void glVertexAttribL3dv(GLuint index, const GLdouble * v)
{
return glbinding::Binding::VertexAttribL3dv(index, v);
}
inline void glVertexAttribL3dvEXT(GLuint index, const GLdouble * v)
{
return glbinding::Binding::VertexAttribL3dvEXT(index, v);
}
inline void glVertexAttribL3i64NV(GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z)
{
return glbinding::Binding::VertexAttribL3i64NV(index, x, y, z);
}
inline void glVertexAttribL3i64vNV(GLuint index, const GLint64EXT * v)
{
return glbinding::Binding::VertexAttribL3i64vNV(index, v);
}
inline void glVertexAttribL3ui64NV(GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z)
{
return glbinding::Binding::VertexAttribL3ui64NV(index, x, y, z);
}
inline void glVertexAttribL3ui64vNV(GLuint index, const GLuint64EXT * v)
{
return glbinding::Binding::VertexAttribL3ui64vNV(index, v);
}
inline void glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
return glbinding::Binding::VertexAttribL4d(index, x, y, z, w);
}
inline void glVertexAttribL4dEXT(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
return glbinding::Binding::VertexAttribL4dEXT(index, x, y, z, w);
}
inline void glVertexAttribL4dv(GLuint index, const GLdouble * v)
{
return glbinding::Binding::VertexAttribL4dv(index, v);
}
inline void glVertexAttribL4dvEXT(GLuint index, const GLdouble * v)
{
return glbinding::Binding::VertexAttribL4dvEXT(index, v);
}
inline void glVertexAttribL4i64NV(GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w)
{
return glbinding::Binding::VertexAttribL4i64NV(index, x, y, z, w);
}
inline void glVertexAttribL4i64vNV(GLuint index, const GLint64EXT * v)
{
return glbinding::Binding::VertexAttribL4i64vNV(index, v);
}
inline void glVertexAttribL4ui64NV(GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w)
{
return glbinding::Binding::VertexAttribL4ui64NV(index, x, y, z, w);
}
inline void glVertexAttribL4ui64vNV(GLuint index, const GLuint64EXT * v)
{
return glbinding::Binding::VertexAttribL4ui64vNV(index, v);
}
inline void glVertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
{
return glbinding::Binding::VertexAttribLFormat(attribindex, size, type, relativeoffset);
}
inline void glVertexAttribLFormatNV(GLuint index, GLint size, GLenum type, GLsizei stride)
{
return glbinding::Binding::VertexAttribLFormatNV(index, size, type, stride);
}
inline void glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer)
{
return glbinding::Binding::VertexAttribLPointer(index, size, type, stride, pointer);
}
inline void glVertexAttribLPointerEXT(GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer)
{
return glbinding::Binding::VertexAttribLPointerEXT(index, size, type, stride, pointer);
}
inline void glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
{
return glbinding::Binding::VertexAttribP1ui(index, type, normalized, value);
}
inline void glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint * value)
{
return glbinding::Binding::VertexAttribP1uiv(index, type, normalized, value);
}
inline void glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
{
return glbinding::Binding::VertexAttribP2ui(index, type, normalized, value);
}
inline void glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint * value)
{
return glbinding::Binding::VertexAttribP2uiv(index, type, normalized, value);
}
inline void glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
{
return glbinding::Binding::VertexAttribP3ui(index, type, normalized, value);
}
inline void glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint * value)
{
return glbinding::Binding::VertexAttribP3uiv(index, type, normalized, value);
}
inline void glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
{
return glbinding::Binding::VertexAttribP4ui(index, type, normalized, value);
}
inline void glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint * value)
{
return glbinding::Binding::VertexAttribP4uiv(index, type, normalized, value);
}
inline void glVertexAttribParameteriAMD(GLuint index, GLenum pname, GLint param)
{
return glbinding::Binding::VertexAttribParameteriAMD(index, pname, param);
}
inline void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * pointer)
{
return glbinding::Binding::VertexAttribPointer(index, size, type, normalized, stride, pointer);
}
inline void glVertexAttribPointerARB(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * pointer)
{
return glbinding::Binding::VertexAttribPointerARB(index, size, type, normalized, stride, pointer);
}
inline void glVertexAttribPointerNV(GLuint index, GLint fsize, GLenum type, GLsizei stride, const void * pointer)
{
return glbinding::Binding::VertexAttribPointerNV(index, fsize, type, stride, pointer);
}
inline void glVertexAttribs1dvNV(GLuint index, GLsizei count, const GLdouble * v)
{
return glbinding::Binding::VertexAttribs1dvNV(index, count, v);
}
inline void glVertexAttribs1fvNV(GLuint index, GLsizei count, const GLfloat * v)
{
return glbinding::Binding::VertexAttribs1fvNV(index, count, v);
}
inline void glVertexAttribs1hvNV(GLuint index, GLsizei n, const GLhalfNV * v)
{
return glbinding::Binding::VertexAttribs1hvNV(index, n, v);
}
inline void glVertexAttribs1svNV(GLuint index, GLsizei count, const GLshort * v)
{
return glbinding::Binding::VertexAttribs1svNV(index, count, v);
}
inline void glVertexAttribs2dvNV(GLuint index, GLsizei count, const GLdouble * v)
{
return glbinding::Binding::VertexAttribs2dvNV(index, count, v);
}
inline void glVertexAttribs2fvNV(GLuint index, GLsizei count, const GLfloat * v)
{
return glbinding::Binding::VertexAttribs2fvNV(index, count, v);
}
inline void glVertexAttribs2hvNV(GLuint index, GLsizei n, const GLhalfNV * v)
{
return glbinding::Binding::VertexAttribs2hvNV(index, n, v);
}
inline void glVertexAttribs2svNV(GLuint index, GLsizei count, const GLshort * v)
{
return glbinding::Binding::VertexAttribs2svNV(index, count, v);
}
inline void glVertexAttribs3dvNV(GLuint index, GLsizei count, const GLdouble * v)
{
return glbinding::Binding::VertexAttribs3dvNV(index, count, v);
}
inline void glVertexAttribs3fvNV(GLuint index, GLsizei count, const GLfloat * v)
{
return glbinding::Binding::VertexAttribs3fvNV(index, count, v);
}
inline void glVertexAttribs3hvNV(GLuint index, GLsizei n, const GLhalfNV * v)
{
return glbinding::Binding::VertexAttribs3hvNV(index, n, v);
}
inline void glVertexAttribs3svNV(GLuint index, GLsizei count, const GLshort * v)
{
return glbinding::Binding::VertexAttribs3svNV(index, count, v);
}
inline void glVertexAttribs4dvNV(GLuint index, GLsizei count, const GLdouble * v)
{
return glbinding::Binding::VertexAttribs4dvNV(index, count, v);
}
inline void glVertexAttribs4fvNV(GLuint index, GLsizei count, const GLfloat * v)
{
return glbinding::Binding::VertexAttribs4fvNV(index, count, v);
}
inline void glVertexAttribs4hvNV(GLuint index, GLsizei n, const GLhalfNV * v)
{
return glbinding::Binding::VertexAttribs4hvNV(index, n, v);
}
inline void glVertexAttribs4svNV(GLuint index, GLsizei count, const GLshort * v)
{
return glbinding::Binding::VertexAttribs4svNV(index, count, v);
}
inline void glVertexAttribs4ubvNV(GLuint index, GLsizei count, const GLubyte * v)
{
return glbinding::Binding::VertexAttribs4ubvNV(index, count, v);
}
inline void glVertexBindingDivisor(GLuint bindingindex, GLuint divisor)
{
return glbinding::Binding::VertexBindingDivisor(bindingindex, divisor);
}
inline void glVertexBlendARB(GLint count)
{
return glbinding::Binding::VertexBlendARB(count);
}
inline void glVertexBlendEnvfATI(GLenum pname, GLfloat param)
{
return glbinding::Binding::VertexBlendEnvfATI(pname, param);
}
inline void glVertexBlendEnviATI(GLenum pname, GLint param)
{
return glbinding::Binding::VertexBlendEnviATI(pname, param);
}
inline void glVertexFormatNV(GLint size, GLenum type, GLsizei stride)
{
return glbinding::Binding::VertexFormatNV(size, type, stride);
}
inline void glVertexP2ui(GLenum type, GLuint value)
{
return glbinding::Binding::VertexP2ui(type, value);
}
inline void glVertexP2uiv(GLenum type, const GLuint * value)
{
return glbinding::Binding::VertexP2uiv(type, value);
}
inline void glVertexP3ui(GLenum type, GLuint value)
{
return glbinding::Binding::VertexP3ui(type, value);
}
inline void glVertexP3uiv(GLenum type, const GLuint * value)
{
return glbinding::Binding::VertexP3uiv(type, value);
}
inline void glVertexP4ui(GLenum type, GLuint value)
{
return glbinding::Binding::VertexP4ui(type, value);
}
inline void glVertexP4uiv(GLenum type, const GLuint * value)
{
return glbinding::Binding::VertexP4uiv(type, value);
}
inline void glVertexPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const void * pointer)
{
return glbinding::Binding::VertexPointerEXT(size, type, stride, count, pointer);
}
inline void glVertexPointerListIBM(GLint size, GLenum type, GLint stride, const void ** pointer, GLint ptrstride)
{
return glbinding::Binding::VertexPointerListIBM(size, type, stride, pointer, ptrstride);
}
inline void glVertexPointervINTEL(GLint size, GLenum type, const void ** pointer)
{
return glbinding::Binding::VertexPointervINTEL(size, type, pointer);
}
inline void glVertexStream1dATI(GLenum stream, GLdouble x)
{
return glbinding::Binding::VertexStream1dATI(stream, x);
}
inline void glVertexStream1dvATI(GLenum stream, const GLdouble * coords)
{
return glbinding::Binding::VertexStream1dvATI(stream, coords);
}
inline void glVertexStream1fATI(GLenum stream, GLfloat x)
{
return glbinding::Binding::VertexStream1fATI(stream, x);
}
inline void glVertexStream1fvATI(GLenum stream, const GLfloat * coords)
{
return glbinding::Binding::VertexStream1fvATI(stream, coords);
}
inline void glVertexStream1iATI(GLenum stream, GLint x)
{
return glbinding::Binding::VertexStream1iATI(stream, x);
}
inline void glVertexStream1ivATI(GLenum stream, const GLint * coords)
{
return glbinding::Binding::VertexStream1ivATI(stream, coords);
}
inline void glVertexStream1sATI(GLenum stream, GLshort x)
{
return glbinding::Binding::VertexStream1sATI(stream, x);
}
inline void glVertexStream1svATI(GLenum stream, const GLshort * coords)
{
return glbinding::Binding::VertexStream1svATI(stream, coords);
}
inline void glVertexStream2dATI(GLenum stream, GLdouble x, GLdouble y)
{
return glbinding::Binding::VertexStream2dATI(stream, x, y);
}
inline void glVertexStream2dvATI(GLenum stream, const GLdouble * coords)
{
return glbinding::Binding::VertexStream2dvATI(stream, coords);
}
inline void glVertexStream2fATI(GLenum stream, GLfloat x, GLfloat y)
{
return glbinding::Binding::VertexStream2fATI(stream, x, y);
}
inline void glVertexStream2fvATI(GLenum stream, const GLfloat * coords)
{
return glbinding::Binding::VertexStream2fvATI(stream, coords);
}
inline void glVertexStream2iATI(GLenum stream, GLint x, GLint y)
{
return glbinding::Binding::VertexStream2iATI(stream, x, y);
}
inline void glVertexStream2ivATI(GLenum stream, const GLint * coords)
{
return glbinding::Binding::VertexStream2ivATI(stream, coords);
}
inline void glVertexStream2sATI(GLenum stream, GLshort x, GLshort y)
{
return glbinding::Binding::VertexStream2sATI(stream, x, y);
}
inline void glVertexStream2svATI(GLenum stream, const GLshort * coords)
{
return glbinding::Binding::VertexStream2svATI(stream, coords);
}
inline void glVertexStream3dATI(GLenum stream, GLdouble x, GLdouble y, GLdouble z)
{
return glbinding::Binding::VertexStream3dATI(stream, x, y, z);
}
inline void glVertexStream3dvATI(GLenum stream, const GLdouble * coords)
{
return glbinding::Binding::VertexStream3dvATI(stream, coords);
}
inline void glVertexStream3fATI(GLenum stream, GLfloat x, GLfloat y, GLfloat z)
{
return glbinding::Binding::VertexStream3fATI(stream, x, y, z);
}
inline void glVertexStream3fvATI(GLenum stream, const GLfloat * coords)
{
return glbinding::Binding::VertexStream3fvATI(stream, coords);
}
inline void glVertexStream3iATI(GLenum stream, GLint x, GLint y, GLint z)
{
return glbinding::Binding::VertexStream3iATI(stream, x, y, z);
}
inline void glVertexStream3ivATI(GLenum stream, const GLint * coords)
{
return glbinding::Binding::VertexStream3ivATI(stream, coords);
}
inline void glVertexStream3sATI(GLenum stream, GLshort x, GLshort y, GLshort z)
{
return glbinding::Binding::VertexStream3sATI(stream, x, y, z);
}
inline void glVertexStream3svATI(GLenum stream, const GLshort * coords)
{
return glbinding::Binding::VertexStream3svATI(stream, coords);
}
inline void glVertexStream4dATI(GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
return glbinding::Binding::VertexStream4dATI(stream, x, y, z, w);
}
inline void glVertexStream4dvATI(GLenum stream, const GLdouble * coords)
{
return glbinding::Binding::VertexStream4dvATI(stream, coords);
}
inline void glVertexStream4fATI(GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
return glbinding::Binding::VertexStream4fATI(stream, x, y, z, w);
}
inline void glVertexStream4fvATI(GLenum stream, const GLfloat * coords)
{
return glbinding::Binding::VertexStream4fvATI(stream, coords);
}
inline void glVertexStream4iATI(GLenum stream, GLint x, GLint y, GLint z, GLint w)
{
return glbinding::Binding::VertexStream4iATI(stream, x, y, z, w);
}
inline void glVertexStream4ivATI(GLenum stream, const GLint * coords)
{
return glbinding::Binding::VertexStream4ivATI(stream, coords);
}
inline void glVertexStream4sATI(GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w)
{
return glbinding::Binding::VertexStream4sATI(stream, x, y, z, w);
}
inline void glVertexStream4svATI(GLenum stream, const GLshort * coords)
{
return glbinding::Binding::VertexStream4svATI(stream, coords);
}
inline void glVertexWeightPointerEXT(GLint size, GLenum type, GLsizei stride, const void * pointer)
{
return glbinding::Binding::VertexWeightPointerEXT(size, type, stride, pointer);
}
inline void glVertexWeightfEXT(GLfloat weight)
{
return glbinding::Binding::VertexWeightfEXT(weight);
}
inline void glVertexWeightfvEXT(const GLfloat * weight)
{
return glbinding::Binding::VertexWeightfvEXT(weight);
}
inline void glVertexWeighthNV(GLhalfNV weight)
{
return glbinding::Binding::VertexWeighthNV(weight);
}
inline void glVertexWeighthvNV(const GLhalfNV * weight)
{
return glbinding::Binding::VertexWeighthvNV(weight);
}
inline GLenum glVideoCaptureNV(GLuint video_capture_slot, GLuint * sequence_num, GLuint64EXT * capture_time)
{
return static_cast<gl14ext::GLenum>(glbinding::Binding::VideoCaptureNV(video_capture_slot, sequence_num, capture_time));
}
inline void glVideoCaptureStreamParameterdvNV(GLuint video_capture_slot, GLuint stream, GLenum pname, const GLdouble * params)
{
return glbinding::Binding::VideoCaptureStreamParameterdvNV(video_capture_slot, stream, pname, params);
}
inline void glVideoCaptureStreamParameterfvNV(GLuint video_capture_slot, GLuint stream, GLenum pname, const GLfloat * params)
{
return glbinding::Binding::VideoCaptureStreamParameterfvNV(video_capture_slot, stream, pname, params);
}
inline void glVideoCaptureStreamParameterivNV(GLuint video_capture_slot, GLuint stream, GLenum pname, const GLint * params)
{
return glbinding::Binding::VideoCaptureStreamParameterivNV(video_capture_slot, stream, pname, params);
}
inline void glViewportArrayv(GLuint first, GLsizei count, const GLfloat * v)
{
return glbinding::Binding::ViewportArrayv(first, count, v);
}
inline void glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
{
return glbinding::Binding::ViewportIndexedf(index, x, y, w, h);
}
inline void glViewportIndexedfv(GLuint index, const GLfloat * v)
{
return glbinding::Binding::ViewportIndexedfv(index, v);
}
inline void glWaitSync(GLsync sync, UnusedMask flags, GLuint64 timeout)
{
return glbinding::Binding::WaitSync(sync, flags, timeout);
}
inline void glWeightPathsNV(GLuint resultPath, GLsizei numPaths, const GLuint * paths, const GLfloat * weights)
{
return glbinding::Binding::WeightPathsNV(resultPath, numPaths, paths, weights);
}
inline void glWeightPointerARB(GLint size, GLenum type, GLsizei stride, const void * pointer)
{
return glbinding::Binding::WeightPointerARB(size, type, stride, pointer);
}
inline void glWeightbvARB(GLint size, const GLbyte * weights)
{
return glbinding::Binding::WeightbvARB(size, weights);
}
inline void glWeightdvARB(GLint size, const GLdouble * weights)
{
return glbinding::Binding::WeightdvARB(size, weights);
}
inline void glWeightfvARB(GLint size, const GLfloat * weights)
{
return glbinding::Binding::WeightfvARB(size, weights);
}
inline void glWeightivARB(GLint size, const GLint * weights)
{
return glbinding::Binding::WeightivARB(size, weights);
}
inline void glWeightsvARB(GLint size, const GLshort * weights)
{
return glbinding::Binding::WeightsvARB(size, weights);
}
inline void glWeightubvARB(GLint size, const GLubyte * weights)
{
return glbinding::Binding::WeightubvARB(size, weights);
}
inline void glWeightuivARB(GLint size, const GLuint * weights)
{
return glbinding::Binding::WeightuivARB(size, weights);
}
inline void glWeightusvARB(GLint size, const GLushort * weights)
{
return glbinding::Binding::WeightusvARB(size, weights);
}
inline void glWindowPos2dARB(GLdouble x, GLdouble y)
{
return glbinding::Binding::WindowPos2dARB(x, y);
}
inline void glWindowPos2dMESA(GLdouble x, GLdouble y)
{
return glbinding::Binding::WindowPos2dMESA(x, y);
}
inline void glWindowPos2dvARB(const GLdouble * v)
{
return glbinding::Binding::WindowPos2dvARB(v);
}
inline void glWindowPos2dvMESA(const GLdouble * v)
{
return glbinding::Binding::WindowPos2dvMESA(v);
}
inline void glWindowPos2fARB(GLfloat x, GLfloat y)
{
return glbinding::Binding::WindowPos2fARB(x, y);
}
inline void glWindowPos2fMESA(GLfloat x, GLfloat y)
{
return glbinding::Binding::WindowPos2fMESA(x, y);
}
inline void glWindowPos2fvARB(const GLfloat * v)
{
return glbinding::Binding::WindowPos2fvARB(v);
}
inline void glWindowPos2fvMESA(const GLfloat * v)
{
return glbinding::Binding::WindowPos2fvMESA(v);
}
inline void glWindowPos2iARB(GLint x, GLint y)
{
return glbinding::Binding::WindowPos2iARB(x, y);
}
inline void glWindowPos2iMESA(GLint x, GLint y)
{
return glbinding::Binding::WindowPos2iMESA(x, y);
}
inline void glWindowPos2ivARB(const GLint * v)
{
return glbinding::Binding::WindowPos2ivARB(v);
}
inline void glWindowPos2ivMESA(const GLint * v)
{
return glbinding::Binding::WindowPos2ivMESA(v);
}
inline void glWindowPos2sARB(GLshort x, GLshort y)
{
return glbinding::Binding::WindowPos2sARB(x, y);
}
inline void glWindowPos2sMESA(GLshort x, GLshort y)
{
return glbinding::Binding::WindowPos2sMESA(x, y);
}
inline void glWindowPos2svARB(const GLshort * v)
{
return glbinding::Binding::WindowPos2svARB(v);
}
inline void glWindowPos2svMESA(const GLshort * v)
{
return glbinding::Binding::WindowPos2svMESA(v);
}
inline void glWindowPos3dARB(GLdouble x, GLdouble y, GLdouble z)
{
return glbinding::Binding::WindowPos3dARB(x, y, z);
}
inline void glWindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z)
{
return glbinding::Binding::WindowPos3dMESA(x, y, z);
}
inline void glWindowPos3dvARB(const GLdouble * v)
{
return glbinding::Binding::WindowPos3dvARB(v);
}
inline void glWindowPos3dvMESA(const GLdouble * v)
{
return glbinding::Binding::WindowPos3dvMESA(v);
}
inline void glWindowPos3fARB(GLfloat x, GLfloat y, GLfloat z)
{
return glbinding::Binding::WindowPos3fARB(x, y, z);
}
inline void glWindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z)
{
return glbinding::Binding::WindowPos3fMESA(x, y, z);
}
inline void glWindowPos3fvARB(const GLfloat * v)
{
return glbinding::Binding::WindowPos3fvARB(v);
}
inline void glWindowPos3fvMESA(const GLfloat * v)
{
return glbinding::Binding::WindowPos3fvMESA(v);
}
inline void glWindowPos3iARB(GLint x, GLint y, GLint z)
{
return glbinding::Binding::WindowPos3iARB(x, y, z);
}
inline void glWindowPos3iMESA(GLint x, GLint y, GLint z)
{
return glbinding::Binding::WindowPos3iMESA(x, y, z);
}
inline void glWindowPos3ivARB(const GLint * v)
{
return glbinding::Binding::WindowPos3ivARB(v);
}
inline void glWindowPos3ivMESA(const GLint * v)
{
return glbinding::Binding::WindowPos3ivMESA(v);
}
inline void glWindowPos3sARB(GLshort x, GLshort y, GLshort z)
{
return glbinding::Binding::WindowPos3sARB(x, y, z);
}
inline void glWindowPos3sMESA(GLshort x, GLshort y, GLshort z)
{
return glbinding::Binding::WindowPos3sMESA(x, y, z);
}
inline void glWindowPos3svARB(const GLshort * v)
{
return glbinding::Binding::WindowPos3svARB(v);
}
inline void glWindowPos3svMESA(const GLshort * v)
{
return glbinding::Binding::WindowPos3svMESA(v);
}
inline void glWindowPos4dMESA(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
return glbinding::Binding::WindowPos4dMESA(x, y, z, w);
}
inline void glWindowPos4dvMESA(const GLdouble * v)
{
return glbinding::Binding::WindowPos4dvMESA(v);
}
inline void glWindowPos4fMESA(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
return glbinding::Binding::WindowPos4fMESA(x, y, z, w);
}
inline void glWindowPos4fvMESA(const GLfloat * v)
{
return glbinding::Binding::WindowPos4fvMESA(v);
}
inline void glWindowPos4iMESA(GLint x, GLint y, GLint z, GLint w)
{
return glbinding::Binding::WindowPos4iMESA(x, y, z, w);
}
inline void glWindowPos4ivMESA(const GLint * v)
{
return glbinding::Binding::WindowPos4ivMESA(v);
}
inline void glWindowPos4sMESA(GLshort x, GLshort y, GLshort z, GLshort w)
{
return glbinding::Binding::WindowPos4sMESA(x, y, z, w);
}
inline void glWindowPos4svMESA(const GLshort * v)
{
return glbinding::Binding::WindowPos4svMESA(v);
}
inline void glWriteMaskEXT(GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW)
{
return glbinding::Binding::WriteMaskEXT(res, in, outX, outY, outZ, outW);
}
} // namespace gl14ext
| [
"[email protected]"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.