blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 5
146
| content_id
stringlengths 40
40
| detected_licenses
listlengths 0
7
| license_type
stringclasses 2
values | repo_name
stringlengths 6
79
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringclasses 4
values | visit_date
timestamp[us] | revision_date
timestamp[us] | committer_date
timestamp[us] | github_id
int64 5.07k
426M
⌀ | star_events_count
int64 0
27
| fork_events_count
int64 0
12
| gha_license_id
stringclasses 3
values | gha_event_created_at
timestamp[us] | gha_created_at
timestamp[us] | gha_language
stringclasses 6
values | src_encoding
stringclasses 26
values | language
stringclasses 1
value | is_vendor
bool 1
class | is_generated
bool 1
class | length_bytes
int64 20
6.28M
| extension
stringclasses 20
values | content
stringlengths 20
6.28M
| authors
listlengths 1
16
| author_lines
listlengths 1
16
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
3458b696c6fa6d283501ae12e115d212c790c3ba | 4323418f83efdc8b9f8b8bb1cc15680ba66e1fa8 | /Trunk/Battle Cars/Battle Cars/Source/CSGD_TextureManager.cpp | 5fb0d5e626262a0b39d91b18ff1a24cd334c82aa | []
| no_license | FiveFourFive/battle-cars | 5f2046e7afe5ac50eeeb9129b87fcb4b2893386c | 1809cce27a975376b0b087a96835347069fe2d4c | refs/heads/master | 2021-05-29T19:52:25.782568 | 2011-07-28T17:48:39 | 2011-07-28T17:48:39 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 11,949 | cpp | ////////////////////////////////////////////////////////
// File : "CSGD_TextureManager.cpp"
//
// Author : Jensen Rivera (JR)
//
// Date Created : 6/26/2006
//
// Purpose : Wrapper class for Direct3D.
////////////////////////////////////////////////////////
/*
Disclaimer:
This source code was developed for and is the property of:
(c) Full Sail University Game Development Curriculum 2008-2011 and
(c) Full Sail Real World Education Game Design & Development Curriculum 2000-2008
Full Sail students may not redistribute or make this code public,
but may use it in their own personal projects.
*/
#include "CSGD_TextureManager.h"
#include <assert.h> // code in assertions gets compiled out in Release mode
// For macros
#include "SGD_Util.h" // for SAFE_RELEASE and DXERROR
#pragma warning (disable : 4996)
CSGD_TextureManager CSGD_TextureManager::m_Instance;
///////////////////////////////////////////////////////////////////
// Function: "CSGD_TextureManager(Constructor)"
///////////////////////////////////////////////////////////////////
CSGD_TextureManager::CSGD_TextureManager(void)
{
m_lpDevice = NULL;
m_lpSprite = NULL;
}
///////////////////////////////////////////////////////////////////
// Function: "CSGD_TextureManager(Destructor)"
///////////////////////////////////////////////////////////////////
CSGD_TextureManager::~CSGD_TextureManager(void)
{
}
///////////////////////////////////////////////////////////////////
// Function: "GetInstance"
//
// Last Modified: 6/26/2006
//
// Input: void
//
// Return: An instance to this class.
//
// Purpose: Gets an instance to this class.
///////////////////////////////////////////////////////////////////
CSGD_TextureManager *CSGD_TextureManager::GetInstance(void)
{
return &m_Instance;
}
///////////////////////////////////////////////////////////////////
// Function: "InitTextureManager"
//
// Last Modified: 8/29/2006
//
// Input: lpDevice - A pointer to the Direct3D device.
// lpSprite - A pointer to the sprite object.
//
// Return: true, if successful.
//
// Purpose: Initializes the texture manager.
///////////////////////////////////////////////////////////////////
bool CSGD_TextureManager::InitTextureManager(LPDIRECT3DDEVICE9 lpDevice, LPD3DXSPRITE lpSprite)
{
m_lpDevice = lpDevice;
m_lpDevice->AddRef();
m_lpSprite = lpSprite;
m_lpSprite->AddRef();
return (m_lpDevice && m_lpSprite) ? true : false;
}
///////////////////////////////////////////////////////////////////
// Function: "ShutdownTextureManager"
//
// Last Modified: 10/29/2008
//
// Input: void
//
// Return: void
//
// Purpose: Unloads all the loaded textures and
// releases references to sprite and d3d devices.
///////////////////////////////////////////////////////////////////
void CSGD_TextureManager::ShutdownTextureManager(void)
{
for (unsigned int i = 0; i < m_Textures.size(); i++)
{
// Remove ref.
m_Textures[i].ref = 0;
// Release the texture if it's not being used.
SAFE_RELEASE(m_Textures[i].texture);
m_Textures[i].filename[0] = '\0';
}
// Clear the list of all loaded textures.
m_Textures.clear();
// Release our references to the sprite interface and d3d device
SAFE_RELEASE(m_lpSprite);
SAFE_RELEASE(m_lpDevice);
}
///////////////////////////////////////////////////////////////////
// Function: "LoadTexture"
//
// Last Modified: 10/29/2008
//
// Input: szFilename - The file to load.
// dwColorkey - The color key to use on the texture (use D3DCOLOR_XRGB() Macro).
// NOTE: 0 = no color key (which will use the alpha from the image instead)
//
// Return: The id to the texture that was loaded or found, -1 if it failed.
//
// NOTE: The function searches to see if the texture was already loaded
// and returns the id if it was.
//
// Purpose: To load a texture from a file.
//
// NOTE: Image dimensions must be a power of 2 (i.e. 256x64).
//
// Supports .bmp, .dds, .dib, .hdr, .jpg, .pfm, .png,
// .ppm, and .tga files.
///////////////////////////////////////////////////////////////////
int CSGD_TextureManager::LoadTexture(const char* szFilename, DWORD dwColorkey)
{
// Make sure the filename is valid.
if (!szFilename) return -1;
// Make sure the texture isn't already loaded.
for (unsigned int i = 0; i < m_Textures.size(); i++)
{
// compare strings without caring about upper or lowercase.
if (stricmp(szFilename, m_Textures[i].filename) == 0) // 0 means they are equal.
{
m_Textures[i].ref++; // add a reference to this texture.
return i; // return the index.
}
}
// Look for an open spot.
int nID = -1;
for (unsigned int i = 0; i < m_Textures.size(); i++)
{
if (m_Textures[i].ref == 0)
{
nID = i;
break;
}
}
// if we didn't find an open spot, load it in a new one
if (nID == -1)
{
// A temp texture object.
TEXTURE loaded;
// Copy the filename of the loaded texture.
strcpy(loaded.filename, szFilename);
// Load the texture from the given file.
HRESULT hr = 0;
if (FAILED(hr = D3DXCreateTextureFromFileEx(m_lpDevice, szFilename, 0, 0, D3DX_DEFAULT, 0,
D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT,
D3DX_DEFAULT, dwColorkey, 0, 0, &loaded.texture)))
{
// Failed.
char szBuffer[256] = {0};
sprintf(szBuffer, "Failed to Create Texture - %s", szFilename);
MessageBox(0, szBuffer, "TextureManager Error", MB_OK);
return -1;
}
// AddRef.
loaded.ref = 1;
// Get surface description (to find Width/Height of the texture)
D3DSURFACE_DESC d3dSurfDesc;
ZeroMemory(&d3dSurfDesc, sizeof(d3dSurfDesc));
loaded.texture->GetLevelDesc(0, &d3dSurfDesc);
// Remember the Width and Height
loaded.Width = d3dSurfDesc.Width;
loaded.Height = d3dSurfDesc.Height;
// Put the texture into the list.
m_Textures.push_back(loaded);
// Return the nID of the texture.
return (int)m_Textures.size() - 1;
}
// we found an open spot
else
{
// Make sure the texture has been released.
SAFE_RELEASE(m_Textures[nID].texture);
// Copy the filename of the loaded texture.
strcpy(m_Textures[nID].filename, szFilename);
// Load the texture from the given file.
HRESULT hr = 0;
if (FAILED(hr = D3DXCreateTextureFromFileEx(m_lpDevice, szFilename, 0, 0, D3DX_DEFAULT, 0,
D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT,
D3DX_DEFAULT, dwColorkey, 0, 0, &m_Textures[nID].texture)))
{
// Failed.
char szBuffer[256] = {0};
sprintf(szBuffer, "Failed to Create Texture - %s", szFilename);
MessageBox(0, szBuffer, "TextureManager Error", MB_OK);
return -1;
}
// Get surface description (to find Width/Height of the texture)
D3DSURFACE_DESC d3dSurfDesc;
ZeroMemory(&d3dSurfDesc, sizeof(d3dSurfDesc));
m_Textures[nID].texture->GetLevelDesc(0, &d3dSurfDesc);
// Remember the Width and Height
m_Textures[nID].Width = d3dSurfDesc.Width;
m_Textures[nID].Height = d3dSurfDesc.Height;
// AddRef
m_Textures[nID].ref = 1;
// Return the nID of the texture.
return nID;
}
}
///////////////////////////////////////////////////////////////////
// Function: "UnloadTexture"
//
// Last Modified: 10/29/2008
//
// Input: nID - The id to the texture to release.
//
// Return: void
//
// Purpose: Releases a reference to a given texture. When the
// reference to the texture is zero, the texture is
// released from memory.
///////////////////////////////////////////////////////////////////
void CSGD_TextureManager::UnloadTexture(int nID)
{
// Make sure the nID is in range.
assert(nID > -1 && nID < (int)m_Textures.size() && "nID is out of range");
// Remove ref.
m_Textures[nID].ref--;
// Release the texture if it's not being used.
if (m_Textures[nID].ref <= 0)
{
// Do a lazy delete and leave this spot empty
SAFE_RELEASE(m_Textures[nID].texture);
m_Textures[nID].filename[0] = '\0';
m_Textures[nID].ref = 0;
}
}
///////////////////////////////////////////////////////////////////
// Function: "GetTextureWidth"
//
// Last Modified: 9/21/2006
//
// Input: nID - The id to the texture who's width you want.
//
// Return: The width of the given texture.
//
// Purpose: Gets the width of a specified texture.
///////////////////////////////////////////////////////////////////
int CSGD_TextureManager::GetTextureWidth(int nID)
{
// Make sure the nID is in range.
assert(nID > -1 && nID < (int)m_Textures.size() && "nID is out of range");
return m_Textures[nID].Width;
}
///////////////////////////////////////////////////////////////////
// Function: "GetTextureHeight"
//
// Last Modified: 9/21/2006
//
// Input: nID - The id to the texture who's height you want.
//
// Return: The height of the given texture.
//
// Purpose: Gets the height of a specified texture.
///////////////////////////////////////////////////////////////////
int CSGD_TextureManager::GetTextureHeight(int nID)
{
// Make sure the nID is in range.
assert(nID > -1 && nID < (int)m_Textures.size() && "nID is out of range");
return m_Textures[nID].Height;
}
///////////////////////////////////////////////////////////////////
// Function: "DrawTexture"
//
// Last Modified: 8/22/2009
//
// Input: nID - The id of the texture to draw.
// nX - The x position to draw the texture at.
// nY - The y position to draw the texture at.
// fScaleX - How much to scale the texture in the x.
// fScaleY - How much to scale the texture in the y.
// pSection - The section of the bitmap to draw.
// fRotCenterX - The x center to apply the rotation from.
// fRotCenterY - The y center to apply the rotation from.
// fRotation - How much to rotate the texture.
// dwColor - The color to apply to the texture (use D3DCOLOR_XRGB() Macro).
//
// Return: true if successful.
//
// Purpose: Draws a texture to the screen.
//
// NOTE: Drawing a section of an image will only work properly if
// that image is a power of 2!
///////////////////////////////////////////////////////////////////
bool CSGD_TextureManager::Draw(int nID, int nX, int nY, float fScaleX, float fScaleY,
RECT* pSection, float fRotCenterX, float fRotCenterY, float fRotation, DWORD dwColor)
{
// Make sure the nID is in range.
assert(nID > -1 && nID < (int)m_Textures.size() && "nID is out of range");
// Make sure that the texture is valid
assert(m_Textures[nID].texture != NULL && "Attempting to draw released texture id");
// Make sure the sprite was created and we have a valid texture.
if (!m_lpSprite)
return false;
D3DXMATRIX scale;
D3DXMATRIX rotation;
D3DXMATRIX translate;
D3DXMATRIX combined;
// Initialize the Combined matrix.
D3DXMatrixIdentity(&combined);
// Scale the sprite.
D3DXMatrixScaling(&scale, fScaleX, fScaleY, 1.0f);
combined *= scale;
// Rotate the sprite.
D3DXMatrixTranslation(&translate, -fRotCenterX * fScaleX, -fRotCenterY * fScaleY, 0.0f);
combined *= translate;
D3DXMatrixRotationZ(&rotation, fRotation);
combined *= rotation;
D3DXMatrixTranslation(&translate, fRotCenterX * fScaleX, fRotCenterY * fScaleY, 0.0f);
combined *= translate;
// Translate the sprite
D3DXMatrixTranslation(&translate, (float)nX, (float)nY, 0.0f);
combined *= translate;
// Apply the transform.
m_lpSprite->SetTransform(&combined);
// Draw the sprite.
if (FAILED(m_lpSprite->Draw(m_Textures[nID].texture, pSection, NULL, NULL, dwColor)))
DXERROR("Failed to draw the texture.");
// Move the world back to identity.
D3DXMatrixIdentity(&combined);
m_lpSprite->SetTransform(&combined);
// success.
return true;
}
#pragma warning (default : 4996) | [
"[email protected]@598269ab-7e8a-4bc4-b06e-4a1e7ae79330"
]
| [
[
[
1,
410
]
]
]
|
ebbc245886dbd11501970368198e3b99c48b98dd | 5ac13fa1746046451f1989b5b8734f40d6445322 | /minimangalore/Nebula2/code/nebula2/src/locale/nlocaleserver_main.cc | 186658969618e5651d5937c2f036b88b5bbfbcaf | []
| no_license | moltenguy1/minimangalore | 9f2edf7901e7392490cc22486a7cf13c1790008d | 4d849672a6f25d8e441245d374b6bde4b59cbd48 | refs/heads/master | 2020-04-23T08:57:16.492734 | 2009-08-01T09:13:33 | 2009-08-01T09:13:33 | 35,933,330 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,392 | cc | //------------------------------------------------------------------------------
// nlocaleserver_main.cc
// (C) 2004 RadonLabs GmbH
//------------------------------------------------------------------------------
#include "kernel/nkernelserver.h"
#include "locale/nlocaleserver.h"
#include "xml/nxmlspreadsheet.h"
nNebulaClass(nLocaleServer, "nroot");
nLocaleServer* nLocaleServer::Singleton = 0;
//------------------------------------------------------------------------------
/**
*/
nLocaleServer::nLocaleServer() :
isOpen(false)
{
n_assert(0 == Singleton);
Singleton = this;
}
//------------------------------------------------------------------------------
/**
*/
nLocaleServer::~nLocaleServer()
{
if (this->IsOpen())
{
this->Close();
}
n_assert(this == Singleton);
Singleton = 0;
}
//------------------------------------------------------------------------------
/**
*/
bool
nLocaleServer::Open()
{
n_assert(!this->IsOpen());
this->isOpen = true;
return true;
}
//------------------------------------------------------------------------------
/**
*/
nString&
nLocaleServer::ParseText(nString& text)
{
// replace \n and \t
text = text.Substitute("\\t", "\t");
text = text.Substitute("\\n", "\n");
return text;
}
//------------------------------------------------------------------------------
/**
*/
void
nLocaleServer::Close()
{
n_assert(this->IsOpen());
this->isOpen = false;
}
//------------------------------------------------------------------------------
/**
*/
const char*
nLocaleServer::GetLocaleText(const char* id)
{
static nString msg;
n_assert(this->IsOpen());
if (this->idHashMap.Exists(id))
{
const ushort key = this->idHashMap[id];
n_assert(key >= 0 && key < this->textArray.Size());
return this->textArray[key].Get();
}
else
{
// print warning to log
n_printf("WARNING: nLocaleServer: Not found ID '%s'!\n", id);
// create locale string
msg = "Localize: ";
msg.Append(id);
return msg.Get();
}
}
//------------------------------------------------------------------------------
/**
*/
void
nLocaleServer::AddLocaleTable(const char* filename)
{
n_assert(this->IsOpen());
n_assert(filename);
// check if the table was already loaded
int i;
for (i = 0; i < this->loadedTables.Size(); i++)
{
if (this->loadedTables[i] == filename)
{
// skip add
n_printf("nLocaleServer::AddLocaleTable(): file '%s' already added skip it now.\n", filename);
return;
}
}
// load table
nXmlSpreadSheet sheet;
sheet.SetFilename(filename);
if (!sheet.Open())
{
n_error("nLocaleServer::Open(): Can't open file '%s'!\n", filename);
}
if (0 == sheet.NumTables())
{
n_error("nLocaleServer::Open(): File '%s' don't contain tables.\n", filename);
}
if (sheet.NumTables() > 1)
{
n_message("nLocaleServer::Open(): Warning: File '%s' contain more than one table, reading only the first one.\n", filename);
}
nXmlTable& table = sheet.TableAt(0);
int numRows = table.NumRows();
if (numRows <= 0)
{
n_error("nLocaleServer::Open(): File '%s' table 1 don't contain data!\n", filename);
}
// parse table entrys
int row;
for (row = 1; row < numRows; row++)
{
nString ID = table.Cell(row, "ID").AsString();
if (this->idHashMap.Exists(ID.Get()))
{
n_error("nLocaleServer::Open(): ID '%s' is not unique!\n", ID.Get());
}
else
{
// fill hashmap
const ushort key = this->idHashMap[ID.Get()];
// set string in text array
nString text = table.Cell(row, "Text").AsString();
if (key >= this->textArray.Size())
{
// preallocate
this->textArray.Reserve(key - this->textArray.Size() + 1);
}
this->textArray[key] = this->ParseText(text);
}
}
// cleanup
sheet.Close();
// remember loaded table
this->loadedTables.Append(filename);
}
| [
"BawooiT@d1c0eb94-fc07-11dd-a7be-4b3ef3b0700c"
]
| [
[
[
1,
173
]
]
]
|
ff748bc719146a396287cbb069df32abed19402e | aa5491d8b31750da743472562e85dd4987f1258a | /Main/client/chatwindow.cpp | 9696c0f3a65eb85a52350bb375f6441ab0ed0d83 | []
| no_license | LBRGeorge/jmnvc | d841ad694eaa761d0a45ab95b210758c50750d17 | 064402f0a9f1536229b99cf45f6e7536e1ae7bb5 | refs/heads/master | 2016-08-04T03:12:18.402941 | 2009-05-31T18:40:42 | 2009-05-31T18:40:42 | 39,416,169 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,539 | cpp | #include "main.h"
extern CGame *pGame;
//----------------------------------------------------
CChatWindow::CChatWindow(IDirect3DDevice8 *pD3DDevice)
{
int x=0;
m_bEnabled = TRUE;
m_fDrawStartX = 25.0f;
m_fDrawStartY = 30.0f;
m_fDrawPadding = 3.0f;
m_pD3DFont = NULL;
if(pD3DDevice) {
m_pD3DFont = new CD3DFont(CHAT_FONT,CHAT_FONT_SIZE+1,0);
m_pD3DFont->InitDeviceObjects(pD3DDevice);
m_pD3DFont->RestoreDeviceObjects();
}
m_pD3DFont->GetTextExtent("W",&m_sizeText);
// Init the chat window lines to 0
while(x!=MAX_DISP_MESSAGES) {
memset(m_szChatWindowBuffer[x],0,MAX_MESSAGE_LENGTH);
x++;
}
m_dwChatTextColor = D3DCOLOR_ARGB(255,255,255,255);
m_dwChatInfoColor = D3DCOLOR_ARGB(255,204,122,184);
m_dwChatDebugColor = D3DCOLOR_ARGB(255,4,163,107);
m_dwChatBackgroundColor = D3DCOLOR_ARGB(255,0,0,0);
m_pD3DDevice = pD3DDevice;
}
//----------------------------------------------------
CChatWindow::~CChatWindow()
{
if(m_pD3DFont) delete m_pD3DFont;
}
//----------------------------------------------------
void CChatWindow::Draw()
{
float fDrawX=m_fDrawStartX;
float fDrawY=m_fDrawStartY;
DWORD dwColorChat=0;
int x=0;
if(m_pD3DFont && m_bEnabled)
{
while(x!=(MAX_DISP_MESSAGES)) {
switch(m_eChatType[x]) {
case CHAT_TYPE_CHAT:
dwColorChat = m_dwChatTextColor;
break;
case CHAT_TYPE_INFO:
dwColorChat = m_dwChatInfoColor;
break;
case CHAT_TYPE_DEBUG:
dwColorChat = m_dwChatDebugColor;
break;
}
// Draws a drop shadow on the text. Too CPU intense?
m_pD3DFont->DrawText(fDrawX+1.0f,fDrawY+1.0f,m_dwChatBackgroundColor,
m_szChatWindowBuffer[x],0L,TRUE);
m_pD3DFont->DrawText(fDrawX,fDrawY,dwColorChat,
m_szChatWindowBuffer[x]);
fDrawY+=m_sizeText.cy+m_fDrawPadding;
x++;
}
} else {
if((NULL == m_pD3DFont) && m_pD3DDevice) { // Create/recreate it.
m_pD3DFont = new CD3DFont(CHAT_FONT,CHAT_FONT_SIZE,0);
m_pD3DFont->InitDeviceObjects(m_pD3DDevice);
m_pD3DFont->RestoreDeviceObjects();
}
}
}
//----------------------------------------------------
void CChatWindow::AddChatMessage(CHAR *szNick, DWORD dwNickColor, CHAR *szMessage)
{
char tmp_buf[512] = {0};
char * t = tmp_buf;
memset(tmp_buf,0,512);
// NICKNAME
*t = '\01'; t++; // color start
memcpy(t,&dwNickColor,sizeof(DWORD)); t+=4; // nick color
memcpy(t,szNick,strlen(szNick)); t+=strlen(szNick); // nick string
*t = '\01'; t++; // color start
memcpy(t,&m_dwChatTextColor,sizeof(DWORD)); t+=4; // chat color
*t = ':'; t++;
*t = ' '; t++;
// MESSAGE
FilterInvalidChars(szMessage);
strcpy(t,szMessage);
AddToChatWindowBuffer(tmp_buf,CHAT_TYPE_CHAT);
}
//----------------------------------------------------
void CChatWindow::AddInfoMessage(CHAR * szFormat, ...)
{
char tmp_buf[512];
memset(tmp_buf,0,512);
va_list args;
va_start(args, szFormat);
vsprintf(tmp_buf, szFormat, args);
va_end(args);
FilterInvalidChars(tmp_buf);
AddToChatWindowBuffer(tmp_buf,CHAT_TYPE_INFO);
}
//----------------------------------------------------
void CChatWindow::AddDebugMessage(CHAR * szFormat, ...)
{
char tmp_buf[512];
memset(tmp_buf,0,512);
va_list args;
va_start(args, szFormat);
vsprintf(tmp_buf, szFormat, args);
va_end(args);
FilterInvalidChars(tmp_buf);
AddToChatWindowBuffer(tmp_buf,CHAT_TYPE_DEBUG);
}
//----------------------------------------------------
void CChatWindow::FilterInvalidChars(PCHAR szString)
{
while(*szString) {
if(*szString < ' ' || *szString > 'z') {
*szString = ' ';
}
szString++;
}
}
//----------------------------------------------------
void CChatWindow::AddToChatWindowBuffer(PCHAR szString, eChatMessageType eType)
{
int iBestLineLength;
PushBack();
if(strlen(szString) > MAX_LINE_LENGTH)
{
iBestLineLength = MAX_LINE_LENGTH;
// see if we can locate a space.
while(szString[iBestLineLength] != ' ' && iBestLineLength)
iBestLineLength--;
if((MAX_LINE_LENGTH - iBestLineLength) > 8) {
// we should just take the whole line
strncpy(m_szChatWindowBuffer[MAX_DISP_MESSAGES-1],szString,MAX_LINE_LENGTH);
m_szChatWindowBuffer[MAX_DISP_MESSAGES-1][MAX_LINE_LENGTH] = '\0';
m_eChatType[MAX_DISP_MESSAGES-1] = eType;
PushBack();
strcpy(m_szChatWindowBuffer[MAX_DISP_MESSAGES-1],szString+MAX_LINE_LENGTH);
m_eChatType[MAX_DISP_MESSAGES-1] = eType;
}
else {
// grab upto the found space.
strncpy(m_szChatWindowBuffer[MAX_DISP_MESSAGES-1],szString,iBestLineLength);
m_szChatWindowBuffer[MAX_DISP_MESSAGES-1][iBestLineLength] = '\0';
m_eChatType[MAX_DISP_MESSAGES-1] = eType;
PushBack();
strcpy(m_szChatWindowBuffer[MAX_DISP_MESSAGES-1],szString+(iBestLineLength+1));
m_eChatType[MAX_DISP_MESSAGES-1] = eType;
}
}
else {
strcpy(m_szChatWindowBuffer[MAX_DISP_MESSAGES-1],szString);
m_eChatType[MAX_DISP_MESSAGES-1] = eType;
}
}
//----------------------------------------------------
void CChatWindow::PushBack()
{
int x=0;
while(x!=(MAX_DISP_MESSAGES - 1)) {
strcpy(m_szChatWindowBuffer[x],m_szChatWindowBuffer[x + 1]);
m_eChatType[x] = m_eChatType[x + 1];
x++;
}
}
//----------------------------------------------------
void CChatWindow::DeleteDeviceObjects()
{
SAFE_DELETE(m_pD3DFont);
}
//----------------------------------------------------
// EOF | [
"jacks.mini.net@45e629aa-34f5-11de-82fb-7f665ef830f7"
]
| [
[
[
1,
223
]
]
]
|
e4465a771355b7010e4eeed997f4975e90ddd6a1 | ad80c85f09a98b1bfc47191c0e99f3d4559b10d4 | /code/src/tools/nnpktool.cc | c04c21ee3b5339a25c79025e3553574420d11a8b | []
| no_license | DSPNerd/m-nebula | 76a4578f5504f6902e054ddd365b42672024de6d | 52a32902773c10cf1c6bc3dabefd2fd1587d83b3 | refs/heads/master | 2021-12-07T18:23:07.272880 | 2009-07-07T09:47:09 | 2009-07-07T09:47:09 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 37,309 | cc | //------------------------------------------------------------------------------
// nnpktool.cc
//
// Manage npk files.
//
// Usage:
//
// nnpktool [-help]
// [-pack dirname]
// [-list dirname]
// [-out filename]
// [-diff]
// [-listdiff]
// [-old]
// [-new]
// [-unpack]
//
// -help show help
// -pack pack this input directory
// -list list contents of npk files
// -out name of output file (def pack.npk)
// -diff build upgrade file of two npk files
// -listdiff list difference of two npk files
// -old the 'older' npk file to compare
// -new the 'newer' npk file to compare
// -unpack unpack given npk file
//
// (C) 2002 RadonLabs GmbH
//------------------------------------------------------------------------------
#include "tools/wftools.h"
#include "kernel/nkernelserver.h"
#include "kernel/nfileserver2.h"
#include "kernel/ndirectory.h"
#include "kernel/nfile.h"
#include "file/nnpktoc.h"
#include "file/nnpkfilewrapper.h"
class FileEntry : public nNode
{
public:
enum { IDENTICAL, NOT_FOUND, DIFFERENT, SIZE_CHANGED };
FileEntry()
{
this->reason = IDENTICAL;
this->testFlag = false;
}
int reason;
nString name;
bool testFlag;
nNpkTocEntry* entry;
int numDiff;
int firstDiff;
int fileSize;
};
//------------------------------------------------------------------------------
/**
Strip the parent path from a path name, returning a pointer to the
last component.
*/
const char*
stripParentPath(const char* path)
{
n_assert(path);
const char* lastPart = strrchr(path, '/');
if (!lastPart)
{
return path;
}
lastPart += 1;
n_assert(lastPart != 0);
return lastPart;
}
//------------------------------------------------------------------------------
/**
Get the directory name from a path name.
*/
const char*
getDirectoryName(const char* path, char* buf, int bufSize)
{
n_assert(path);
n_assert(bufSize > (int)strlen(path));
const char* tail = stripParentPath(path);
n_assert(tail);
const char* from = path;
char* to = buf;
while (from != tail)
{
*to++ = *from++;
}
*to = 0;
return buf;
}
//------------------------------------------------------------------------------
/**
Convert string to lower case.
*/
const char*
convertToLower(const char* path, char* buf, int bufSize)
{
n_assert((strlen(path) + 1) < (unsigned int) bufSize);
const char* from = path;
char* to = buf;
char c;
while ((c = *from++))
{
*to++ = tolower(c);
}
*to = 0;
return buf;
}
//------------------------------------------------------------------------------
/**
Recursively parse source directory and fill a nNpkToc object with the
data.
@param dir opened nDirectory object containing source dir
@param dirName stripped directory name (NOT the full path!)
@param tocObject the toc object to fill with data
@param curFileOffset [in/out] file offset tracker
*/
bool
generateToc(nFileServer2* fs, nDirectory* dir, const char* dirName, nNpkToc& tocObject, int& curFileOffset)
{
// add the directory itself to the tocObject
tocObject.BeginDirEntry(dirName);
// for each directory entry...
if (!dir->IsEmpty()) do
{
nDirectory::nEntryType entryType = dir->GetEntryType();
const char* fullEntryName = dir->GetEntryName();
char buf[N_MAXPATH];
fullEntryName = convertToLower(fullEntryName, buf, sizeof(buf));
// strip the parent path from the entry
const char* entryName = stripParentPath(fullEntryName);
// add entry to toc
if (nDirectory::FILE == entryType)
{
// get length of file
nFile* file = fs->NewFileObject();
n_assert(file);
int fileLength = 0;
bool fileOk = false;
if (file->Open(fullEntryName, "rb"))
{
file->Seek(0, nFile::END);
fileLength = file->Tell();
file->Close();
fileOk = true;
}
delete file;
if (fileOk)
{
// n_printf("-> adding file '%s' at %d len %d\n", entryName, curFileOffset, fileLength);
tocObject.AddFileEntry(entryName, curFileOffset, fileLength);
curFileOffset += fileLength;
}
else
{
n_printf("*** ERROR: Could not open file '%s', skipping...\n", fullEntryName);
}
}
else if (nDirectory::DIRECTORY == entryType)
{
// n_printf("-> recursing into dir '%s'\n", entryName);
// start a new subdirectory entry
nDirectory* subDir = fs->NewDirectoryObject();
n_assert(subDir);
bool subDirOk = false;
if (subDir->Open(fullEntryName))
{
generateToc(fs, subDir, entryName, tocObject, curFileOffset);
subDir->Close();
subDirOk = true;
}
delete subDir;
if (!subDirOk)
{
n_printf("*** ERROR: Could not open directory '%s', skipping...\n", entryName);
}
}
} while (dir->SetToNextEntry());
// finish the directory
tocObject.EndDirEntry();
return true;
}
//------------------------------------------------------------------------------
/**
Write the header, leave the dataOffset field empty, this will be
written later by the fixDataOffset function.
*/
bool
writeHeader(nFile* file)
{
file->PutInt('NPK0'); // magic number
file->PutInt(4); // block len
file->PutInt(0); // dataOffset (fixed later)
return true;
}
//------------------------------------------------------------------------------
/**
Fix the data offset in the file header
*/
bool
writeDataOffset(nFile* file, int dataOffset)
{
file->Seek(8, nFile::START);
file->PutInt(dataOffset);
return true;
}
//------------------------------------------------------------------------------
/**
Write a single toc entry to the file, recurse if necessary.
*/
void
writeTocEntry(nFile* file, nNpkTocEntry* tocEntry)
{
n_assert(file);
n_assert(tocEntry);
nNpkTocEntry::Type entryType = tocEntry->GetType();
const char* entryName = tocEntry->GetName();
int entryNameLen = strlen(entryName);
int entryFileOffset = tocEntry->GetFileOffset();
int entryFileLength = tocEntry->GetFileLength();
if (nNpkTocEntry::DIR == entryType)
{
// n_printf("=> writing dir entry '%s'\n", entryName);
// write a directory entry, and recurse
int blockLen = sizeof(short) + entryNameLen;
file->PutInt('DIR_');
file->PutInt(blockLen);
file->PutShort(entryNameLen);
file->Write(entryName, entryNameLen);
nNpkTocEntry* curSubEntry = tocEntry->GetFirstEntry();
while (curSubEntry)
{
writeTocEntry(file, curSubEntry);
curSubEntry = tocEntry->GetNextEntry(curSubEntry);
}
// write a final directory end marker
file->PutInt('DEND');
file->PutInt(0);
}
else if (nNpkTocEntry::FILE == entryType)
{
// n_printf("=> writing file entry '%s', offset %d len %d\n", entryName, entryFileOffset, entryFileLength);
// write a file entry
int blockLen = 2 * sizeof(int) + sizeof(short) + entryNameLen;
file->PutInt('FILE');
file->PutInt(blockLen);
file->PutInt(entryFileOffset);
file->PutInt(entryFileLength);
file->PutShort(entryNameLen);
file->Write(entryName, entryNameLen);
}
}
//------------------------------------------------------------------------------
/**
Recursively write the table of contents to the file.
*/
bool
writeToc(nFile* file, nNpkToc& tocObject)
{
if (writeHeader(file))
{
writeTocEntry(file, tocObject.GetRootEntry());
return true;
}
return false;
}
//------------------------------------------------------------------------------
/**
Write data for a toc file into nFile, recurse on directory entries.
*/
bool
writeEntryData(nFileServer2* fs, nFile* file, nNpkTocEntry* tocEntry, int dataBlockOffset, int& dataLen)
{
n_assert(file);
n_assert(tocEntry);
nNpkTocEntry::Type entryType = tocEntry->GetType();
const char* entryName = tocEntry->GetName();
int entryFileOffset = tocEntry->GetFileOffset();
int entryFileLength = tocEntry->GetFileLength();
if (nNpkTocEntry::DIR == entryType)
{
n_printf("=> enter dir '%s'\n", entryName);
// a dir entry, just recurse
nNpkTocEntry* curSubEntry = tocEntry->GetFirstEntry();
while (curSubEntry)
{
if (!writeEntryData(fs, file, curSubEntry, dataBlockOffset, dataLen))
{
return false;
}
curSubEntry = tocEntry->GetNextEntry(curSubEntry);
}
}
else if (nNpkTocEntry::FILE == entryType)
{
// make sure the file is still consistent with the toc data
n_assert(file->Tell() == (dataBlockOffset + entryFileOffset));
// get the full source path name
char fileName[N_MAXPATH];
tocEntry->GetFullName(fileName, sizeof(fileName));
// read source file data
nFile* srcFile = fs->NewFileObject();
n_assert(srcFile);
if (srcFile->Open(fileName, "rb"))
{
// allocate buffer for file and file contents
char* buffer = n_new char[entryFileLength];
int bytesRead = srcFile->Read(buffer, entryFileLength);
srcFile->Close();
delete srcFile;
if (bytesRead != entryFileLength)
{
n_delete buffer;
n_printf("Error reading file '%s'!\n", fileName);
return false;
}
// write buffer to target file
int bytesWritten = file->Write(buffer, entryFileLength);
n_delete buffer;
if (bytesWritten != entryFileLength)
{
n_printf("Error writing to target file!\n");
return false;
}
dataLen += entryFileLength;
}
else
{
n_printf("Failed to open source file '%s'!\n", fileName);
return false;
}
}
return true;
}
//------------------------------------------------------------------------------
/**
Write the data block to the file, and fix the data start offset in the
file header...
*/
bool
writeData(nFileServer2* fs, nFile* file, nNpkToc& tocObject)
{
int dataBlockStart = file->Tell();
file->PutInt('DATA');
int dataLenOffset = file->Tell();
file->PutInt(0); // fix later
int dataSize = 0;
if (!writeEntryData(fs, file, tocObject.GetRootEntry(), dataBlockStart + 8, dataSize))
{
return false;
}
// fix block lengths
writeDataOffset(file, dataBlockStart);
file->Seek(dataLenOffset, nFile::START);
file->PutInt(dataSize);
file->Seek(0, nFile::END);
return true;
}
//------------------------------------------------------------------------------
/**
The global pack function.
*/
bool
packIt(nFileServer2* fs, const char* dirName, const char* outName)
{
char absDirName[N_MAXPATH];
char absOutName[N_MAXPATH];
// absolutize filenames
fs->MakeAbsolute(dirName, absDirName, sizeof(absDirName));
fs->MakeAbsolute(outName, absOutName, sizeof(absOutName));
// create directory and file objects
nDirectory* dir = fs->NewDirectoryObject();
nFile* file = fs->NewFileObject();
n_assert(dir);
n_assert(file);
// open source directory and target file...
if (!dir->Open(absDirName))
{
n_printf("Could not open directory '%s' for reading!\n", dirName);
delete file;
delete dir;
return false;
}
if (!file->Open(absOutName, "w"))
{
n_printf("Could not open file '%s' for writing!\n", outName);
delete file;
delete dir;
return false;
}
// create table of content
nNpkToc tocObject;
tocObject.SetRootPath(fs->GetCwd());
bool retval = true;
n_printf("-> building table of contents...\n");
int fileOffset = 0;
if (generateToc(fs, dir, stripParentPath(absDirName), tocObject, fileOffset))
{
n_printf("-> done\n");
// write header and toc to file
n_printf("-> writing toc...\n");
if (writeToc(file, tocObject))
{
n_printf("-> done\n");
// write data block
n_printf("-> writing data block...\n");
if (writeData(fs, file, tocObject))
{
n_printf("-> all done\n");
}
else
{
n_printf("*** ERROR WRITING DATA BLOCK\n");
retval = false;
}
}
else
{
n_printf("*** ERROR WRITING TOC\n");
retval = false;
}
}
else
{
n_printf("*** ERROR PARSING DIRECTORY\n");
retval = false;
}
// close everything and finish
file->Close();
dir->Close();
delete file;
delete dir;
return retval;
}
//------------------------------------------------------------------------------
/**
Print out contents of a single toc entry, and recurse.
*/
void
printTocEntry(nNpkTocEntry* entry, int& recursionDepth)
{
n_assert(entry);
const char* name = entry->GetName();
nNpkTocEntry::Type type = entry->GetType();
int length = entry->GetFileLength();
// print recursion depth spaces...
int i = 0;
for (i = 0; i < recursionDepth; i++)
{
n_printf(" ");
}
// show actual entry info
n_printf("%s\t%s\t%d\n", (nNpkTocEntry::DIR == type) ? "dir" : "file",
name, length);
// if its a dir entry, recurse
if (nNpkTocEntry::DIR == type)
{
recursionDepth++;
nNpkTocEntry* childEntry = entry->GetFirstEntry();
if (childEntry) do
{
printTocEntry(childEntry, recursionDepth);
} while ((childEntry = entry->GetNextEntry(childEntry)));
recursionDepth--;
}
}
//------------------------------------------------------------------------------
/**
Build "internal path" (path inside pack file), without "data.n",
because thuis is the name of the file and has nothing to do with
the content.
*/
void
BuildInternalPath(nNpkTocEntry* entry, char* buffer, int bufSize)
{
static const int maxDepth = 16;
nNpkTocEntry* traceStack[maxDepth];
// fill trace stack with path to parent...
int depth = 0;
nNpkTocEntry* curEntry = entry;
while (curEntry && (depth < maxDepth))
{
traceStack[depth++] = curEntry;
curEntry = curEntry->GetParent();
}
// fill path string while stepping down
int curBufIndex = 0;
depth--; // because incrementing in loop above
depth--; // because ignoring data.n
for (; depth >= 0; --depth)
{
const char* curName = traceStack[depth]->GetName();
int curNameLen = strlen(curName);
n_assert((curBufIndex + curNameLen + 1) < bufSize);
strcpy(&(buffer[curBufIndex]), curName);
curBufIndex += curNameLen;
if (depth > 0)
{
buffer[curBufIndex++] = '/';
}
}
n_assert(curBufIndex < bufSize);
buffer[curBufIndex] = 0;
}
//-----------------------------------------------------------------------------
/**
*/
bool
IsFileInList(nList* list, const char* internalName)
{
nString intName(internalName);
FileEntry* entry;
for (entry = (FileEntry*) list->GetHead();
entry != 0;
entry = (FileEntry*) entry->GetSucc())
{
// test entries they were not found yet
if (entry->name == intName)
{
return true;
}
}
return false;
}
//------------------------------------------------------------------------------
/**
*/
bool
KillEmptyDirectories(nFileServer2* fs, const char* base)
{
nDirectory* dir = fs->NewDirectoryObject();
n_assert(0 != dir);
char curDir[N_MAXPATH];
strcpy(curDir, fs->GetCwd());
if (dir->Open(base))
{
// if this one is empty, return immediatly and let kill
// directory outside
if (dir->IsEmpty())
{
dir->Close();
return true;
}
fs->ChangeDir(base);
// step through all elements
bool doLoop = dir->SetToFirstEntry();
while (doLoop)
{
nDirectory::nEntryType t = dir->GetEntryType();
if (nDirectory::DIRECTORY == t)
{
bool empty = KillEmptyDirectories(fs, dir->GetEntryName());
if (empty)
{
rmdir(dir->GetEntryName());
}
}
doLoop = dir->SetToNextEntry();
}
dir->Close();
fs->ChangeDir(curDir);
}
else
{
n_printf("Cannot open directory %s for reading...\n", base);
}
return false;
}
//------------------------------------------------------------------------------
/**
*/
void
RemoveDir(nFileServer2* fs, const char* dirName)
{
// step recursive through all subdirs, kill files and then
// kill the empty directory
nDirectory* dir = fs->NewDirectoryObject();
n_assert(0 != dir);
char curDir[N_MAXPATH];
strcpy(curDir, fs->GetCwd());
if (dir->Open(dirName))
{
fs->ChangeDir(dirName);
// seems to be no problem deleting files while stepping
// through subdir...
bool doLoop = dir->SetToFirstEntry();
while (doLoop)
{
nDirectory::nEntryType t = dir->GetEntryType();
if (nDirectory::DIRECTORY == t)
{
RemoveDir(fs, dir->GetEntryName());
}
if (nDirectory::FILE == t)
{
remove(dir->GetEntryName());
}
doLoop = dir->SetToNextEntry();
}
dir->Close();
fs->ChangeDir(curDir);
}
rmdir(dirName);
}
//------------------------------------------------------------------------------
/**
*/
bool
AreFilesIdentical(FileEntry* oldEntry, FileEntry* newEntry,
int& reason, int& numDiff, int& firstDiff)
{
nNpkTocEntry* oldNpkEntry = oldEntry->entry;
nNpkTocEntry* newNpkEntry = newEntry->entry;
if (oldNpkEntry->GetFileLength() != newNpkEntry->GetFileLength())
{
// different size --> must be different
reason = FileEntry::SIZE_CHANGED;
return false;
}
nNpkFileWrapper* oldWrapper = oldNpkEntry->GetFileWrapper();
nNpkFileWrapper* newWrapper = newNpkEntry->GetFileWrapper();
n_assert(0 != oldWrapper);
n_assert(0 != newWrapper);
nFile* oldFile = oldWrapper->GetBinaryFile();
nFile* newFile = newWrapper->GetBinaryFile();
n_assert(0 != oldFile);
n_assert(0 != newFile);
int size = oldNpkEntry->GetFileLength();
char* oldArray = new char[size];
char* newArray = new char[size];
oldFile->Seek(oldNpkEntry->GetFileOffset(), nFile::START);
newFile->Seek(newNpkEntry->GetFileOffset(), nFile::START);
oldFile->Read(oldArray, size);
newFile->Read(newArray, size);
int retValue = memcmp(oldArray, newArray, size);
numDiff = 0;
firstDiff = -1;
if (retValue != 0)
{
int i;
for (i = 0; i < size; i++)
{
if ( ((char)(oldArray[i])) != ((char)(newArray[i])))
{
numDiff++;
if (firstDiff == -1)
{
firstDiff = i;
}
}
}
}
delete oldArray;
delete newArray;
if (retValue != 0)
{
reason = FileEntry::DIFFERENT;
}
else
{
reason = FileEntry::IDENTICAL;
}
return (0 == retValue) ? true : false;
}
//------------------------------------------------------------------------------
/**
*/
void
BuildDifferenceList(nList& oldList, nList& newList, nList& diffList)
{
// not very beautiful....
FileEntry* oldEntry = 0, *newEntry = 0, *diffEntry = 0;
// clear all test flags for faster search
for (oldEntry = (FileEntry*) oldList.GetHead();
oldEntry != 0;
oldEntry = (FileEntry*) oldEntry->GetSucc())
{
oldEntry->testFlag = false;
}
for (newEntry = (FileEntry*) newList.GetHead();
newEntry != 0;
newEntry = (FileEntry*) newEntry->GetSucc())
{
// look for newEntry inside oldList
bool found = false;
int reason = FileEntry::NOT_FOUND;
int numDiff = 0;
int firstDiff = -1;
for (oldEntry = (FileEntry*) oldList.GetHead();
oldEntry != 0;
oldEntry = (FileEntry*) oldEntry->GetSucc())
{
// test entries they were not found yet
if (!oldEntry->testFlag)
{
if (oldEntry->name == newEntry->name)
{
// the old one was found in the newlist, but
// is it different?
if (AreFilesIdentical(oldEntry, newEntry,
reason, numDiff, firstDiff))
{
found = true;
}
// testet. ignore it for next steps
oldEntry->testFlag = true;
break;
}
}
}
if (!found)
{
// not in old list??? put a new entry into diff list
diffEntry = new FileEntry;
n_assert(0 != diffEntry);
diffEntry->name = newEntry->name;
diffEntry->entry = newEntry->entry;
diffEntry->reason = reason;
diffEntry->numDiff = numDiff;
diffEntry->firstDiff = firstDiff;
diffEntry->fileSize = newEntry->entry->GetFileLength();
diffList.AddTail((nNode*) diffEntry);
}
}
}
//------------------------------------------------------------------------------
/**
*/
void
FillList(nNpkTocEntry* entry, nList& list)
{
n_assert(0 != entry);
char name[N_MAXPATH];
BuildInternalPath(entry, name, N_MAXPATH);
nNpkTocEntry::Type type = entry->GetType();
// store data in list
FileEntry* fileEntry = new FileEntry;
fileEntry->name = name;
fileEntry->entry = entry;
list.AddTail((nNode *) fileEntry);
if (nNpkTocEntry::DIR == type)
{
nNpkTocEntry* childEntry = 0;
for (childEntry = entry->GetFirstEntry();
childEntry != 0;
childEntry = entry->GetNextEntry(childEntry))
{
FillList(childEntry, list);
}
}
}
//------------------------------------------------------------------------------
/**
*/
bool
listIt(nFileServer2* fs, const char* listName)
{
char absFileName[N_MAXPATH];
char rootPath[N_MAXPATH];
// absolutize filenames
fs->MakeAbsolute(listName, absFileName, sizeof(absFileName));
// get the directory name from the absolute filename
getDirectoryName(absFileName, rootPath, sizeof(rootPath));
// create a file wrapper object and parse npk file
nNpkFileWrapper wrapper;
if (wrapper.Open(fs, rootPath, absFileName))
{
// get table of contents object
nNpkToc& toc = wrapper.GetTocObject();
// print out file contents
int recursionDepth = 0;
n_printf("TYPE\tNAME\tLENGTH\n");
printTocEntry(toc.GetRootEntry(), recursionDepth);
wrapper.Close();
return true;
}
else
{
n_printf("Could not open '%s' as npk file!\n", absFileName);
return false;
}
}
//------------------------------------------------------------------------------
/**
*/
bool
GenerateDifferenceList(nFileServer2* fs,
const char* oldName,
const char* newName,
nList& diffList)
{
char absOldName[N_MAXPATH];
char absNewName[N_MAXPATH];
char rootNewPath[N_MAXPATH];
char rootOldPath[N_MAXPATH];
// absolutize filenames
fs->MakeAbsolute(newName, absNewName, sizeof(absNewName));
fs->MakeAbsolute(oldName, absOldName, sizeof(absOldName));
// get the directory name from the absolute filename
getDirectoryName(absNewName, rootNewPath, sizeof(rootNewPath));
getDirectoryName(absOldName, rootOldPath, sizeof(rootOldPath));
// create a file wrapper object and parse npk file
nNpkFileWrapper oldWrapper, newWrapper;
if (oldWrapper.Open(fs, rootOldPath, absOldName))
{
if (newWrapper.Open(fs, rootNewPath, absNewName))
{
// get table of contents object
nNpkToc& oldToc = oldWrapper.GetTocObject();
nNpkToc& newToc = newWrapper.GetTocObject();
// build two tables
nList oldList, newList;
FillList(oldToc.GetRootEntry(), oldList);
FillList(newToc.GetRootEntry(), newList);
// print out file contents
BuildDifferenceList(oldList, newList, diffList);
oldWrapper.Close();
newWrapper.Close();
FileEntry* fEntry = 0;
while (0 != (fEntry = (FileEntry*) oldList.RemHead()))
{
delete fEntry;
}
while (0 != (fEntry = (FileEntry*) newList.RemHead()))
{
delete fEntry;
}
return true;
}
else
{
n_printf("Could not open '%s' as npk file!\n", absNewName);
return false;
}
}
else
{
n_printf("Could not open '%s' as npk file!\n", absOldName);
return false;
}
}
//-----------------------------------------------------------------------------
/**
*/
void
unPackFile(nFileServer2* fs,
nFile* npkFile,
nNpkTocEntry* entry,
const char* outName,
nList* dList)
{
nNpkTocEntry::Type type = entry->GetType();
if (nNpkTocEntry::FILE == type)
{
// we can unpack whole npk files or parts of it. In this case
// the files to extract are stored in a (FileEntry-) list.
// Otherwise the list pointer is 0 and we extract every file.
bool reallyExtract = true;
if (0 != dList)
{
char buffer[N_MAXPATH];
BuildInternalPath(entry, buffer, N_MAXPATH);
if (!IsFileInList(dList, buffer))
{
reallyExtract = false;
}
}
if (reallyExtract)
{
nFile* file = fs->NewFileObject();
n_assert(0 != file);
char absName[N_MAXPATH];
char intern[N_MAXPATH];
BuildInternalPath(entry, intern, N_MAXPATH);
fs->MakeAbsolute(intern, absName, sizeof(absName));
if (file->Open(entry->GetName(), "w"))
{
// copy bytes from npk into this file
int start = entry->GetFileOffset();
int length = entry->GetFileLength();
npkFile->Seek(start, nFile::START);
char* buf = (char *) malloc(length);
n_assert(0 != buf);
npkFile->Read(buf, length);
file->Write(buf, length);
file->Close();
}
else
{
n_printf("Cannot open %s\n", absName);
}
delete file;
}
}
if (nNpkTocEntry::DIR == type)
{
// create directory
nDirectory* dir = fs->NewDirectoryObject();
n_assert(0 != dir);
char currentDir[N_MAXPATH];
n_assert(N_MAXPATH >= strlen(fs->GetCwd()));
sprintf(currentDir, fs->GetCwd());
// use correct name or the one was given from outside?
const char* dName = 0;
if (0 != outName)
{
dName = outName;
}
else
{
dName = entry->GetName();
}
n_assert(0 != dName);
char absDir[N_MAXPATH];
fs->MakeAbsolute(dName, absDir, sizeof(absDir));
n_mkdir(dName);
if (dir->Open(absDir))
{
fs->ChangeDir(dName);
nNpkTocEntry* childEntry = 0;
for (childEntry = entry->GetFirstEntry();
childEntry != 0;
childEntry = entry->GetNextEntry(childEntry))
{
// outName is for the highest level only, below
// that we use correct name from npk file
unPackFile(fs, npkFile, childEntry, 0, dList);
}
dir->Close();
fs->ChangeDir(currentDir);
}
else
{
n_printf("Cannot open dir %s\n", entry->GetName());
}
delete dir;
}
}
//------------------------------------------------------------------------------
/**
*/
void
unPack(nFileServer2* fs, const char* fileName, const char* outName, nList* dList)
{
// create directory of the same name. check for existence and
// ".npk" first
if (0 == strstr(fileName, ".npk"))
{
n_printf("Error: %s is not an nebula pack file!\n", fileName);
return;
}
char dirName[N_MAXPATH];
strcpy(dirName, fileName);
char* end = strstr(dirName, ".npk");
*end = 0;
strcat(dirName, ".n");
char absFileName[N_MAXPATH];
char rootPath[N_MAXPATH];
nNpkFileWrapper fileWrapper;
fs->MakeAbsolute(fileName, absFileName, sizeof(absFileName));
getDirectoryName(absFileName, rootPath, sizeof(rootPath));
if (fileWrapper.Open(fs, rootPath, absFileName))
{
// get table of contents object
nNpkTocEntry* tocEntry = fileWrapper.GetTocObject().GetRootEntry();
nFile* npkFile = fileWrapper.GetBinaryFile();
unPackFile(fs, npkFile, tocEntry, outName, dList);
fileWrapper.Close();
}
}
//------------------------------------------------------------------------------
/**
*/
void
listDiff(nFileServer2* fs,
const char* oldName,
const char* newName)
{
nList diffList;
GenerateDifferenceList(fs, oldName, newName, diffList);
FileEntry* fEntry = 0;
for (fEntry = (FileEntry *) diffList.GetHead();
fEntry != 0;
fEntry = (FileEntry *) fEntry->GetSucc())
{
char* wieso = "???";
switch (fEntry->reason)
{
case FileEntry::DIFFERENT:
wieso = "different content";
break;
case FileEntry::SIZE_CHANGED:
wieso = "different size";
break;
case FileEntry::NOT_FOUND:
wieso = "is new";
break;
case FileEntry::IDENTICAL:
wieso = "identisch";
break;
}
n_printf("- %s - %s\n", fEntry->name.Get(), wieso);
}
fEntry = 0;
while (0 != (fEntry = (FileEntry*) diffList.RemHead()))
{
delete fEntry;
}
}
//------------------------------------------------------------------------------
/**
*/
void
makeDiff(nFileServer2* fs,
const char* oldName,
const char* newName,
const char* outName)
{
nList diffList;
GenerateDifferenceList(fs, oldName, newName, diffList);
// simple way: extract all files from diffList into a directory
// and let pack the whole new directory with flohs routines
unPack(fs, newName, "temp.n", &diffList);
// kill all empty directories
KillEmptyDirectories(fs, "temp.n");
// pack "difference directory"
if (0 == outName)
{
outName = "diff.npk";
}
packIt(fs, "temp.n", outName);
// delete old temp-dir
RemoveDir(fs, "temp.n");
FileEntry* fEntry = 0;
while (0 != (fEntry = (FileEntry*) diffList.RemHead()))
{
delete fEntry;
}
}
//------------------------------------------------------------------------------
int
main(int argc, char* argv[])
{
bool help, showDiff, diff;
const char* packName;
const char* listName;
const char* outName;
const char* oldName;
const char* newName;
const char* unPackName;
// get args
help = wf_getboolarg(argc, argv, "-help");
packName = wf_getstrarg(argc, argv, "-pack", 0);
listName = wf_getstrarg(argc, argv, "-list", 0);
outName = wf_getstrarg(argc, argv, "-out", "pack.npk");
diff = wf_getboolarg(argc, argv, "-diff");
showDiff = wf_getboolarg(argc, argv, "-listdiff");
oldName = wf_getstrarg(argc, argv, "-old", 0);
newName = wf_getstrarg(argc, argv, "-new", 0);
unPackName = wf_getstrarg(argc, argv, "-unpack", 0);
// show help
if (help)
{
printf("npacknpk [-help]\n"
"(C) 2002 RadonLabs GmbH\n"
"-help show help\n"
"-pack pack this input directory\n"
"-list list contents of npk files\n"
"-out name of output file (def pack.npk)\n"
"-diff build upgrade file of two npk files\n"
"-listdiff list difference of two npk files\n"
"-old the 'older' npk file to compare\n"
"-new the 'newer' npk file to compare\n"
"-unpack unpack given npk file\n");
return 0;
}
// create Nebula environment
nKernelServer* ks = new nKernelServer;
nFileServer2* fs = (nFileServer2*) ks->New("nfileserver2", "/sys/servers/file2");
// what operation to do?
if (packName)
{
// call pack function
if (!packIt(fs, packName, outName))
{
n_printf("ERROR IN FILE GENERATION, DELETING NPK FILE\n");
char absOutName[N_MAXPATH];
fs->MakeAbsolute(outName, absOutName, sizeof(absOutName));
remove(absOutName);
}
}
else
{
// do not pack. hm. any other action?
if (diff)
{
n_assert((0 != oldName) && (0 != newName));
// compare two files and build a new file with the difference
makeDiff(fs, oldName, newName, outName);
}
else
{
// Show content only
if (listName)
{
// call list function
listIt(fs, listName);
}
else
{
// list differnce of two npk files
if (showDiff)
{
n_assert((0 != oldName) && (0 != newName));
listDiff(fs, oldName, newName);
}
else
{
if (0 != unPackName)
{
unPack(fs, unPackName, outName, 0);
}
}
}
}
}
delete ks;
// success
return 0;
}
| [
"plushe@411252de-2431-11de-b186-ef1da62b6547"
]
| [
[
[
1,
1291
]
]
]
|
73f12d4137d3f8947eaa66fb6add36bd9410f4fe | 7e8eda9c74315df15b165b43f330da76f77e163e | /src/WiiGestures/wiimote_client.cpp | 5352ab8ddfefe1fc6603038402ef469e164c170f | []
| no_license | pixelperfect3/3d-scene-editor | e9375cf211e984ce92dc6aab44f2ab8f4a3ecca8 | 02db9bc2b1b1de1f5405ab66c80fd86f4b1b4df8 | refs/heads/master | 2016-09-06T02:00:01.057542 | 2009-04-21T18:56:32 | 2009-04-21T18:56:32 | 32,138,477 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,462 | cpp | #include <iostream>
#include <stdlib.h>
#include <math.h>
#include "wiimote_client.h"
#define PI 3.1415926
void VRPN_CALLBACK analog_change_callback(void *userdata, const vrpn_ANALOGCB info) {
((WiiMoteClient *)userdata)->handle_analog_changes(info);
};
void VRPN_CALLBACK button_change_callback(void *userdata, const vrpn_BUTTONCB info) {
((WiiMoteClient *)userdata)->handle_button_changes(info);
};
bool WiiMoteClient::update_channel(const vrpn_int32 channel, const bool value) {
vrpn_float64 channel_val = (value ? 1.0 : 0.0);
return output_listener->request_change_channel_value(channel, channel_val);
}
bool WiiMoteClient::enable_rumble(bool rumble) {
return update_channel(VRPN_WIIMOTE_CHANNEL_RUMBLE, rumble);
}
bool WiiMoteClient::set_mode(const int mode, bool value) {
switch (mode) {
case VRPN_WIIMOTE_CHANNEL_MODE_IR:
case VRPN_WIIMOTE_CHANNEL_MODE_MOTION_SENSE:
return update_channel(mode, value);
default:
return false;
}
}
bool WiiMoteClient::set_leds(int leds) {
vrpn_int32 channel = 0;
switch (leds) {
case 1:
channel = VRPN_WIIMOTE_CHANNEL_LED_1;
break;
case 2:
channel = VRPN_WIIMOTE_CHANNEL_LED_2;
break;
case 3:
channel = VRPN_WIIMOTE_CHANNEL_LED_3;
break;
case 4:
channel = VRPN_WIIMOTE_CHANNEL_LED_4;
break;
default:
return false;
}
std::cout << "LEDS: " << leds << " (channel=" << channel << ")\n";
return update_channel(channel, true);
}
WiiMoteClient::WiiMoteClient(const char *name, unsigned which, vrpn_Connection *c) {
analog_listener = new vrpn_Analog_Remote(name, c);
button_listener = new vrpn_Button_Remote(name, c);
output_listener = new vrpn_Analog_Output_Remote(name, c);
wiimote_index = which;
analog_listener->register_change_handler((void *) this, analog_change_callback);
button_listener->register_change_handler((void *) this, button_change_callback);
for (int ii = 0; ii < 3; ii++) {
this->nunchuk_accel[ii] = 0;
}
for (int ii = 0; ii < 2; ii++) {
this->joystick_pos[ii] = 0;
}
for (int ii = 0; ii < 4; ii++) {
this->ir_x[ii] = -1;
this->ir_y[ii] = -1;
this->ir_size[ii] = -1;
}
for (int ii = 0; ii < WIIMOTE_CLIENT_NUM_BUTTONS; ii++) {
this->buttons[ii] = 0;
}
this->last_button = -1;
}
WiiMoteClient::~WiiMoteClient() {
disconnect();
}
void WiiMoteClient::updateFromServer() {
analog_listener->mainloop();
button_listener->mainloop();
output_listener->mainloop();
}
void WiiMoteClient::disconnect() {
analog_listener->unregister_change_handler((void *)this, analog_change_callback);
button_listener->unregister_change_handler((void *)this, button_change_callback);
if (analog_listener) {
delete analog_listener;
}
if (button_listener) {
delete button_listener;
}
if (output_listener) {
delete output_listener;
}
}
/*
// The Analogs are in a random order, both from the primary controller:
// channel[0] = battery level (0-1)
// channel[1] = gravity X vector calculation (1 = Earth gravity)
// channel[2] = gravity Y vector calculation (1 = Earth gravity)
// channel[3] = gravity Z vector calculation (1 = Earth gravity)
// channel[4] = X of first sensor spot (0-1023, -1 if not seen)
// channel[5] = Y of first sensor spot (0-767, -1 if not seen)
// channel[6] = size of first sensor spot (0-15, -1 if not seen)
// channel[7] = X of second sensor spot (0-1023, -1 if not seen)
// channel[9] = Y of second sensor spot (0-767, -1 if not seen)
// channel[9] = size of second sensor spot (0-15, -1 if not seen)
// channel[10] = X of third sensor spot (0-1023, -1 if not seen)
// channel[11] = Y of third sensor spot (0-767, -1 if not seen)
// channel[12] = size of third sensor spot (0-15, -1 if not seen)
// channel[13] = X of fourth sensor spot (0-1023, -1 if not seen)
// channel[14] = Y of fourth sensor spot (0-767, -1 if not seen)
// channel[15] = size of fourth sensor spot (0-15, -1 if not seen)
// and on the secondary controllers (skipping values to leave room for expansion)
// channel[16] = nunchuck gravity X vector
// channel[17] = nunchuck gravity Y vector
// channel[18] = nunchuck gravity Z vector
// channel[19] = nunchuck joystick angle
// channel[20] = nunchuck joystick magnitude
*/
void WiiMoteClient::handle_analog_changes(const vrpn_ANALOGCB info) {
//Wiimote accelerometer data:
wiimote_accel[0] = info.channel[1]; //TODO : replace constants with WIIMOTE_CLIENT_CHANNEL_xxx
wiimote_accel[1] = info.channel[2];
wiimote_accel[2] = info.channel[3];
//IR data: (X, Y, size)
ir_x[0] = info.channel[4];
ir_y[0] = info.channel[5];
ir_size[0] = info.channel[6];
ir_x[1] = info.channel[7];
ir_y[1] = info.channel[8];
ir_size[1] = info.channel[9];
ir_x[2] = info.channel[10];
ir_y[2] = info.channel[11];
ir_size[2] = info.channel[12];
ir_x[3] = info.channel[13];
ir_y[3] = info.channel[14];
ir_size[3] = info.channel[15];
//Nunchuk accelerometer data:
nunchuk_accel[0] = info.channel[16];
nunchuk_accel[1] = info.channel[17];
nunchuk_accel[2] = info.channel[18];
//Nunchuk joystick position:
vrpn_float64 joystick_angle = 90.0 - info.channel[19]; //convert to rectangular-coordinates.
vrpn_float64 joystick_magnitude = info.channel[20];
joystick_pos[0] = cos(joystick_angle * PI / 180.0) * joystick_magnitude;
joystick_pos[1] = sin(joystick_angle * PI / 180.0) * joystick_magnitude;
}
/*
// The buttons are as read from the bit-fields of the primary controller (bits 0-15)
// and then a second set for any extended controller (nunchuck bits 16-31),
// (classic controller bits 32-47), (guitar hero 3 bits 48-63).
Wiimote:
0 => 2
1 => 1
2 => B
3 => A
4 => -
7 => Home
8 => left
9 => right
10 => down
11 => up
12 => +
Nunchuk:
16 => Z
17 => C
Note: buttons 5, 6, 13, 14, and 15 are not used.
*/
void WiiMoteClient::handle_button_changes(const vrpn_BUTTONCB info) {
bool is_release = !this->buttons[info.button] && (info.state == 1);
//TODO : Make it easier to get only button "presses" and "releases".
//For example, feedback to wiimote "server" after certain button releases:
if (is_release) {
switch (info.button) {
case WIIMOTE_CLIENT_BUTTON_A:
this->enable_rumble(true);
break;
case WIIMOTE_CLIENT_BUTTON_B:
this->enable_rumble(false);
break;
case WIIMOTE_CLIENT_BUTTON_1:
this->set_leds(1);
break;
case WIIMOTE_CLIENT_BUTTON_2:
this->set_leds(2);
break;
}
}
this->buttons[info.button] = (info.state == 1) ? true : false;
this->last_button = info.button;
}
void ShowNunchuk(WiiMoteClient &client) {
std::cout << "NUNCHUK [" << client.wiimote_index << "]:\n";
std::cout << "Accel: { " << client.nunchuk_accel[0] << ", " << client.nunchuk_accel[1] << ", " << client.nunchuk_accel[2] << " }\n";
std::cout << "Position: { " << client.joystick_pos[0] << ", " << client.joystick_pos[1] << " }\n";
std::cout << "\n";
}
void ShowButtons(WiiMoteClient &client) {
if (0 <= client.last_button && client.last_button < WIIMOTE_CLIENT_NUM_BUTTONS) {
std::cout << "BUTTON CHANGES [" << client.wiimote_index << "]:\n";
bool on = client.buttons[client.last_button];
std::cout << "Button #" << client.last_button << " is " << (on ? "on" : "off") << "\n";
std::cout << "\n";
}
}
| [
"ethan.sherrie@d3cd3af8-22d8-11de-85c7-557234b16fc6"
]
| [
[
[
1,
221
]
]
]
|
fd59fa452219f638a2990705f28739f55c0ec76b | 8a8873b129313b24341e8fa88a49052e09c3fa51 | /src/ScreenLayout.cpp | 0d2f3617f6ae68ecf155a100bdf49c74efc46769 | []
| no_license | flaithbheartaigh/wapbrowser | ba09f7aa981d65df810dba2156a3f153df071dcf | b0d93ce8517916d23104be608548e93740bace4e | refs/heads/master | 2021-01-10T11:29:49.555342 | 2010-03-08T09:36:03 | 2010-03-08T09:36:03 | 50,261,329 | 1 | 0 | null | null | null | null | GB18030 | C++ | false | false | 17,771 | cpp | /*
============================================================================
Name : ScreenLayout.cpp
Author : 浮生若茶
Version :
Copyright : Your copyright notice
Description : CScreenLayout implementation
============================================================================
*/
#include <coemain.h>
#include <W32STD.H>
#include "ScreenLayout.h"
#include "PreDefine.h"
#include "MainEngine.h"
#include "UtilityTools.h"
#include "Graphic.h"
#include "cocobmp.h"
#include <eikenv.h>
//#include "picture.h"
CScreenLayout::CScreenLayout(CMainEngine* aEngine) : iEngine(aEngine)
, iDefaultFont(aEngine->Graphic().GetFont())
{
}
CScreenLayout::~CScreenLayout()
{
}
CScreenLayout* CScreenLayout::NewLC(CMainEngine* aEngine)
{
CScreenLayout* self = new (ELeave)CScreenLayout(aEngine);
CleanupStack::PushL(self);
self->ConstructL();
return self;
}
CScreenLayout* CScreenLayout::NewL(CMainEngine* aEngine)
{
CScreenLayout* self=CScreenLayout::NewLC(aEngine);
CleanupStack::Pop(); // self;
return self;
}
void CScreenLayout::ConstructL()
{
//iDefaultFont = iEngine->GetFont();
ASSERT(iDefaultFont);
InitByScreenSize();
InitByFont();
InitData();
}
void CScreenLayout::SetFont(const CFont* aDefaultFont)
{
ASSERT(aDefaultFont);
iDefaultFont = aDefaultFont;
}
const CFont* CScreenLayout::Font()const
{
ASSERT(iDefaultFont);
return iDefaultFont;
}
void CScreenLayout::SetClientRect(const TRect& aRect)
{
iFullClientRect = aRect;
iClientRect = aRect;
iClientRect.Shrink(iOuterMargin,iOuterMargin);
iNaviPaneRect = iClientRect;
iNaviPaneRect.iBr.iY = iNaviPaneRect.iTl.iY + iListBoxLineHeight;
//iWhiteBackgroundRect.Shrink(iInnerMargin,iInnerMargin);
iWhiteBackgroundRect = iClientRect;
iWhiteBackgroundRect.iTl.iY = iNaviPaneRect.iBr.iY + iOuterMargin;
//iWhiteBackgroundRect.Shrink(iInnerMargin,iInnerMargin);
iLineNum = iWhiteBackgroundRect.Height()/iListBoxLineHeight;
iInfoRect = aRect;
iInfoRect.iTl.SetXY(0,0);
iInfoRect.Shrink(iOuterMargin,iOuterMargin);
iMultiTextRect = iClientRect;
iInfoRect.Shrink(iOuterMargin,iOuterMargin);
}
void CScreenLayout::SetTitleBarRect(const TRect& aRect)
{
iTitleBarRect = aRect;
}
const TRect& CScreenLayout::TitleBarRect() const
{
return iTitleBarRect;
}
TRect CScreenLayout::GetStatusPaneRect()const
{
return iStatusPaneRect;
}
TRect CScreenLayout::GetFullClientRect()const
{
return iFullClientRect;
}
TRect CScreenLayout::GetClientRect()const
{
return iClientRect;
}
TRect CScreenLayout::GetControlPaneRect()const
{
return iControlPaneRect;
}
TRect CScreenLayout::GetNaviPaneRect()const
{
return iNaviPaneRect;
}
TRect CScreenLayout::GetListBoxRect()const
{
return iListBoxRect;
}
TRect CScreenLayout::GetDialogRect()const
{
return iDialogRect;
}
TRect CScreenLayout::GetDialogIconRect()const
{
return iDialogIconRect;
}
TRect CScreenLayout::GetScrollbarRect()const
{
return iScrollbarRect;
}
TRect CScreenLayout::LeftButtonRect()const
{
return iLeftButtonRect;
}
TRect CScreenLayout::RightButtonRect()const
{
return iRightButtonRect;
}
TRect CScreenLayout::MultiTextRect()const
{
return iMultiTextRect;
}
TRect CScreenLayout::WhiteBackgroundRect()const
{
return iWhiteBackgroundRect;
}
TRect CScreenLayout::InfoRect()const
{
return iInfoRect;
}
TSize CScreenLayout::PopMenuItemSize()const
{
return iPopMenuItemSize;
}
TInt CScreenLayout::TextLineHeight()const //文字行间距
{
//return iTextLineHeight;
// itemSize.iHeight = font->HeightInPixels();
// itemSize.iHeight += (itemSize.iHeight>>1);{
return iListBoxLineHeight;
}
TInt CScreenLayout::LineHeight()const //文字行间距
{
return iListBoxLineHeight;
//return iTextLineHeight;
}
TInt CScreenLayout::LineNum()const
{
// WriteLogsL(_L("CScreenLayout::LineNum iLineNum = %d"),iLineNum);
return iLineNum;
}
TInt CScreenLayout::FontHeight()const
{
return iFontHeight;
}
TInt CScreenLayout::ScrollBarWidth()const
{
return iScrollBarWidth;
}
TInt CScreenLayout::IconNumPerLine()const
{
return iIconNumPerLine;
}
TInt CScreenLayout::IconLineNum()const
{
return iIconLineNum;
}
TInt CScreenLayout::Multiple()const
{
return iMultiple;
}
TInt CScreenLayout::Divisor()const
{
return iDivisor;
}
TInt CScreenLayout::InnerMargin()const
{
return iInnerMargin;
}
TInt CScreenLayout::OuterMargin() const
{
return iOuterMargin;
}
/*
TInt CScreenLayout::AttributeOffset()const
{
return iAttributeOffset;
}
*/
void CScreenLayout::GetAttributeOffset(TInt& aOffset1,TInt& aOffset2)const
{
aOffset1 = iAttributeOffset1;
aOffset2 = iAttributeOffset2;
}
void CScreenLayout::GetLoadingTextPos(TInt& aFirstTextPos,TInt& aSecondTextPost)const
{
aFirstTextPos = iLoadingTextPos_1;
aSecondTextPost = iLoadingTextPos_2;
}
void CScreenLayout::GetOfferRewardEditorHeight(TInt& aHeight1,TInt& aHeight2)const
{
aHeight1 = iOfferRewardEditorHeight1;
aHeight2 = iOfferRewardEditorHeight2;
}
void CScreenLayout::GetSaveAsPos(TPoint& aTitlePos,TPoint& aListPos)const
{
aTitlePos = iSaveAsTitlePos;
aListPos = iSaveAsListPos;
}
TSize CScreenLayout::ScaleByDefaultRatio(CFbsBitmap* aBitmap)const
{
ASSERT(aBitmap);
TSize bmpSize = aBitmap->SizeInPixels();
#ifdef __SERIES60_3X__
//TSize screenSize = ScreenSize();
bmpSize.iWidth *= iMultiple;
bmpSize.iWidth /= iDivisor;
bmpSize.iHeight *= iMultiple;
bmpSize.iHeight /= iDivisor;
AknIconUtils::SetSize(aBitmap,bmpSize);
#endif
return bmpSize;
}
CFbsBitmap* CScreenLayout::GetIconL(TInt aId,TInt aMaxXIndex ,TInt aMaxYIndex ,TInt aXIndex,TInt aYIndex)const
{
TFileName fileName = iEngine->GetMbmFileName();
return GetIconL(fileName,aId,aMaxXIndex,aMaxYIndex,aXIndex,aYIndex);
}
CFbsBitmap* CScreenLayout::GetIconL(const TDesC& aFileName,TInt aId,TInt aMaxXIndex,TInt aMaxYIndex,TInt aXIndex,TInt aYIndex)const
{
ASSERT(aMaxXIndex > 0);
ASSERT(aMaxYIndex > 0);
#ifdef __SERIES60_3X__
CFbsBitmap* srcBmp = AknIconUtils::CreateIconL(aFileName,aId);
#else
CFbsBitmap* srcBmp =STATIC_CAST( CEikonEnv* ,CCoeEnv::Static())->CreateBitmapL(aFileName,aId);
#endif
CleanupStack::PushL(srcBmp);
TSize srcSize = srcBmp->SizeInPixels();
srcSize.iWidth /= aMaxXIndex;
srcSize.iHeight /= aMaxYIndex;
TRect bmpRect(srcSize);
bmpRect.Move(srcSize.iWidth*aXIndex,srcSize.iHeight*aYIndex);
//srcRect.
CFbsBitmap* bmp = new (ELeave) CFbsBitmap;
CleanupStack::PushL(bmp);
TInt err = bmp->Create(srcSize,EColor16M);
User::LeaveIfError(err);
CFbsBitmapDevice* bmpDevice = CFbsBitmapDevice::NewL(bmp);
CleanupStack::PushL(bmpDevice);
CFbsBitGc* bmpGc;
err = bmpDevice->CreateContext(bmpGc);
CleanupStack::PushL(bmpGc);
User::LeaveIfError(err);
bmpGc->BitBlt(TPoint(0,0),srcBmp,bmpRect);
CleanupStack::PopAndDestroy(2); //bmpGc,bmpDevice
#ifdef __SERIES60_3X__
bmp = AknIconUtils::CreateIconL(bmp);
#endif
CleanupStack::Pop(); //bmp
CleanupStack::PopAndDestroy(srcBmp); //srcBmp
return bmp;
}
/*
CFbsBitmap* CScreenLayout::GetIconL(const TDesC& aFileName,TInt aId,const TRect& aSrcRect)const
{
CFbsBitmap* bmp = new (ELeave) CFbsBitmap;
CleanupStack::PushL(bmp);
TInt err = bmp->Create(aSrcRect.Size(),EColor16M);
User::LeaveIfError(err);
CFbsBitmapDevice* bmpDevice = CFbsBitmapDevice::NewL(bmp);
CleanupStack::PushL(bmpDevice);
CFbsBitGc* bmpGc;
err = bmpDevice->CreateContext(bmpGc);
CleanupStack::PushL(bmpGc);
User::LeaveIfError(err);
CFbsBitmap* srcBmp = AknIconUtils::CreateIconL(aFileName,aId);
bmpGc->BitBlt(TPoint(0,0),srcBmp,aSrcRect);
delete srcBmp;
CleanupStack::PopAndDestroy(2)
bmp = AknIconUtils::CreateIconL(bmp);
ScaleByDefaultRatio(bmp);
CleanupStack::Pop(); //bmp
return bmp;
}
*/
TSize CScreenLayout::ScreenSize()
{
TPixelsTwipsAndRotation pixelsTwipsAndRotation;
CCoeEnv::Static()->ScreenDevice()->GetDefaultScreenSizeAndRotation(pixelsTwipsAndRotation);
/*
TBuf<10> buf;
buf.AppendNum(pixelsTwipsAndRotation.iPixelSize.iWidth);
buf.Append(_L(":"));
buf.AppendNum(pixelsTwipsAndRotation.iPixelSize.iHeight);
UtilityTools::ExecuteDialog(buf);
*/
////User::InfoPrint(buf);
return pixelsTwipsAndRotation.iPixelSize;
}
//下面两个函数可能产生精度问题
TSize CScreenLayout::ScaleFitToScreenWidth(CFbsBitmap* aBitmap)
{
ASSERT(aBitmap);
TSize bmpSize = aBitmap->SizeInPixels();
TSize screenSize = ScreenSize();
TInt tempNum=bmpSize.iHeight*screenSize.iWidth%bmpSize.iWidth;
bmpSize.iHeight = bmpSize.iHeight*screenSize.iWidth/bmpSize.iWidth;
if(tempNum>5)
bmpSize.iHeight+=1;
bmpSize.iWidth = screenSize.iWidth;
//AknIconUtils::SetSize(aBitmap,bmpSize,EAspectRatioNotPreserved);
#ifdef __SERIES60_3X__
AknIconUtils::SetSize(aBitmap,bmpSize);
#endif
return bmpSize;
}
TSize CScreenLayout::ScaleFitToScreenHeight(CFbsBitmap* aBitmap)
{
ASSERT(aBitmap);
TSize bmpSize = aBitmap->SizeInPixels();
TSize screenSize = ScreenSize();
TInt tempNum=bmpSize.iWidth*screenSize.iHeight%bmpSize.iHeight;
bmpSize.iWidth = bmpSize.iWidth*screenSize.iHeight/bmpSize.iHeight;
if(tempNum>5)
bmpSize.iWidth+=1;
bmpSize.iHeight = screenSize.iHeight;
//AknIconUtils::SetSize(aBitmap,bmpSize,EAspectRatioNotPreserved);
#ifdef __SERIES60_3X__
AknIconUtils::SetSize(aBitmap,bmpSize);
#endif
return bmpSize;
}
/*
//////////////////////////////////////////////////////////////////////////
此类中考虑用固定的值保存图片适合的屏幕尺寸
同时保存该尺寸下使用的字体
//////////////////////////////////////////////////////////////////////////
enum TScaleMode { EAspectRatioPreserved = 0, EAspectRatioPreservedAndUnusedSpaceRemoved = 1, EAspectRatioNotPreserved = 2 }
//////////////////////////////////////////////////////////////////////////
*/
void CScreenLayout::InitData()
{
TSize screenSize = ScreenSize();
//////////////////////////////////////////////////////////////////////////
iStatusPaneRect;
iClientRect;
iControlPaneRect;
//////////////////////////////////////////////////////////////////////////
iTextLineHeight = iDefaultFont->HeightInPixels();
iTextLineHeight += iTextLineHeight/3;
//////////////////////////////////////////////////////////////////////////
iListBoxLineHeight = iDefaultFont->HeightInPixels();
iListBoxLineHeight += iListBoxLineHeight/2;
//////////////////////////////////////////////////////////////////////////
iPopMenuItemSize.iWidth = screenSize.iWidth/2;
iPopMenuItemSize.iHeight = iTextLineHeight + 1;
//////////////////////////////////////////////////////////////////////////
TPoint naviPanePoint;
naviPanePoint.iX = screenSize.iWidth/40;
naviPanePoint.iY = screenSize.iHeight/5 - 2;
TSize naviPaneSize;
naviPaneSize.iWidth = screenSize.iWidth - 2*naviPanePoint.iX;
naviPaneSize.iHeight = screenSize.iHeight/10;
iNaviPaneRect.SetRect(naviPanePoint,naviPaneSize);
//////////////////////////////////////////////////////////////////////////
//CFbsBitmap* bmpTitleBg = NULL;//iEngine->GetBmpTitlebg()->GetBitmap();
CFbsBitmap* bmpTitleBg = iEngine->CreateBmpById(EMbmCocobmpTitlebg);
ASSERT(bmpTitleBg);
TSize titleSize = bmpTitleBg->SizeInPixels();
titleSize.iHeight = (titleSize.iHeight*screenSize.iWidth/titleSize.iWidth);
titleSize.iWidth = screenSize.iWidth;
iStatusPaneRect.SetRect(TPoint(0,0),titleSize);
//CFbsBitmap* controlPaneBmp = NULL;//iEngine->GetBmpMenubg()->GetBitmap();
CFbsBitmap* controlPaneBmp = iEngine->CreateBmpById(EMbmCocobmpMenubg);
ASSERT(controlPaneBmp);
TPoint controlPanePoint(0,0);
TSize menuSize = controlPaneBmp->SizeInPixels();
menuSize.iHeight = (menuSize.iHeight*screenSize.iWidth/menuSize.iWidth);
menuSize.iWidth = screenSize.iWidth;
controlPanePoint.iY = screenSize.iHeight - menuSize.iHeight;
iControlPaneRect.SetRect(controlPanePoint,menuSize);
//////////////////////////////////////////////////////////////////////////
//iDialogRect;
//////////////////////////////////////////////////////////////////////////
// iWhiteBackgroundRect = iContentZoneRect;
/*
TRect iListBoxRect;
TRect iDialogRect;
TRect iScrollbarRect;
TSize iPopMenuItemSize;
iMultiTextRect
//TRect clientRect(TPoint(5,65),TSize(SCREEN_WIDTH,SCREEN_HEIGHT/2)); //test
TRect clientRect(TPoint(7,62),TSize(162,119));
*/
/*
#define KNaviPaneTextPoint TPoint(4,38)
#define KNaviPaneSize TSize(169, 20)
#define KNaviPaneRect TRect(KNaviPaneTextPoint,KNaviPaneSize)
#define KLeftButtonPos TPoint(3,191)
#define KRightButtonPos TPoint(173,191)
*/
/*
const CFont* iDefaultFont;
TRect iStatusPaneRect;
TRect iContentZoneRect;
TRect iControlPaneRect;
TRect iNaviPaneRect;
TRect iListBoxRect;
TRect iDialogRect;
TRect iScrollbarRect;
TSize iPopMenuItemSize;
TInt iTextLineHeight;
*/
}
void CScreenLayout::InitByScreenSize()
{
TSize screenSize = ScreenSize();
if(screenSize.iWidth == 176&& screenSize.iHeight == 208) //3250
{
iScrollBarWidth = 3;
iIconNumPerLine = 3;
iIconLineNum = 3;
iInnerMargin = 2;
iOuterMargin = 5;
iMultiple = 1;
iDivisor = 1;
iLoadingTextPos_1 = 110;
iLoadingTextPos_2 = 177;
iSaveAsTitlePos.iX = 0;
iSaveAsTitlePos.iY = 5;
iSaveAsListPos.iX = 0;
iSaveAsListPos.iY = 30;
iAttributeOffset1 = 10;
iAttributeOffset2 = 40;
// iOfferRewardEditorLineHeight =
iOfferRewardEditorHeight1 = 74;
iOfferRewardEditorHeight2 = 74;
}
else if(screenSize.iWidth == 352&& screenSize.iHeight == 416) //N80
{
iScrollBarWidth = 6;
iIconNumPerLine = 3;
iIconLineNum = 3;
iInnerMargin = 4;
iOuterMargin = 10;
iMultiple = 2;
iDivisor = 1;
iLoadingTextPos_1 = 230;
iLoadingTextPos_2 = 354;
iSaveAsTitlePos.iX = 0;
iSaveAsTitlePos.iY = 10;
iSaveAsListPos.iX = 0;
iSaveAsListPos.iY = 65;
iAttributeOffset1 = 20;
iAttributeOffset2 = 80;
iOfferRewardEditorHeight1 = 144;
iOfferRewardEditorHeight2 = 144;
}
else if(screenSize.iWidth == 240&& screenSize.iHeight == 320) //N73
{
iScrollBarWidth = 4;
iIconNumPerLine = 3;
iIconLineNum = 3;
iInnerMargin = 3;
iOuterMargin = 7;
iMultiple = 1;
iDivisor = 1;
iMultiple = 4;
iDivisor = 3;
iLoadingTextPos_1 = 178;
iLoadingTextPos_2 = 270;
iSaveAsTitlePos.iX = 0;
iSaveAsTitlePos.iY = 8;
iSaveAsListPos.iX = 0;
iSaveAsListPos.iY = 37;
iAttributeOffset1 = 15;
iAttributeOffset2 = 50;
iOfferRewardEditorHeight1 = 135;
iOfferRewardEditorHeight2 = 135;
}
else if(screenSize.iWidth == 320&& screenSize.iHeight == 240) //E61
{
iScrollBarWidth = 5;
iIconNumPerLine = 3;
iIconLineNum = 3;
iInnerMargin = 2;
iOuterMargin = 5;
iMultiple = 1;
iDivisor = 1;
iLoadingTextPos_1 = 125;
iLoadingTextPos_2 = 177;
// iSaveAsListPos.iX = ;
// iSaveAsListPos.iY = ;
// iSaveAsListPos.iX = ;
// iSaveAsListPos.iY = ;
}
else if(screenSize.iWidth == 208&& screenSize.iHeight == 208) //5500
{
iScrollBarWidth = 5;
iIconNumPerLine = 3;
iIconLineNum = 3;
iInnerMargin = 2;
iOuterMargin = 5;
iMultiple = 1;
iDivisor = 1;
iLoadingTextPos_1 = 125;
iLoadingTextPos_2 = 177;
// iSaveAsListPos.iX = ;
// iSaveAsListPos.iY = ;
// iSaveAsListPos.iX = ;
// iSaveAsListPos.iY = ;
}
else if(screenSize.iWidth == 800&& screenSize.iHeight == 352) //
{
iScrollBarWidth = 6;
iSaveAsListPos;
iSaveAsListPos;
}
else //其它未知机型
{
//ASSERT(0);
}
}
void CScreenLayout::InitByFont()
{
// WriteLogsL(_L("CScreenLayout::InitByFont"));
iFontHeight = iDefaultFont->HeightInPixels();
//////////////////////////////////////////////////////////////////////////
iTextLineHeight = iFontHeight;
iTextLineHeight += iTextLineHeight/3;
//////////////////////////////////////////////////////////////////////////
iListBoxLineHeight = iFontHeight;
iListBoxLineHeight += iListBoxLineHeight/2;
//////////////////////////////////////////////////////////////////////////
}
/*
void CScreenLayout::InitDialogRect()
{
void CDialog::InitBitmaps()
{
iDialogBmp = iEngine->CreateBmpL(EMbmSoarskyresDialog);
iDialogIcon = iEngine->CreateBmpL(EMbmSoarskyresDialog_icon);
iDialogIconMask = iEngine->CreateBmpL(EMbmSoarskyresDialog_icon_mask);
TInt multiple = iScreenLayout->Multiple();
TInt divisor = iScreenLayout->Divisor();
iDialogSize = iDialogBmp->SizeInPixels();
iDialogSize.iWidth = (iDialogSize.iWidth*multiple)/divisor;
iDialogSize.iHeight = (iDialogSize.iHeight*multiple)/divisor;
AknIconUtils::SetSize(iDialogBmp,iDialogSize);
iIconSize = iDialogIcon->SizeInPixels();
iIconSize.iWidth = (iIconSize.iWidth*multiple)/divisor;
iIconSize.iHeight = (iIconSize.iHeight*multiple)/divisor;
AknIconUtils::SetSize(iDialogIcon,iIconSize);
AknIconUtils::SetSize(iDialogIconMask,iIconSize);
//上下左右居中
TSize screenSize = CScreenLayout::ScreenSize();
iStartPoint.iX = (screenSize.iWidth - iDialogSize.iWidth)/2;
iStartPoint.iY = (screenSize.iHeight - iDialogSize.iHeight)/2;
iIconPoint.iX = 0;
iIconPoint.iY = (iDialogSize.iHeight - iIconSize.iHeight)/2;
iTextLengthPerLine = iDialogSize.iWidth - iIconSize.iWidth/3;
iMargin = iScreenLayout->InnerMargin();
iTextLengthPerLine -= iMargin*2;
// TSize textSize = iDialogSize;
// textSize.iWidth -= iIconSize.iWidth;
}
}
*/
| [
"sungrass.xp@37a08ede-ebbd-11dd-bd7b-b12b6590754f"
]
| [
[
[
1,
710
]
]
]
|
bc9a0862cbaba45aad5f0a0689c5c217e2560af9 | 913f43ef4d03bd5d6b42b9e31b1048ae54493f59 | /CraterRacer/CraterRacer/Source_Code/Utility Files/VictoryCalculator.cpp | 66debd7b1365c2608b4405ae08417d2ef1cf9145 | []
| no_license | GreenAdept/cpsc585 | bfba6ea333c2857df0822dd7d00768df6a010a73 | c66745e77be4c78e435da1a59ae94ac2a61228cf | refs/heads/master | 2021-01-10T16:42:03.804213 | 2010-04-27T00:13:52 | 2010-04-27T00:13:52 | 48,024,449 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,004 | cpp |
#include "VictoryCalculator.h"
#include "MessageManager.h"
using namespace std;
VictoryCalculator::VictoryCalculator() {
gameFinished = false;
recorded = false;
hasTimeLimit = false;
timeLimit = "";
emittedGameFinished = false;
completedTimeTrial = true;
}
//------------------------------------------------------
// Function: calculateRank
// Calculates the ranking and remaining laps for the
// Vehicle in the provided vector/list with the specified
// index.
//------------------------------------------------------
void VictoryCalculator::calculateRank (vector<Vehicle*>& vehicles, int index) {
Vehicle* v = vehicles[index];
VehicleAI* myAI = (VehicleAI*) v->getAI();
int rank = 1;
if (myAI->isFinished()) {
for (int i=0; i<finished.size(); i++)
if (finished[i])
rank++;
finished[index] = true;
ranks[index] = rank;
}
else {
int passedWPs = myAI->getNumberofPassedWPs();
float dist = myAI->getDistanceToNextWP (v->getPosition());
for (int i=0; i<vehicles.size(); i++) {
if (i == index) continue;
VehicleAI* enemyAI = (VehicleAI*) vehicles[i]->getAI();
if (passedWPs < enemyAI->getNumberofPassedWPs())
rank++;
if (passedWPs == enemyAI->getNumberofPassedWPs()) {
if (dist > enemyAI->getDistanceToNextWP (vehicles[i]->getPosition()))
rank++;
}
}
ranks[index] = rank;
v->setRank(rank);
}
}
//------------------------------------------------------
// Function: calculateRanks
// Calculates the rankings and remaining laps for the
// Vehicles in the provided vector/list.
//------------------------------------------------------
void VictoryCalculator::calculateRanks (vector<Vehicle*> vehicles, int numPlayers) {
if (ranks.size() != vehicles.size()) {
ranks.resize (vehicles.size(), 1);
finished.resize (vehicles.size(), false);
finishTimes.resize (vehicles.size(), "00:00:00");
}
gameFinished = true;
for (int i=0; i<vehicles.size(); i++) {
if (!finished[i]) {
calculateRank (vehicles, i);
if (i < numPlayers)
gameFinished = false;
}
}
if (hasTimeLimit && finished[0] && gameFinished) { //if the vehicle finished, and there is a time limit
if (finishTimes[0].compare(timeLimit) <= 0) {
//else show a message with "congrats" or something, and record time.
completedTimeTrial = true;
}
}
if (!emittedGameFinished) {
if (gameFinished) {
Emit (Events::EGameFinished);
emittedGameFinished = true;
}
}
}
//------------------------------------------------------
// Function: getRank
// Returns the ranking of the vehicle (player or
// computer-controlled) with the specified index.
//
// Player 1 has index 0, Player 2 has index 1, etc...
//------------------------------------------------------
int VictoryCalculator::getRank (int index) {
if (index >= ranks.size())
return 0;
else
return ranks[index];
}
vector<int> VictoryCalculator::getRanks () {
return ranks;
}
//------------------------------------------------------
// Function: isFinished
// Returns true if the vehicle (player or computer-
// controlled) with the specified index has finished
// the race, false otherwise.
//
// Player 1 has index 0, Player 2 has index 1, etc...
//------------------------------------------------------
bool VictoryCalculator::isFinished (int index) {
if (index >= finished.size())
return false;
else
return finished[index];
}
/*
wstring VictoryCalculator::getFormattedString (int index) {
if (index >= finished.size())
return L"%i";
if (finished[index])
return L"You finished in %i place";
else
return L"You are in %i place";
}
*/
int VictoryCalculator::recordTime(string time) {
//if the player is not finished, or we have already recorded the time, return
if (!isFinished(0)) return -1;
if (recorded) return -1;
times.clear();
int numberOfRecordedTimes = 5;
//get the current recordings from file
ifstream fin("times.txt");
string s;
while (!fin.eof()) {
fin >> s; //read the time from file
if (s != "") {
times.push_back(s);
}
fin >> s; //read the name from file
if (s != "") {
names.push_back(s);
}
}
fin.close();
//make sure there is the right number of recorded times
while (times.size() != numberOfRecordedTimes) {
if (times.size() < numberOfRecordedTimes) {
times.push_back("59:59:99");
}
else {
times.pop_back();
}
}
//make sure there is the right number of recorded names
while (names.size() != numberOfRecordedTimes) {
if (names.size() < numberOfRecordedTimes) {
names.push_back("---");
}
else {
names.pop_back();
}
}
//add the new time to the list of recorded times (means there is one more recording than wanted)
times.push_back(time);
names.push_back("---");
//sort the times
int index = numberOfRecordedTimes;
while (index > 0) {
if (times[index].compare(times[index-1]) < 0) {
string temp = times[index];
times[index] = times[index-1];
times[index-1] = temp;
temp = names[index];
names[index] = names[index-1];
names[index-1] = temp;
index--;
}
else {
break;
}
}
//remove the slowest time (so that there is the right number of recordings again)
times.pop_back();
names.pop_back();
recorded = true;
return index;
}
void VictoryCalculator::closeFile(int index, string name) {
names[index] = name;
ofstream fout("times.txt");
for (int i = 0; i < times.size(); i++) {
fout << times[i] << endl;
fout << names[i] << endl;
}
fout.close();
}
vector<string> VictoryCalculator::getRecordedTimes()
{
return times;
}
vector<string> VictoryCalculator::getRecordedNames()
{
return names;
}
bool VictoryCalculator::isGameFinished () {
return gameFinished;
}
//--------------------------------------------------------------------------------------
// Function: setFinishTime
// This function sets the finish time for a player.
//--------------------------------------------------------------------------------------
void VictoryCalculator::setFinishTime (int playerNum, string time) {
if( playerNum > 7 )
return;
else if (playerNum < 0)
finishTimes [-playerNum] = time;
else
finishTimes [playerNum] = time;
}
string VictoryCalculator::getFinishTime(int playerNum)
{
return finishTimes[playerNum];
}
//--------------------------------------------------------------------------------------
// Function: getFinishTimes
//--------------------------------------------------------------------------------------
vector<string> VictoryCalculator::getFinishTimes () {
return finishTimes;
}
void VictoryCalculator::setTimeLimit(string limit)
{
hasTimeLimit = true;
timeLimit = limit;
completedTimeTrial = false;
}
string VictoryCalculator::getTimeLimit( )
{
if (hasTimeLimit)
return timeLimit;
return NULL;
}
| [
"tfalders@b92cab1e-0213-11df-804c-772d9fe11005",
"amber.wetherill@b92cab1e-0213-11df-804c-772d9fe11005",
"[email protected]",
"wshnng@b92cab1e-0213-11df-804c-772d9fe11005"
]
| [
[
[
1,
2
],
[
5,
6
],
[
8,
8
],
[
15,
52
],
[
54,
76
],
[
84,
85
],
[
92,
139
],
[
231,
231
],
[
238,
240
],
[
242,
242
],
[
247,
247
]
],
[
[
3,
4
],
[
225,
225
],
[
237,
237
],
[
241,
241
],
[
243,
246
],
[
249,
249
],
[
254,
255
],
[
261,
263
],
[
265,
265
]
],
[
[
7,
7
],
[
12,
12
],
[
14,
14
],
[
86,
91
],
[
140,
140
],
[
142,
146
],
[
148,
152
],
[
155,
155
],
[
157,
168
],
[
170,
174
],
[
176,
203
],
[
205,
205
],
[
207,
217
],
[
219,
220
],
[
222,
224
],
[
232,
236
],
[
248,
248
],
[
250,
253
],
[
264,
264
]
],
[
[
9,
11
],
[
13,
13
],
[
53,
53
],
[
77,
83
],
[
141,
141
],
[
147,
147
],
[
153,
154
],
[
156,
156
],
[
169,
169
],
[
175,
175
],
[
204,
204
],
[
206,
206
],
[
218,
218
],
[
221,
221
],
[
226,
230
],
[
256,
260
],
[
266,
282
]
]
]
|
62596208512f959d536fedef39904fd184f247cd | 7466380185c736d09946eca7b2e09ecc5ac516db | /src/agg/agg_font_win32_tt.h | c9408dd8eeb76f966fe6e1f95b4eae7a883cdfc7 | []
| no_license | gchiu/Hostkit | 8b37a218a68bc5ed7863b4e04cb6fe072ba66275 | 1a270f6923ccf62ca6d7d31b063e7649ef0cc984 | refs/heads/master | 2021-01-24T01:01:12.023673 | 2010-07-29T22:05:00 | 2010-08-02T22:27:17 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,595 | h | //----------------------------------------------------------------------------
// Anti-Grain Geometry - Version 2.3
// Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
//
// Permission to copy, use, modify, sell and distribute this software
// is granted provided this copyright notice appears in all copies.
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
//----------------------------------------------------------------------------
// Contact: [email protected]
// [email protected]
// http://www.antigrain.com
//----------------------------------------------------------------------------
#ifndef AGG_FONT_WIN32_TT_INCLUDED
#define AGG_FONT_WIN32_TT_INCLUDED
#include <windows.h>
#include "agg_scanline_storage_aa.h"
#include "agg_scanline_storage_bin.h"
#include "agg_scanline_u.h"
#include "agg_scanline_bin.h"
#include "agg_path_storage_integer.h"
#include "agg_rasterizer_scanline_aa.h"
#include "agg_conv_curve.h"
#include "agg_trans_affine.h"
#include "agg_font_cache_manager.h"
namespace agg
{
//-----------------------------------------------font_engine_win32_tt_base
class font_engine_win32_tt_base
{
enum { buf_size = 32768-32 };
public:
//--------------------------------------------------------------------
typedef serialized_scanlines_adaptor_aa<int8u> gray8_adaptor_type;
typedef serialized_scanlines_adaptor_bin mono_adaptor_type;
typedef scanline_storage_aa8 scanlines_aa_type;
typedef scanline_storage_bin scanlines_bin_type;
//--------------------------------------------------------------------
~font_engine_win32_tt_base();
font_engine_win32_tt_base(bool flag32, HDC dc, unsigned max_fonts = 32);
// Set font parameters
//--------------------------------------------------------------------
void resolution(unsigned dpi) { m_resolution = unsigned(dpi); }
void height(double h) { m_height = unsigned(h); }
void width(double w) { m_width = unsigned(w); }
void weight(int w) { m_weight = w; }
void italic(int it) { m_italic = it; }
void char_set(DWORD c) { m_char_set = c; }
void pitch_and_family(DWORD p){ m_pitch_and_family = p; }
void flip_y(bool flip) { m_flip_y = flip; }
void hinting(bool h) { m_hinting = h; }
bool create_font(const char* typeface_, glyph_rendering ren_type);
bool create_font(const char* typeface_,
glyph_rendering ren_type,
double height_,
double width_=0.0,
int weight_=FW_REGULAR,
int italic_=0,
DWORD char_set_=ANSI_CHARSET,
DWORD pitch_and_family_=FF_DONTCARE);
// Set Gamma
//--------------------------------------------------------------------
template<class GammaF> void gamma(const GammaF& f)
{
m_rasterizer.gamma(f);
}
//--------------------------------------------------------------------
void transform(const agg::trans_affine& mtx)
{
m_affine = mtx;
}
// Accessors
//--------------------------------------------------------------------
unsigned resolution() const { return m_resolution; }
const char* typeface() const { return m_typeface; }
double height() const { return m_height; }
double width() const { return m_width; }
int weight() const { return m_weight; }
int italic() const { return m_italic; }
DWORD char_set() const { return m_char_set; }
DWORD pitch_and_family() const { return m_pitch_and_family; }
bool hinting() const { return m_hinting; }
bool flip_y() const { return m_flip_y; }
KERNINGPAIR* kerning_pairs()const { return m_kerning_pairs; }
// Interface mandatory to implement for font_cache_manager
//--------------------------------------------------------------------
const char* font_signature() const { return m_signature; }
int change_stamp() const { return m_change_stamp; }
bool prepare_glyph(unsigned glyph_code);
unsigned glyph_index() const { return m_glyph_index; }
unsigned data_size() const { return m_data_size; }
glyph_data_type data_type() const { return m_data_type; }
const rect& bounds() const { return m_bounds; }
double advance_x() const { return m_advance_x; }
double advance_y() const { return m_advance_y; }
void write_glyph_to(int8u* data) const;
bool add_kerning(unsigned first, unsigned second,
double* x, double* y);
private:
font_engine_win32_tt_base(const font_engine_win32_tt_base&);
const font_engine_win32_tt_base& operator = (const font_engine_win32_tt_base&);
void update_signature();
static bool pair_less(const KERNINGPAIR v1, const KERNINGPAIR v2);
void load_kerning_pairs();
void sort_kerning_pairs();
int find_font(const char* name) const;
bool m_flag32;
HDC m_dc;
HFONT m_old_font;
HFONT* m_fonts;
unsigned m_num_fonts;
unsigned m_max_fonts;
char** m_font_names;
HFONT m_cur_font;
int m_change_stamp;
char* m_typeface;
unsigned m_typeface_len;
char* m_signature;
unsigned m_height;
unsigned m_width;
int m_weight;
int m_italic;
DWORD m_char_set;
DWORD m_pitch_and_family;
bool m_hinting;
bool m_flip_y;
bool m_font_created;
unsigned m_resolution;
glyph_rendering m_glyph_rendering;
unsigned m_glyph_index;
unsigned m_data_size;
glyph_data_type m_data_type;
rect m_bounds;
double m_advance_x;
double m_advance_y;
MAT2 m_matrix;
char* m_gbuf;
KERNINGPAIR* m_kerning_pairs;
unsigned m_num_kerning_pairs;
unsigned m_max_kerning_pairs;
trans_affine m_affine;
path_storage_integer<int16, 6> m_path16;
path_storage_integer<int32, 6> m_path32;
conv_curve<path_storage_integer<int16, 6> > m_curves16;
conv_curve<path_storage_integer<int32, 6> > m_curves32;
scanline_u8 m_scanline_aa;
scanline_bin m_scanline_bin;
scanlines_aa_type m_scanlines_aa;
scanlines_bin_type m_scanlines_bin;
rasterizer_scanline_aa<> m_rasterizer;
};
//------------------------------------------------font_engine_win32_tt_int16
// This class uses values of type int16 (10.6 format) for the vector cache.
// The vector cache is compact, but when rendering glyphs of height
// more that 200 there integer overflow can occur.
//
class font_engine_win32_tt_int16 : public font_engine_win32_tt_base
{
public:
typedef serialized_integer_path_adaptor<int16, 6> path_adaptor_type;
typedef font_engine_win32_tt_base::gray8_adaptor_type gray8_adaptor_type;
typedef font_engine_win32_tt_base::mono_adaptor_type mono_adaptor_type;
typedef font_engine_win32_tt_base::scanlines_aa_type scanlines_aa_type;
typedef font_engine_win32_tt_base::scanlines_bin_type scanlines_bin_type;
font_engine_win32_tt_int16(HDC dc, unsigned max_fonts = 32) :
font_engine_win32_tt_base(false, dc, max_fonts) {}
};
//------------------------------------------------font_engine_win32_tt_int32
// This class uses values of type int32 (26.6 format) for the vector cache.
// The vector cache is twice larger than in font_engine_win32_tt_int16,
// but it allows you to render glyphs of very large sizes.
//
class font_engine_win32_tt_int32 : public font_engine_win32_tt_base
{
public:
typedef serialized_integer_path_adaptor<int32, 6> path_adaptor_type;
typedef font_engine_win32_tt_base::gray8_adaptor_type gray8_adaptor_type;
typedef font_engine_win32_tt_base::mono_adaptor_type mono_adaptor_type;
typedef font_engine_win32_tt_base::scanlines_aa_type scanlines_aa_type;
typedef font_engine_win32_tt_base::scanlines_bin_type scanlines_bin_type;
font_engine_win32_tt_int32(HDC dc, unsigned max_fonts = 32) :
font_engine_win32_tt_base(true, dc, max_fonts) {}
};
}
#endif
| [
"[email protected]"
]
| [
[
[
1,
216
]
]
]
|
2ca573ad4c043fe84c3b3c920b61796075079f34 | 9a10a9d7886ce0ba9e85a0ed092e6eb6bafb2780 | /inc/impl/DnD.cpp | c0b21be031eb47709dc23b4ac9ad9e1e151fd91e | [
"BSD-3-Clause"
]
| permissive | leok7v/kolobok | ccc51bbeef67739978d8465d328b4f93b4d7e833 | 30278ac53285912587db078e28205ea33a85143f | refs/heads/master | 2020-06-04T08:37:01.952623 | 2010-01-07T06:23:38 | 2010-01-07T06:23:38 | 32,692,395 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,752 | cpp | #include "tiny.h"
/* Ole DoDragDrop "swallows" messages. After extensive study of it
the simplest solution is just to implement and use its' equvivalent
that does not.
*/
struct DropTargetNode {
HWND hwnd; // target
IDropTarget* dt;
DropTargetNode* prev;
DropTargetNode* next;
};
struct TrackerWindowInfo {
HRESULT hr;
IDataObject* object;
IDropSource* dropSource;
IDropTarget* dragTarget;
DWORD allowedEffects;
DWORD* effect;
HWND hwndTarget;
HWND hwndDragTarget;
bool done;
bool esc;
};
static const uchar DRAGTRACKERCLASS[] = L"DnDTracker";
static DropTargetNode* targets = null;
static int getButtonState() {
byte ks[256] = { 0 };
GetKeyboardState(ks);
int keyMask = 0;
if ((ks[VK_SHIFT] & 0x80) != 0) keyMask |= MK_SHIFT;
if ((ks[VK_CONTROL] & 0x80) != 0) keyMask |= MK_CONTROL;
if ((ks[VK_LBUTTON] & 0x80) != 0) keyMask |= MK_LBUTTON;
if ((ks[VK_RBUTTON] & 0x80) != 0) keyMask |= MK_RBUTTON;
if ((ks[VK_MBUTTON] & 0x80) != 0) keyMask |= MK_MBUTTON;
return keyMask;
}
static void insertDropTarget(DropTargetNode* nodeToAdd) {
DropTargetNode* node = targets;
DropTargetNode** prev = &targets;
while (node != null) {
if (nodeToAdd->hwnd < node->hwnd) {
prev = &node->prev;
node = node->prev;
}
else if (nodeToAdd->hwnd > node->hwnd) {
prev = &node->next;
node = node->next;
}
else {
assert(false);
return;
}
}
assert(node == null);
assert(*prev == null);
*prev = nodeToAdd;
}
static DropTargetNode* extractDropTarget(HWND hwndOfTarget) {
DropTargetNode* node = targets;
DropTargetNode** prev = &targets;
while (node != null) {
if (hwndOfTarget < node->hwnd) {
prev = &node->prev;
node = node->prev;
}
else if (hwndOfTarget > node->hwnd) {
prev = &node->next;
node = node->next;
}
else {
assert(*prev == node);
*prev = node->prev;
if (node->next != null) insertDropTarget(node->next);
node->next = null;
node->prev = null;
return node;
}
}
return null;
}
static DropTargetNode* findDropTarget(HWND hwndOfTarget) {
DropTargetNode* node = targets;
while (node != null) {
if (hwndOfTarget < node->hwnd) node = node->prev;
else if (hwndOfTarget > node->hwnd) node = node->next;
else return node;
}
return null;
}
static void trackMouseMove(TrackerWindowInfo* trackerInfo, POINT pt, DWORD keyState) {
HRESULT hr = S_OK;
HWND newTarget = WindowFromPoint(pt);
*trackerInfo->effect = trackerInfo->allowedEffects;
if (trackerInfo->dragTarget != null && trackerInfo->hwndTarget == newTarget) {
POINTL mouse = { pt.x, pt.y };
trackerInfo->dragTarget->DragOver(keyState, mouse, trackerInfo->effect);
}
else {
DropTargetNode* newDropTargetNode = 0;
if (trackerInfo->dragTarget != null) {
trackerInfo->dragTarget->DragLeave();
}
if (newTarget != 0) {
HWND hwnd = newTarget;
trackerInfo->hwndTarget = newTarget;
do { newDropTargetNode = findDropTarget(hwnd); }
while (!newDropTargetNode && (hwnd = GetParent(hwnd)) != 0);
if (hwnd != null) newTarget = hwnd;
trackerInfo->hwndDragTarget = newTarget;
trackerInfo->dragTarget = newDropTargetNode != null ? newDropTargetNode->dt : null;
if (trackerInfo->dragTarget != null) {
POINTL mouse = { pt.x, pt.y };
trackerInfo->dragTarget->DragEnter(trackerInfo->object,
keyState, mouse, trackerInfo->effect);
}
}
else {
trackerInfo->hwndDragTarget = null;
trackerInfo->hwndTarget = null;
trackerInfo->dragTarget = null;
}
}
if (trackerInfo->dragTarget == null) *trackerInfo->effect = DROPEFFECT_NONE;
hr = trackerInfo->dropSource->GiveFeedback(*trackerInfo->effect);
if (hr == DRAGDROP_S_USEDEFAULTCURSORS) {
int id = 1;
if (*trackerInfo->effect & DROPEFFECT_MOVE) id = 2;
else if (*trackerInfo->effect & DROPEFFECT_COPY) id = 3;
else if (*trackerInfo->effect & DROPEFFECT_LINK) id = 4;
HINSTANCE ole32 = GetModuleHandle(L"ole32.dll");
HCURSOR crs = LoadCursor(ole32, MAKEINTRESOURCE(id));
if (crs != null) SetCursor(crs);
}
}
static void trackStateChange(TrackerWindowInfo* trackerInfo, POINT pt, DWORD keyState) {
trackerInfo->hr = trackerInfo->dropSource->QueryContinueDrag(trackerInfo->esc, keyState);
if (trackerInfo->hr != S_OK) {
trackerInfo->done = true;
ReleaseCapture();
if (trackerInfo->dragTarget != null) {
switch (trackerInfo->hr) {
case DRAGDROP_S_DROP: {
POINTL mouse = { pt.x, pt.y };
trackerInfo->dragTarget->Drop(trackerInfo->object,
keyState, mouse, trackerInfo->effect);
break;
}
case DRAGDROP_S_CANCEL: {
trackerInfo->dragTarget->DragLeave();
*trackerInfo->effect = DROPEFFECT_NONE;
break;
}
}
}
}
}
static LRESULT CALLBACK dragTrackerWindowProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) {
switch (msg)
{
case WM_CREATE: {
LPCREATESTRUCT createStruct = (LPCREATESTRUCT)lp;
SetWindowLong(hwnd, 0, (long)createStruct->lpCreateParams);
break;
}
case WM_MOUSEMOVE: {
TrackerWindowInfo* trackerInfo = (TrackerWindowInfo*)GetWindowLong(hwnd, 0);
POINT pt = { LOWORD(lp), HIWORD(lp) };
ClientToScreen(hwnd, &pt);
trackMouseMove(trackerInfo, pt, wp);
break;
}
case WM_LBUTTONUP: case WM_MBUTTONUP: case WM_RBUTTONUP:
case WM_LBUTTONDOWN: case WM_MBUTTONDOWN: case WM_RBUTTONDOWN: {
TrackerWindowInfo* trackerInfo = (TrackerWindowInfo*)GetWindowLong(hwnd, 0);
POINT pt = { LOWORD(lp), HIWORD(lp) };
ClientToScreen(hwnd, &pt);
trackStateChange(trackerInfo, pt, wp);
break;
}
}
return DefWindowProc(hwnd, msg, wp, lp);
}
#pragma warning(disable: 4345) /* behavior change: an object of POD type constructed with an initializer of the form () will be default-initialized. */
HRESULT DnD::registerDragDrop(HWND hwnd, LPDROPTARGET pDropTarget) {
// trace(L"registerDragDrop(%p, %p)\n", hwnd, pDropTarget);
if (pDropTarget == null) return E_INVALIDARG;
DropTargetNode* dropTargetInfo = findDropTarget(hwnd);
if (dropTargetInfo != null) return DRAGDROP_E_ALREADYREGISTERED;
dropTargetInfo = new DropTargetNode(); // warning 4345
if (dropTargetInfo == null) return E_OUTOFMEMORY;
dropTargetInfo->hwnd = hwnd;
dropTargetInfo->prev = null;
dropTargetInfo->next = null;
dropTargetInfo->dt = pDropTarget;
dropTargetInfo->dt->AddRef();
insertDropTarget(dropTargetInfo);
return S_OK;
}
HRESULT DnD::revokeDragDrop(HWND hwnd) {
// trace(L"revokeDragDrop(%p)\n", hwnd);
DropTargetNode* dropTargetInfo = extractDropTarget(hwnd);
if (dropTargetInfo == null) return DRAGDROP_E_NOTREGISTERED;
dropTargetInfo->dt->Release();
delete dropTargetInfo;
return S_OK;
}
HRESULT DnD::doDragDrop(IDataObject *object,
IDropSource* dropSource,
DWORD allowedEffects,
DWORD* effect) {
// trace(L"doDragDrop(%p, %p)\n", object, dropSource);
if (dropSource == null) return E_INVALIDARG;
TrackerWindowInfo trackerInfo = {0};
trackerInfo.object = object;
trackerInfo.dropSource = dropSource;
trackerInfo.allowedEffects = allowedEffects;
trackerInfo.effect = effect;
trackerInfo.done = false;
trackerInfo.esc = false;
trackerInfo.hwndDragTarget = 0;
trackerInfo.hwndTarget = 0;
trackerInfo.dragTarget = 0;
MSG msg = {0};
HWND hwndTrackWindow = CreateWindow(DRAGTRACKERCLASS, L"DnDTracker", WS_POPUP,
-1, -1, -1, -1, 0, 0, 0, &trackerInfo);
if (hwndTrackWindow != 0) {
SetCapture(hwndTrackWindow);
while (!trackerInfo.done && GetMessage(&msg, 0, 0, 0)) {
if (msg.message >= WM_KEYFIRST && msg.message <= WM_KEYLAST) {
if (msg.message == WM_KEYDOWN && msg.wParam == VK_ESCAPE) {
trackerInfo.esc = true;
}
trackStateChange(&trackerInfo, msg.pt, getButtonState());
}
else {
DispatchMessage(&msg);
}
}
DestroyWindow(hwndTrackWindow);
return trackerInfo.hr;
}
return E_FAIL;
}
void DnD::init() {
WNDCLASS wndClass = {0};
wndClass.style = CS_GLOBALCLASS;
wndClass.lpfnWndProc = dragTrackerWindowProc;
wndClass.cbWndExtra = sizeof(TrackerWindowInfo*);
wndClass.lpszClassName = DRAGTRACKERCLASS;
RegisterClass(&wndClass);
}
void DnD::fini() {
while (targets != null) RevokeDragDrop(targets->hwnd);
}
| [
"leo.kuznetsov@e731d3c6-f9ae-11de-973d-3ba8dba7af4f"
]
| [
[
[
1,
271
]
]
]
|
b5eef683269122d0f314765e6c9e18c758e4a012 | 037faae47a5b22d3e283555e6b5ac2a0197faf18 | /pcsx2v2/windows/WinMain.cpp | 61c705b922110980738d380b84f06308a03e8cc1 | []
| no_license | isabella232/pcsx2-sourceforge | 6e5aac8d0b476601bfc8fa83ded66c1564b8c588 | dbb2c3a010081b105a8cba0c588f1e8f4e4505c6 | refs/heads/master | 2023-03-18T22:23:15.102593 | 2008-11-17T20:10:17 | 2008-11-17T20:10:17 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 52,310 | cpp | /* Pcsx2 - Pc Ps2 Emulator
* Copyright (C) 2002-2008 Pcsx2 Team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#define WINVER 0x0500
#if _WIN32_WINNT < 0x0501
#define _WIN32_WINNT 0x0501
#endif
#include <windows.h>
#include <windowsx.h>
#include <commctrl.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <sys/stat.h>
#include <ntsecapi.h>
#include <assert.h>
#include "Common.h"
#include "PsxCommon.h"
#include "win32.h"
#include "resource.h"
#include "cheats\cheats.h"
#include "debugger.h"
#include "rdebugger.h"
#include "AboutDlg.h"
#include "McdsDlg.h"
#include "VU.h"
#include "iCore.h"
#include "iVUzerorec.h"
#include "cheats/cheats.h"
#include "../Paths.h"
#define COMPILEDATE __DATE__
static int efile;
char filename[256];
extern int g_SaveGSStream;
static int AccBreak = 0;
int needReset = 1;
unsigned int langsMax;
typedef struct {
char lang[256];
} _langs;
_langs *langs = NULL;
int UseGui = 1;
int nDisableSC = 0; // screensaver
int firstRun=1;
int RunExe = 0;
void OpenConsole() {
COORD csize;
CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
SMALL_RECT srect;
if (gApp.hConsole) return;
AllocConsole();
SetConsoleTitle(_("Ps2 Output"));
csize.X = 100;
csize.Y = 1024;
SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE), csize);
GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbiInfo);
srect = csbiInfo.srWindow;
srect.Right = srect.Left + 99;
srect.Bottom = srect.Top + 64;
SetConsoleWindowInfo(GetStdHandle(STD_OUTPUT_HANDLE), TRUE, &srect);
gApp.hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
}
void CloseConsole() {
if (gApp.hConsole == NULL) return;
FreeConsole(); gApp.hConsole = NULL;
}
void strcatz(char *dst, char *src) {
int len = strlen(dst) + 1;
strcpy(dst + len, src);
}
//2002-09-20 (Florin)
BOOL APIENTRY CmdlineProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);//forward def
//-------------------
extern int g_ZeroGSOptions;
void RunExecute(int run) {
SetThreadPriority(GetCurrentThread(), Config.ThPriority);
SetPriorityClass(GetCurrentProcess(), Config.ThPriority == THREAD_PRIORITY_HIGHEST ? ABOVE_NORMAL_PRIORITY_CLASS : NORMAL_PRIORITY_CLASS);
nDisableSC = 1;
if (needReset == 1) {
SysReset();
}
if( UseGui )
AccBreak = 1;
DestroyWindow(gApp.hWnd);
gApp.hWnd = NULL;
if (OpenPlugins(g_TestRun.ptitle) == -1) {
CreateMainWindow(SW_SHOWNORMAL);
return;
}
if (needReset == 1) {
if(RunExe == 0)cpuExecuteBios();
//if (efile == 2)
if(!efile)efile=GetPS2ElfName(filename);
//if (efile)
loadElfFile(filename);
RunExe = 0;
efile=0;
needReset = 0;
}
// this needs to be called for every new game! (note: sometimes launching games through bios will give a crc of 0)
if( GSsetGameCRC != NULL )
GSsetGameCRC(ElfCRC, g_ZeroGSOptions);
if (run) Cpu->Execute();
}
int Slots[5] = { -1, -1, -1, -1, -1 };
void ResetMenuSlots() {
int i;
for (i=0; i<5; i++) {
if (Slots[i] == -1)
EnableMenuItem(GetSubMenu(gApp.hMenu, 0), ID_FILE_STATES_LOAD_SLOT1+i, MF_GRAYED);
else
EnableMenuItem(GetSubMenu(gApp.hMenu, 0), ID_FILE_STATES_LOAD_SLOT1+i, MF_ENABLED);
}
}
void UpdateMenuSlots() {
char str[256];
int i;
for (i=0; i<5; i++) {
sprintf (str, "sstates\\%8.8X.%3.3d", ElfCRC, i);
Slots[i] = CheckState(str);
}
}
void States_Load(int num) {
char Text[256];
int ret;
efile = 0;
RunExecute(0);
sprintf (Text, "sstates\\%8.8X.%3.3d", ElfCRC, num);
ret = LoadState(Text);
if (ret == 0)
sprintf (Text, _("*PCSX2*: Loaded State %d"), num+1);
else sprintf (Text, _("*PCSX2*: Error Loading State %d"), num+1);
StatusSet(Text);
Cpu->Execute();
}
void States_Save(int num) {
char Text[256];
int ret;
sprintf (Text, "sstates\\%8.8X.%3.3d", ElfCRC, num);
ret = SaveState(Text);
if (ret == 0)
sprintf(Text, _("*PCSX2*: Saving State %d"), num+1);
else sprintf(Text, _("*PCSX2*: Error Saving State %d"), num+1);
StatusSet(Text);
RunExecute(1);
}
void OnStates_LoadOther() {
OPENFILENAME ofn;
char szFileName[256];
char szFileTitle[256];
char szFilter[256];
memset(&szFileName, 0, sizeof(szFileName));
memset(&szFileTitle, 0, sizeof(szFileTitle));
strcpy(szFilter, _("PCSX2 State Format"));
strcatz(szFilter, "*.*;*.*");
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = gApp.hWnd;
ofn.lpstrFilter = szFilter;
ofn.lpstrCustomFilter = NULL;
ofn.nMaxCustFilter = 0;
ofn.nFilterIndex = 1;
ofn.lpstrFile = szFileName;
ofn.nMaxFile = 256;
ofn.lpstrInitialDir = NULL;
ofn.lpstrFileTitle = szFileTitle;
ofn.nMaxFileTitle = 256;
ofn.lpstrTitle = NULL;
ofn.lpstrDefExt = "EXE";
ofn.Flags = OFN_HIDEREADONLY | OFN_NOCHANGEDIR;
if (GetOpenFileName ((LPOPENFILENAME)&ofn)) {
char Text[256];
int ret;
efile = 2;
RunExecute(0);
ret = LoadState(szFileName);
if (ret == 0)
sprintf(Text, _("*PCSX2*: Saving State %s"), szFileName);
else sprintf(Text, _("*PCSX2*: Error Saving State %s"), szFileName);
StatusSet(Text);
Cpu->Execute();
}
}
void OnStates_Save1() { States_Save(0); }
void OnStates_Save2() { States_Save(1); }
void OnStates_Save3() { States_Save(2); }
void OnStates_Save4() { States_Save(3); }
void OnStates_Save5() { States_Save(4); }
char* g_pRunGSState = NULL;
void OnStates_SaveOther() {
OPENFILENAME ofn;
char szFileName[256];
char szFileTitle[256];
char szFilter[256];
memset(&szFileName, 0, sizeof(szFileName));
memset(&szFileTitle, 0, sizeof(szFileTitle));
strcpy(szFilter, _("PCSX2 State Format"));
strcatz(szFilter, "*.*;*.*");
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = gApp.hWnd;
ofn.lpstrFilter = szFilter;
ofn.lpstrCustomFilter = NULL;
ofn.nMaxCustFilter = 0;
ofn.nFilterIndex = 1;
ofn.lpstrFile = szFileName;
ofn.nMaxFile = 256;
ofn.lpstrInitialDir = NULL;
ofn.lpstrFileTitle = szFileTitle;
ofn.nMaxFileTitle = 256;
ofn.lpstrTitle = NULL;
ofn.lpstrDefExt = "EXE";
ofn.Flags = OFN_HIDEREADONLY | OFN_NOCHANGEDIR;
if (GetOpenFileName ((LPOPENFILENAME)&ofn)) {
char Text[256];
int ret;
ret = SaveState(szFileName);
if (ret == 0)
sprintf(Text, _("*PCSX2*: Loaded State %s"), szFileName);
else sprintf(Text, _("*PCSX2*: Error Loading State %s"), szFileName);
StatusSet(Text);
RunExecute(1);
}
}
TESTRUNARGS g_TestRun;
static int ParseCommandLine(char* pcmd)
{
const char* pdelim = " \t\r\n";
char* token = strtok(pcmd, pdelim);
g_TestRun.efile = 0;
while(token != NULL) {
if( _stricmp(token, "-help") == 0) {
const char* phelpmsg =
"pcsx2 [options] [file]\n\n"
"-cfg [file] {configuration file}\n"
"-efile [efile] {0 - reset, 1 - runcd (default), 2 - loadelf}\n"
"-help {display this help file}\n"
"-nogui {Don't use gui when launching}\n"
"-loadgs [file} {Loads a gsstate}\n"
"\n"
#ifdef PCSX2_DEVBUILD
"Testing Options: \n"
"\t-frame [frame] {game will run up to this frame before exiting}\n"
"\t-image [name] {path and base name of image (do not include the .ext)}\n"
"\t-jpg {save images to jpg format}\n"
"\t-log [name] {log path to save log file in}\n"
"\t-logopt [hex] {log options in hex (see debug.h) }\n"
"\t-numimages [num] {after hitting frame, this many images will be captures every 20 frames}\n"
"\t-test {Triggers testing mode (only for dev builds)}\n"
"\n"
#endif
"Load Plugins:\n"
"\t-cdvd [dllpath] {specify the dll load path of the CDVD plugin}\n"
"\t-gs [dllpath] {specify the dll load path of the GS plugin}\n"
"-pad [tsxcal] {specify to hold down on the triangle, square, circle, x, start, select buttons}\n"
"\t-spu [dllpath] {specify the dll load path of the SPU2 plugin}\n"
"\n";
printf("%s", phelpmsg);
MessageBox(NULL,phelpmsg,"Help", MB_OK);
return -1;
}
else if( _stricmp(token, "-nogui") == 0 ) {
UseGui = 0;
}
#ifdef PCSX2_DEVBUILD
else if( _stricmp(token, "-image") == 0 ) {
token = strtok(NULL, pdelim);
g_TestRun.pimagename = token;
}
else if( _stricmp(token, "-log") == 0 ) {
token = strtok(NULL, pdelim);
g_TestRun.plogname = token;
}
else if( _stricmp(token, "-logopt") == 0 ) {
token = strtok(NULL, pdelim);
if( token != NULL ) {
if( token[0] == '0' && token[1] == 'x' ) token += 2;
sscanf(token, "%x", &varLog);
}
}
else if( _stricmp(token, "-frame") == 0 ) {
token = strtok(NULL, pdelim);
if( token != NULL ) {
g_TestRun.frame = atoi(token);
}
}
else if( _stricmp(token, "-numimages") == 0 ) {
token = strtok(NULL, pdelim);
if( token != NULL ) {
g_TestRun.numimages = atoi(token);
}
}
else if( _stricmp(token, "-jpg") == 0 ) {
g_TestRun.jpgcapture = 1;
}
#endif
else if( _stricmp(token, "-pad") == 0 ) {
token = strtok(NULL, pdelim);
printf("-pad ignored\n");
}
else if( _stricmp(token, "-efile") == 0 ) {
token = strtok(NULL, pdelim);
if( token != NULL ) {
g_TestRun.efile = atoi(token);
}
}
else if( _stricmp(token, "-gs") == 0 ) {
token = strtok(NULL, pdelim);
g_TestRun.pgsdll = token;
}
else if( _stricmp(token, "-cdvd") == 0 ) {
token = strtok(NULL, pdelim);
g_TestRun.pcdvddll = token;
}
else if( _stricmp(token, "-spu") == 0 ) {
token = strtok(NULL, pdelim);
g_TestRun.pspudll = token;
}
else if( _stricmp(token, "-loadgs") == 0 ) {
token = strtok(NULL, pdelim);
g_pRunGSState = token;
}
else {
g_TestRun.ptitle = token;
printf("opening file %s\n", token);
}
if( token == NULL ) {
printf("invalid args\n");
return -1;
}
token = strtok(NULL, pdelim);
}
return 0;
}
BOOL SysLoggedSetLockPagesPrivilege ( HANDLE hProcess, BOOL bEnable);
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
char *lang;
int i;
#ifdef PCSX2_VIRTUAL_MEM
LPVOID lpMemReserved;
#endif
InitCommonControls();
pInstance=hInstance;
FirstShow=TRUE;
#ifdef PCSX2_VIRTUAL_MEM
if( !SysLoggedSetLockPagesPrivilege( GetCurrentProcess(), TRUE ) )
return -1;
lpMemReserved = VirtualAlloc(PS2MEM_BASE, 0x40000000, MEM_RESERVE, PAGE_NOACCESS);
if( lpMemReserved == NULL || lpMemReserved!= PS2MEM_BASE ) {
char str[255];
sprintf(str, "Cannot allocate mem addresses %x-%x, err: %d", PS2MEM_BASE, PS2MEM_BASE+0x40000000, GetLastError());
MessageBox(NULL, str, "SysError", MB_OK);
return -1;
}
__try
{
#endif
gApp.hInstance = hInstance;
gApp.hMenu = NULL;
gApp.hWnd = NULL;
gApp.hConsole = NULL;
#ifdef ENABLE_NLS
bindtextdomain(PACKAGE, "Langs\\");
textdomain(PACKAGE);
#endif
if (LoadConfig() == -1) {
memset(&Config, 0, sizeof(Config));
//strcpy(Config.Bios, "HLE");
strcpy(Config.BiosDir, "Bios\\");
strcpy(Config.PluginsDir, "Plugins\\");
Config.Patch = 1;
Config.Options = PCSX2_EEREC|PCSX2_VU0REC|PCSX2_VU1REC|PCSX2_COP2REC;
SysMessage(_("Pcsx2 needs to be configured"));
Pcsx2Configure(NULL);
return 0;
}
if (Config.Lang[0] == 0) {
strcpy(Config.Lang, "en_US");
}
langs = (_langs*)malloc(sizeof(_langs));
strcpy(langs[0].lang, "en_US");
InitLanguages(); i=1;
while ((lang = GetLanguageNext()) != NULL) {
langs = (_langs*)realloc(langs, sizeof(_langs)*(i+1));
strcpy(langs[i].lang, lang);
i++;
}
CloseLanguages();
langsMax = i;
if (Config.PsxOut) OpenConsole();
memset(&g_TestRun, 0, sizeof(g_TestRun));
if( lpCmdLine == NULL || *lpCmdLine == 0 )
SysPrintf("-help to see arguments\n");
else if( ParseCommandLine(lpCmdLine) == -1 ) {
return 2;
}
if( g_TestRun.pgsdll )
_snprintf(Config.GS, sizeof(Config.GS), "%s", g_TestRun.pgsdll);
if( g_TestRun.pcdvddll )
_snprintf(Config.CDVD, sizeof(Config.CDVD), "%s", g_TestRun.pcdvddll);
if( g_TestRun.pspudll )
_snprintf(Config.SPU2, sizeof(Config.SPU2), "%s", g_TestRun.pspudll);
if (SysInit() == -1) return 1;
#ifdef PCSX2_DEVBUILD
if( g_TestRun.enabled || g_TestRun.ptitle != NULL ) {
// run without ui
UseGui = 0;
_snprintf(filename, sizeof(filename), "%s", g_TestRun.ptitle);
needReset = 1;
efile = g_TestRun.efile;
RunExecute(1);
SysClose();
return 0; // success!
}
#endif
#ifdef PCSX2_DEVBUILD
if( g_pRunGSState ) {
LoadGSState(g_pRunGSState);
SysClose();
return 0;
}
#endif
CreateMainWindow(nCmdShow);
if( Config.PsxOut ) {
// output the help commands
SysPrintf("\tF1 - save state\n");
SysPrintf("\t(Shift +) F2 - cycle states\n");
SysPrintf("\tF3 - load state\n");
#ifdef PCSX2_DEVBUILD
SysPrintf("\tF10 - dump performance counters\n");
SysPrintf("\tF11 - save GS state\n");
SysPrintf("\tF12 - dump hardware registers\n");
#endif
}
LoadPatch("default");
// needReset = 1;
// efile = 0;
// RunExecute(1);
RunGui();
#ifdef PCSX2_VIRTUAL_MEM
}
__except(SysPageFaultExceptionFilter(GetExceptionInformation()))
{
}
VirtualFree(PS2MEM_BASE, 0, MEM_RELEASE);
#endif
return 0;
}
void RunGui() {
MSG msg;
for (;;) {
if(PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
Sleep(10);
}
}
static int shiftkey = 0;
void CALLBACK KeyEvent(keyEvent* ev)
{
if (ev == NULL) return;
if (ev->event == KEYRELEASE) {
switch (ev->key) {
case VK_SHIFT: shiftkey = 0; break;
}
GSkeyEvent(ev); return;
}
if (ev->event != KEYPRESS)
return;
//some pad plugins don't give a key released event for shift, so this is needed
//shiftkey = GetKeyState(VK_SHIFT)&0x8000;
//Well SSXPad breaks with your code, thats why my code worked and your makes reg dumping impossible
//So i suggest you fix the plugins that dont.
switch (ev->key) {
case VK_SHIFT: shiftkey = 1; break;
case VK_F1: ProcessFKeys(1, shiftkey); break;
case VK_F2: ProcessFKeys(2, shiftkey); break;
case VK_F3: ProcessFKeys(3, shiftkey); break;
case VK_F4: ProcessFKeys(4, shiftkey); break;
case VK_F5: ProcessFKeys(5, shiftkey); break;
case VK_F6: ProcessFKeys(6, shiftkey); break;
case VK_F7: ProcessFKeys(7, shiftkey); break;
case VK_F8: ProcessFKeys(8, shiftkey); break;
case VK_F9: ProcessFKeys(9, shiftkey); break;
case VK_F10: ProcessFKeys(10, shiftkey); break;
case VK_F11: ProcessFKeys(11, shiftkey); break;
case VK_F12: ProcessFKeys(12, shiftkey); break;
case VK_ESCAPE:
#ifdef PCSX2_DEVBUILD
if( g_SaveGSStream >= 3 ) {
// gs state
g_SaveGSStream = 4;
break;
}
#endif
ClosePlugins();
if( !UseGui ) {
// not using GUI and user just quit, so exit
exit(0);
}
CreateMainWindow(SW_SHOWNORMAL);
RunGui();
nDisableSC = 0;
break;
default:
GSkeyEvent(ev);
break;
}
}
#ifdef PCSX2_DEVBUILD
BOOL APIENTRY LogProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) {
int i;
switch (message) {
case WM_INITDIALOG:
for (i=0; i<32; i++)
if (varLog & (1<<i))
CheckDlgButton(hDlg, IDC_LOG+i, TRUE);
if (Log) CheckDlgButton(hDlg, IDC_LOGS, TRUE);
return TRUE;
case WM_COMMAND:
if (LOWORD(wParam) == IDOK) {
for (i=0; i<32; i++) {
int ret = Button_GetCheck(GetDlgItem(hDlg, IDC_LOG+i));
if (ret) varLog|= 1<<i;
else varLog&=~(1<<i);
}
if (Button_GetCheck(GetDlgItem(hDlg, IDC_LOGS)))
Log = 1;
else Log = 0;
SaveConfig();
EndDialog(hDlg, TRUE);
}
return TRUE;
}
return FALSE;
}
#endif
BOOL APIENTRY AdvancedProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) {
//char str[256];
switch (message) {
case WM_INITDIALOG:
//CheckDlgButton(hDlg, IDC_REGCACHING, CHECK_REGCACHING ? TRUE : FALSE);
//if (Config.SafeCnts) CheckDlgButton(hDlg, IDC_SAFECOUNTERS, TRUE);
return TRUE;
case WM_COMMAND:
if (LOWORD(wParam) == IDOK) {
//Config.Options &= ~PCSX2_REGCACHING;
//Config.Options |= IsDlgButtonChecked(hDlg, IDC_REGCACHING) ? PCSX2_REGCACHING : 0;
SaveConfig();
EndDialog(hDlg, TRUE);
} else
if (LOWORD(wParam) == IDCANCEL) {
EndDialog(hDlg, FALSE);
} else
if (LOWORD(wParam) == IDC_ADVRESET) {
CheckDlgButton(hDlg, IDC_REGCACHING, FALSE);
CheckDlgButton(hDlg, IDC_SAFECOUNTERS, FALSE);
CheckDlgButton(hDlg, IDC_SPU2HACK, FALSE);
} else
return TRUE;
}
return FALSE;
}
BOOL APIENTRY HacksProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) {
//char str[256];
switch (message) {
case WM_INITDIALOG:
if(Config.Hacks & 1) CheckDlgButton(hDlg, IDC_SYNCHACK, TRUE);
if(Config.Hacks & 2) CheckDlgButton(hDlg, IDC_ABSHACK, TRUE);
if(Config.Hacks & 4) CheckDlgButton(hDlg, IDC_SOUNDHACK, TRUE);
return TRUE;
case WM_COMMAND:
if (LOWORD(wParam) == IDOK) {
Config.Hacks = 0;
Config.Hacks |= IsDlgButtonChecked(hDlg, IDC_SYNCHACK) ? 1 : 0;
Config.Hacks |= IsDlgButtonChecked(hDlg, IDC_ABSHACK) ? 2 : 0;
Config.Hacks |= IsDlgButtonChecked(hDlg, IDC_SOUNDHACK) ? 4 : 0;
SaveConfig();
EndDialog(hDlg, TRUE);
} else
if (LOWORD(wParam) == IDCANCEL) {
EndDialog(hDlg, FALSE);
} else
return TRUE;
}
return FALSE;
}
HBITMAP hbitmap_background;//the background image
LRESULT WINAPI MainWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
int remoteDebugBios=0;
switch (msg) {
case WM_CREATE:
return TRUE;
case WM_PAINT:
{
BITMAP bm;
PAINTSTRUCT ps;
HDC hdc = BeginPaint(gApp.hWnd, &ps);
HDC hdcMem = CreateCompatibleDC(hdc);
HBITMAP hbmOld = (HBITMAP)SelectObject(hdcMem, hbitmap_background);
GetObject(hbitmap_background, sizeof(bm), &bm);
// BitBlt(hdc, 0, 0, bm.bmWidth, bm.bmHeight, hdcMem, 0, 0, SRCCOPY);
BitBlt(hdc, ps.rcPaint.left, ps.rcPaint.top,
ps.rcPaint.right-ps.rcPaint.left+1,
ps.rcPaint.bottom-ps.rcPaint.top+1,
hdcMem, ps.rcPaint.left, ps.rcPaint.top, SRCCOPY);
SelectObject(hdcMem, hbmOld);
DeleteDC(hdcMem);
EndPaint(gApp.hWnd, &ps);
}
return TRUE;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case ID_HACKS:
DialogBox(gApp.hInstance, MAKEINTRESOURCE(IDD_HACKS), hWnd, (DLGPROC)HacksProc);
return TRUE;
case ID_CHEAT_FINDER_SHOW:
ShowFinder(pInstance,hWnd);
return TRUE;
case ID_CHEAT_BROWSER_SHOW:
ShowCheats(pInstance,hWnd);
return TRUE;
case ID_FILE_EXIT:
SysClose();
PostQuitMessage(0);
exit(0);
return TRUE;
case ID_FILEOPEN:
if (Open_File_Proc(filename) == FALSE) return TRUE;
needReset = 1;
efile = 1;
RunExecute(1);
return TRUE;
case ID_RUN_EXECUTE:
if(needReset == 1) RunExe = 1;
efile = 0;
RunExecute(1);
return TRUE;
case ID_FILE_RUNCD:
needReset = 1;
efile = 0;
RunExecute(1);
return TRUE;
case ID_RUN_RESET:
ResetPlugins();
needReset = 1;
efile = 0;
return TRUE;
//2002-09-20 (Florin)
case ID_RUN_CMDLINE:
DialogBox(gApp.hInstance, MAKEINTRESOURCE(IDD_CMDLINE), hWnd, (DLGPROC)CmdlineProc);
return TRUE;
//-------------------
case ID_PATCHBROWSER:
DialogBox(gApp.hInstance, MAKEINTRESOURCE(IDD_PATCHBROWSER), hWnd, (DLGPROC)PatchBDlgProc);
return TRUE;
case ID_CONFIG_CONFIGURE:
Pcsx2Configure(hWnd);
ReleasePlugins();
LoadPlugins();
return TRUE;
case ID_CONFIG_GRAPHICS:
if (GSconfigure) GSconfigure();
return TRUE;
case ID_CONFIG_CONTROLLERS:
if (PAD1configure) PAD1configure();
if (PAD2configure) {
if (strcmp(Config.PAD1, Config.PAD2))PAD2configure();
}
return TRUE;
case ID_CONFIG_SOUND:
if (SPU2configure) SPU2configure();
return TRUE;
case ID_CONFIG_CDVDROM:
if (CDVDconfigure) CDVDconfigure();
return TRUE;
case ID_CONFIG_DEV9:
if (DEV9configure) DEV9configure();
return TRUE;
case ID_CONFIG_USB:
if (USBconfigure) USBconfigure();
return TRUE;
case ID_CONFIG_FW:
if (FWconfigure) FWconfigure();
return TRUE;
case ID_FILE_STATES_LOAD_SLOT1: States_Load(0); return TRUE;
case ID_FILE_STATES_LOAD_SLOT2: States_Load(1); return TRUE;
case ID_FILE_STATES_LOAD_SLOT3: States_Load(2); return TRUE;
case ID_FILE_STATES_LOAD_SLOT4: States_Load(3); return TRUE;
case ID_FILE_STATES_LOAD_SLOT5: States_Load(4); return TRUE;
case ID_FILE_STATES_LOAD_OTHER: OnStates_LoadOther(); return TRUE;
case ID_FILE_STATES_SAVE_SLOT1: States_Save(0); return TRUE;
case ID_FILE_STATES_SAVE_SLOT2: States_Save(1); return TRUE;
case ID_FILE_STATES_SAVE_SLOT3: States_Save(2); return TRUE;
case ID_FILE_STATES_SAVE_SLOT4: States_Save(3); return TRUE;
case ID_FILE_STATES_SAVE_SLOT5: States_Save(4); return TRUE;
case ID_FILE_STATES_SAVE_OTHER: OnStates_SaveOther(); return TRUE;
case ID_CONFIG_CPU:
DialogBox(gApp.hInstance, MAKEINTRESOURCE(IDD_CPUDLG), hWnd, (DLGPROC)CpuDlgProc);
return TRUE;
case ID_CONFIG_ADVANCED:
DialogBox(gApp.hInstance, MAKEINTRESOURCE(IDD_ADVANCED), hWnd, (DLGPROC)AdvancedProc);
return TRUE;
#ifdef PCSX2_DEVBUILD
case ID_DEBUG_LOGGING:
DialogBox(gApp.hInstance, MAKEINTRESOURCE(IDD_LOGGING), hWnd, (DLGPROC)LogProc);
return TRUE;
#endif
case ID_HELP_ABOUT:
DialogBox(gApp.hInstance, MAKEINTRESOURCE(ABOUT_DIALOG), hWnd, (DLGPROC)AboutDlgProc);
return TRUE;
case ID_HELP_HELP:
//system("help\\index.html");
system("compat_list\\compat_list.html");
return TRUE;
case ID_CONFIG_MEMCARDS:
DialogBox(gApp.hInstance, MAKEINTRESOURCE(IDD_MCDCONF), hWnd, (DLGPROC)ConfigureMcdsDlgProc);
SaveConfig();
return TRUE;
case ID_PROCESSLOW:
Config.ThPriority = THREAD_PRIORITY_LOWEST;
SaveConfig();
CheckMenuItem(gApp.hMenu,ID_PROCESSLOW,MF_CHECKED);
CheckMenuItem(gApp.hMenu,ID_PROCESSNORMAL,MF_UNCHECKED);
CheckMenuItem(gApp.hMenu,ID_PROCESSHIGH,MF_UNCHECKED);
return TRUE;
case ID_PROCESSNORMAL:
Config.ThPriority = THREAD_PRIORITY_NORMAL;
SaveConfig();
CheckMenuItem(gApp.hMenu,ID_PROCESSNORMAL,MF_CHECKED);
CheckMenuItem(gApp.hMenu,ID_PROCESSLOW,MF_UNCHECKED);
CheckMenuItem(gApp.hMenu,ID_PROCESSHIGH,MF_UNCHECKED);
return TRUE;
case ID_PROCESSHIGH:
Config.ThPriority = THREAD_PRIORITY_HIGHEST;
SaveConfig();
CheckMenuItem(gApp.hMenu,ID_PROCESSHIGH,MF_CHECKED);
CheckMenuItem(gApp.hMenu,ID_PROCESSNORMAL,MF_UNCHECKED);
CheckMenuItem(gApp.hMenu,ID_PROCESSLOW,MF_UNCHECKED);
return TRUE;
case ID_CONSOLE:
if(Config.PsxOut)
{
CheckMenuItem(gApp.hMenu,ID_CONSOLE,MF_UNCHECKED);
CloseConsole();
Config.PsxOut=0;
SaveConfig();
}
else
{
CheckMenuItem(gApp.hMenu,ID_CONSOLE,MF_CHECKED);
OpenConsole();
Config.PsxOut=1;
SaveConfig();
}
return TRUE;
case ID_PATCHES:
if(Config.Patch)
{
CheckMenuItem(gApp.hMenu,ID_PATCHES,MF_UNCHECKED);
Config.Patch=0;
SaveConfig();
}
else
{
CheckMenuItem(gApp.hMenu,ID_PATCHES,MF_CHECKED);
Config.Patch=1;
SaveConfig();
}
return TRUE;
default:
if (LOWORD(wParam) >= ID_LANGS && LOWORD(wParam) <= (ID_LANGS + langsMax)) {
AccBreak = 1;
DestroyWindow(gApp.hWnd);
ChangeLanguage(langs[LOWORD(wParam) - ID_LANGS].lang);
CreateMainWindow(SW_NORMAL);
return TRUE;
}
}
break;
case WM_DESTROY:
if (!AccBreak) {
SysClose();
DeleteObject(hbitmap_background);
PostQuitMessage(0);
exit(0);
} else AccBreak = 0;
return TRUE;
case WM_SYSCOMMAND:
if( nDisableSC && (wParam== SC_SCREENSAVE || wParam == SC_MONITORPOWER) ) {
return FALSE;
}
else
return DefWindowProc(hWnd, msg, wParam, lParam);
break;
case WM_QUIT:
if (Config.PsxOut) CloseConsole();
exit(0);
break;
default:
return DefWindowProc(hWnd, msg, wParam, lParam);
}
return FALSE;
}
#define _ADDSUBMENU(menu, menun, string) \
submenu[menun] = CreatePopupMenu(); \
AppendMenu(menu, MF_STRING | MF_POPUP, (UINT)submenu[menun], string);
#define ADDSUBMENU(menun, string) \
_ADDSUBMENU(gApp.hMenu, menun, string);
#define ADDSUBMENUS(submn, menun, string) \
submenu[menun] = CreatePopupMenu(); \
InsertMenu(submenu[submn], 0, MF_BYPOSITION | MF_STRING | MF_POPUP, (UINT)submenu[menun], string);
#define ADDMENUITEM(menun, string, id) \
item.fType = MFT_STRING; \
item.fMask = MIIM_STATE | MIIM_TYPE | MIIM_ID; \
item.fState = MFS_ENABLED; \
item.wID = id; \
sprintf(buf, string); \
InsertMenuItem(submenu[menun], 0, TRUE, &item);
#define ADDMENUITEMC(menun, string, id) \
item.fType = MFT_STRING; \
item.fMask = MIIM_STATE | MIIM_TYPE | MIIM_ID; \
item.fState = MFS_ENABLED | MFS_CHECKED; \
item.wID = id; \
sprintf(buf, string); \
InsertMenuItem(submenu[menun], 0, TRUE, &item);
#define ADDSEPARATOR(menun) \
item.fMask = MIIM_TYPE; \
item.fType = MFT_SEPARATOR; \
InsertMenuItem(submenu[menun], 0, TRUE, &item);
void CreateMainMenu() {
MENUITEMINFO item;
HMENU submenu[5];
char buf[256];
int i;
item.cbSize = sizeof(MENUITEMINFO);
item.dwTypeData = buf;
item.cch = 256;
gApp.hMenu = CreateMenu();
//submenu = CreatePopupMenu();
//AppendMenu(gApp.hMenu, MF_STRING | MF_POPUP, (UINT)submenu, _("&File"));
ADDSUBMENU(0, _("&File"));
ADDMENUITEM(0, _("E&xit"), ID_FILE_EXIT);
ADDSEPARATOR(0);
ADDSUBMENUS(0, 1, _("&States"));
ADDSEPARATOR(0);
ADDMENUITEM(0, _("&Open ELF File"), ID_FILEOPEN);
ADDMENUITEM(0, _("&Run CD/DVD"), ID_FILE_RUNCD);
ADDSUBMENUS(1, 3, _("&Save"));
ADDSUBMENUS(1, 2, _("&Load"));
ADDMENUITEM(2, _("&Other..."), ID_FILE_STATES_LOAD_OTHER);
ADDMENUITEM(2, _("Slot &5"), ID_FILE_STATES_LOAD_SLOT5);
ADDMENUITEM(2, _("Slot &4"), ID_FILE_STATES_LOAD_SLOT4);
ADDMENUITEM(2, _("Slot &3"), ID_FILE_STATES_LOAD_SLOT3);
ADDMENUITEM(2, _("Slot &2"), ID_FILE_STATES_LOAD_SLOT2);
ADDMENUITEM(2, _("Slot &1"), ID_FILE_STATES_LOAD_SLOT1);
ADDMENUITEM(3, _("&Other..."), ID_FILE_STATES_SAVE_OTHER);
ADDMENUITEM(3, _("Slot &5"), ID_FILE_STATES_SAVE_SLOT5);
ADDMENUITEM(3, _("Slot &4"), ID_FILE_STATES_SAVE_SLOT4);
ADDMENUITEM(3, _("Slot &3"), ID_FILE_STATES_SAVE_SLOT3);
ADDMENUITEM(3, _("Slot &2"), ID_FILE_STATES_SAVE_SLOT2);
ADDMENUITEM(3, _("Slot &1"), ID_FILE_STATES_SAVE_SLOT1);
ADDSUBMENU(0, _("&Run"));
ADDSUBMENUS(0, 1, _("&Process Priority"));
ADDMENUITEM(1, _("&Low"), ID_PROCESSLOW );
ADDMENUITEM(1, _("High"), ID_PROCESSHIGH);
ADDMENUITEM(1, _("Normal"), ID_PROCESSNORMAL);
ADDMENUITEM(0,_("&Arguments"), ID_RUN_CMDLINE);
ADDMENUITEM(0,_("Re&set"), ID_RUN_RESET);
ADDMENUITEM(0,_("E&xecute"), ID_RUN_EXECUTE);
ADDSUBMENU(0,_("&Config"));
#ifdef PCSX2_DEVBUILD
// ADDMENUITEM(0,_("&Advanced"), ID_CONFIG_ADVANCED);
#endif
ADDMENUITEM(0,_("Speed &Hacks"), ID_HACKS);
ADDMENUITEM(0,_("&Patches"), ID_PATCHBROWSER);
ADDMENUITEM(0,_("C&pu"), ID_CONFIG_CPU);
ADDMENUITEM(0,_("&Memcards"), ID_CONFIG_MEMCARDS);
ADDSEPARATOR(0);
ADDMENUITEM(0,_("Fire&Wire"), ID_CONFIG_FW);
ADDMENUITEM(0,_("U&SB"), ID_CONFIG_USB);
ADDMENUITEM(0,_("D&ev9"), ID_CONFIG_DEV9);
ADDMENUITEM(0,_("C&dvdrom"), ID_CONFIG_CDVDROM);
ADDMENUITEM(0,_("&Sound"), ID_CONFIG_SOUND);
ADDMENUITEM(0,_("C&ontrollers"), ID_CONFIG_CONTROLLERS);
ADDMENUITEM(0,_("&Graphics"), ID_CONFIG_GRAPHICS);
ADDSEPARATOR(0);
ADDMENUITEM(0,_("&Configure"), ID_CONFIG_CONFIGURE);
ADDSUBMENU(0,_("&Language"));
for (i=langsMax-1; i>=0; i--) {
if (!strcmp(Config.Lang, langs[i].lang)) {
ADDMENUITEMC(0,ParseLang(langs[i].lang), ID_LANGS + i);
} else {
ADDMENUITEM(0,ParseLang(langs[i].lang), ID_LANGS + i);
}
}
#ifdef PCSX2_DEVBUILD
ADDSUBMENU(0, _("&Debug"));
ADDMENUITEM(0,_("&Logging"), ID_DEBUG_LOGGING);
#endif
ADDSUBMENU(0, _("&Misc"));
ADDMENUITEM(0,_("Enable &Patches"), ID_PATCHES);
ADDMENUITEM(0,_("Enable &Console"), ID_CONSOLE);
ADDSEPARATOR(0);
ADDMENUITEM(0,_("Patch &Finder..."), ID_CHEAT_FINDER_SHOW);
ADDMENUITEM(0,_("Patch &Browser..."), ID_CHEAT_BROWSER_SHOW);
ADDSUBMENU(0, _("&Help"));
ADDMENUITEM(0,_("&Compatibility List..."), ID_HELP_HELP);
ADDMENUITEM(0,_("&About..."), ID_HELP_ABOUT);
#ifndef PCSX2_DEVBUILD
EnableMenuItem(GetSubMenu(gApp.hMenu, 4), ID_DEBUG_LOGGING, MF_GRAYED);
#endif
}
void CreateMainWindow(int nCmdShow) {
WNDCLASS wc;
HWND hWnd;
char buf[256];
char COMPILER[20]="";
BITMAP bm;
RECT rect;
int w, h;
#ifdef _MSC_VER
sprintf(COMPILER, "(VC%d)", (_MSC_VER+100)/200);//hacky:) works for VC6 & VC.NET
#elif __BORLANDC__
sprintf(COMPILER, "(BC)");
#endif
/* Load Background Bitmap from the ressource */
hbitmap_background = LoadBitmap(GetModuleHandle(NULL), MAKEINTRESOURCE(SPLASH_LOGO));
wc.lpszClassName = "PCSX2 Main";
wc.lpfnWndProc = MainWndProc;
wc.style = 0;
wc.hInstance = gApp.hInstance;
wc.hIcon = LoadIcon(gApp.hInstance, MAKEINTRESOURCE(IDI_ICON));
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)(COLOR_MENUTEXT);
wc.lpszMenuName = 0;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
RegisterClass(&wc);
GetObject(hbitmap_background, sizeof(bm), &bm);
{
#ifdef PCSX2_VIRTUAL_MEM
const char* pvm = "VM";
#else
const char* pvm = "non VM";
#endif
#ifdef PCSX2_DEVBUILD
sprintf(buf, _("PCSX2 %s Watermoose - %s Compile Date - %s %s"), PCSX2_VERSION, pvm, COMPILEDATE, COMPILER);
#else
sprintf(buf, _("PCSX2 %s Watermoose - %s"), PCSX2_VERSION, pvm);
#endif
}
hWnd = CreateWindow("PCSX2 Main",
buf, WS_OVERLAPPED | WS_SYSMENU,
20, 20, 320, 240, NULL, NULL,
gApp.hInstance, NULL);
gApp.hWnd = hWnd;
ResetMenuSlots();
CreateMainMenu();
SetMenu(gApp.hWnd, gApp.hMenu);
if(Config.ThPriority==THREAD_PRIORITY_NORMAL) CheckMenuItem(gApp.hMenu,ID_PROCESSNORMAL,MF_CHECKED);
if(Config.ThPriority==THREAD_PRIORITY_HIGHEST) CheckMenuItem(gApp.hMenu,ID_PROCESSHIGH,MF_CHECKED);
if(Config.ThPriority==THREAD_PRIORITY_LOWEST) CheckMenuItem(gApp.hMenu,ID_PROCESSLOW,MF_CHECKED);
if(Config.PsxOut) CheckMenuItem(gApp.hMenu,ID_CONSOLE,MF_CHECKED);
if(Config.Patch) CheckMenuItem(gApp.hMenu,ID_PATCHES,MF_CHECKED);
hStatusWnd = CreateStatusWindow(WS_CHILD | WS_VISIBLE, "", hWnd, 100);
sprintf(buf, "PCSX2 %s", PCSX2_VERSION);
StatusSet(buf);
w = bm.bmWidth; h = bm.bmHeight;
GetWindowRect(hStatusWnd, &rect);
h+= rect.bottom - rect.top;
GetMenuItemRect(hWnd, gApp.hMenu, 0, &rect);
h+= rect.bottom - rect.top;
MoveWindow(hWnd, 20, 20, w, h, TRUE);
DestroyWindow(hStatusWnd);
hStatusWnd = CreateStatusWindow(WS_CHILD | WS_VISIBLE, "", hWnd, 100);
sprintf(buf, "F1 - save, F2 - next state, Shift+F2 - prev state, F3 - load, F8 - snapshot", PCSX2_VERSION);
StatusSet(buf);
ShowWindow(hWnd, nCmdShow);
SetWindowPos(hWnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
}
BOOL Open_File_Proc(char * filename) {
OPENFILENAME ofn;
char szFileName[ 256 ];
char szFileTitle[ 256 ];
char * filter = "ELF Files (*.ELF)\0*.ELF\0ALL Files (*.*)\0*.*\0";
memset( &szFileName, 0, sizeof( szFileName ) );
memset( &szFileTitle, 0, sizeof( szFileTitle ) );
ofn.lStructSize = sizeof( OPENFILENAME );
ofn.hwndOwner = gApp.hWnd;
ofn.lpstrFilter = filter;
ofn.lpstrCustomFilter = NULL;
ofn.nMaxCustFilter = 0;
ofn.nFilterIndex = 1;
ofn.lpstrFile = szFileName;
ofn.nMaxFile = 256;
ofn.lpstrInitialDir = NULL;
ofn.lpstrFileTitle = szFileTitle;
ofn.nMaxFileTitle = 256;
ofn.lpstrTitle = NULL;
ofn.lpstrDefExt = "ELF";
ofn.Flags = OFN_FILEMUSTEXIST | OFN_HIDEREADONLY | OFN_NOCHANGEDIR;
if (GetOpenFileName(&ofn)) {
struct stat buf;
if (stat(szFileName, &buf) != 0) {
return FALSE;
}
strcpy(filename, szFileName);
return TRUE;
}
return FALSE;
}
//2002-09-20 (Florin)
BOOL APIENTRY CmdlineProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_INITDIALOG:
SetWindowText(hDlg, _("Program arguments"));
Button_SetText(GetDlgItem(hDlg, IDOK), _("OK"));
Button_SetText(GetDlgItem(hDlg, IDCANCEL), _("Cancel"));
Static_SetText(GetDlgItem(hDlg, IDC_TEXT), _("Fill in the command line arguments for opened program:"));
Static_SetText(GetDlgItem(hDlg, IDC_TIP), _("Tip: If you don't know what to write\nleave it blank"));
SetDlgItemText(hDlg, IDC_CMDLINE, args);
return TRUE;
case WM_COMMAND:
if (LOWORD(wParam) == IDOK)
{
char tmp[256];
GetDlgItemText(hDlg, IDC_CMDLINE, tmp, 256);
ZeroMemory(args, 256);
strcpy(args, tmp);
args[255]=0;
EndDialog(hDlg, TRUE);
} else if (LOWORD(wParam) == IDCANCEL) {
EndDialog(hDlg, TRUE);
}
return TRUE;
}
return FALSE;
}
WIN32_FIND_DATA lFindData;
HANDLE lFind;
int lFirst;
void InitLanguages() {
lFind = FindFirstFile("Langs\\*", &lFindData);
lFirst = 1;
}
char *GetLanguageNext() {
for (;;) {
if (!strcmp(lFindData.cFileName, ".")) {
if (FindNextFile(lFind, &lFindData) == FALSE)
return NULL;
continue;
}
if (!strcmp(lFindData.cFileName, "..")) {
if (FindNextFile(lFind, &lFindData) == FALSE)
return NULL;
continue;
}
break;
}
if (lFirst == 0) {
if (FindNextFile(lFind, &lFindData) == FALSE)
return NULL;
} else lFirst = 0;
if (lFind==INVALID_HANDLE_VALUE) return NULL;
return lFindData.cFileName;
}
void CloseLanguages() {
if (lFind!=INVALID_HANDLE_VALUE) FindClose(lFind);
}
void ChangeLanguage(char *lang) {
strcpy(Config.Lang, lang);
SaveConfig();
LoadConfig();
}
//-------------------
static int sinit=0;
int SysInit() {
CreateDirectory(MEMCARDS_DIR, NULL);
CreateDirectory(SSTATES_DIR, NULL);
#ifdef EMU_LOG
CreateDirectory(LOGS_DIR, NULL);
#ifdef PCSX2_DEVBUILD
if( g_TestRun.plogname != NULL )
emuLog = fopen(g_TestRun.plogname, "w");
if( emuLog == NULL )
emuLog = fopen(LOGS_DIR "\\emuLog.txt","w");
#endif
if( emuLog != NULL )
setvbuf(emuLog, NULL, _IONBF, 0);
#endif
if (cpuInit() == -1) return -1;
while (LoadPlugins() == -1) {
if (Pcsx2Configure(NULL) == FALSE) {
exit(1);
}
}
sinit=1;
return 0;
}
void SysReset() {
if (sinit == 0) return;
StatusSet(_("Resetting..."));
cpuReset();
StatusSet(_("Ready"));
}
void SysClose() {
if (sinit == 0) return;
cpuShutdown();
ReleasePlugins();
sinit=0;
}
int concolors[] = {
0,
FOREGROUND_RED,
FOREGROUND_GREEN,
FOREGROUND_GREEN | FOREGROUND_RED,
FOREGROUND_BLUE,
FOREGROUND_RED | FOREGROUND_BLUE,
FOREGROUND_RED | FOREGROUND_GREEN,
FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE
};
void SysPrintf(char *fmt, ...) {
va_list list;
char msg[512];
char *ptr;
DWORD tmp;
int len, s;
int i, j;
va_start(list,fmt);
_vsnprintf(msg,511,fmt,list);
msg[511] = '\0';
va_end(list);
if (Config.PsxOut == 0) {
#ifdef EMU_LOG
#ifndef LOG_STDOUT
if (emuLog != NULL && !(varLog & 0x80000000)) {
fprintf(emuLog, "%s", msg);
}
#endif
#endif
return;
}
ptr = msg; len = strlen(msg);
for (i=0, j=0; i<len; i++, j++) {
if (ptr[j] == '\033') {
ptr[j] = 0;
WriteConsole(gApp.hConsole, ptr, (DWORD)strlen(ptr), &tmp, 0);
#ifdef EMU_LOG
#ifndef LOG_STDOUT
if (emuLog != NULL && !(varLog & 0x80000000)) {
fprintf(emuLog, "%s", ptr);
}
#endif
#endif
if (ptr[j+2] == '0') {
SetConsoleTextAttribute(gApp.hConsole, 7);
s = 4;
} else {
SetConsoleTextAttribute(gApp.hConsole, 7);
s = 5;
}
ptr+= j+s;
j = 0;
}
}
#ifdef EMU_LOG
#ifndef LOG_STDOUT
if (emuLog != NULL && !(varLog & 0x80000000))
fprintf(emuLog, "%s", ptr);
#endif
#endif
WriteConsole(gApp.hConsole, ptr, (DWORD)strlen(ptr), &tmp, 0);
}
void SysMessage(char *fmt, ...) {
va_list list;
char tmp[512];
va_start(list,fmt);
_vsnprintf(tmp,511,fmt,list);
tmp[511] = '\0';
va_end(list);
MessageBox(0, tmp, _("Pcsx2 Msg"), 0);
}
void SysUpdate() {
KeyEvent(PAD1keyEvent()); //Only need 1 as its used for windows keys only
KeyEvent(PAD2keyEvent());
}
void SysRunGui() {
RunGui();
}
static char *err = N_("Error Loading Symbol");
static int errval;
void *SysLoadLibrary(char *lib) {
return LoadLibrary(lib);
}
void *SysLoadSym(void *lib, char *sym) {
void *tmp = GetProcAddress((HINSTANCE)lib, sym);
if (tmp == NULL) errval = 1;
else errval = 0;
return tmp;
}
char *SysLibError() {
if (errval) { errval = 0; return _(err); }
return NULL;
}
void SysCloseLibrary(void *lib) {
FreeLibrary((HINSTANCE)lib);
}
void *SysMmap(uptr base, u32 size) {
void *mem;
mem = VirtualAlloc((void*)base, size, MEM_RESERVE, PAGE_EXECUTE_READWRITE);
mem = VirtualAlloc((void*)mem, size, MEM_COMMIT , PAGE_EXECUTE_READWRITE);
return mem;
}
void SysMunmap(uptr base, u32 size) {
VirtualFree((void*)base, size, MEM_DECOMMIT);
VirtualFree((void*)base, 0, MEM_RELEASE);
}
#ifdef PCSX2_VIRTUAL_MEM
// virtual memory/privileges
#include "ntsecapi.h"
static wchar_t s_szUserName[255];
LRESULT WINAPI UserNameProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {
switch(uMsg) {
case WM_INITDIALOG:
SetWindowPos(hDlg, HWND_TOPMOST, 200, 100, 0, 0, SWP_NOSIZE);
return TRUE;
case WM_COMMAND:
switch(wParam) {
case IDOK:
{
wchar_t str[255];
GetWindowTextW(GetDlgItem(hDlg, IDC_USER_NAME), str, 255);
swprintf(s_szUserName, 255, L"%S", str);
EndDialog(hDlg, TRUE );
return TRUE;
}
case IDCANCEL:
EndDialog(hDlg, FALSE );
return TRUE;
}
break;
}
return FALSE;
}
BOOL InitLsaString(
PLSA_UNICODE_STRING pLsaString,
LPCWSTR pwszString
)
{
DWORD dwLen = 0;
if (NULL == pLsaString)
return FALSE;
if (NULL != pwszString)
{
dwLen = wcslen(pwszString);
if (dwLen > 0x7ffe) // String is too large
return FALSE;
}
// Store the string.
pLsaString->Buffer = (WCHAR *)pwszString;
pLsaString->Length = (USHORT)dwLen * sizeof(WCHAR);
pLsaString->MaximumLength= (USHORT)(dwLen+1) * sizeof(WCHAR);
return TRUE;
}
PLSA_TRANSLATED_SID2 GetSIDInformation (LPWSTR AccountName,LSA_HANDLE PolicyHandle)
{
LSA_UNICODE_STRING lucName;
PLSA_TRANSLATED_SID2 ltsTranslatedSID;
PLSA_REFERENCED_DOMAIN_LIST lrdlDomainList;
//LSA_TRUST_INFORMATION myDomain;
NTSTATUS ntsResult;
PWCHAR DomainString = NULL;
// Initialize an LSA_UNICODE_STRING with the name.
if (!InitLsaString(&lucName, AccountName))
{
wprintf(L"Failed InitLsaString\n");
return NULL;
}
ntsResult = LsaLookupNames2(
PolicyHandle, // handle to a Policy object
0,
1, // number of names to look up
&lucName, // pointer to an array of names
&lrdlDomainList, // receives domain information
<sTranslatedSID // receives relative SIDs
);
if (0 != ntsResult)
{
wprintf(L"Failed LsaLookupNames - %lu \n",
LsaNtStatusToWinError(ntsResult));
return NULL;
}
// Get the domain the account resides in.
// myDomain = lrdlDomainList->Domains[ltsTranslatedSID->DomainIndex];
// DomainString = (PWCHAR) LocalAlloc(LPTR, myDomain.Name.Length + 1);
// wcsncpy(DomainString, myDomain.Name.Buffer, myDomain.Name.Length);
// Display the relative Id.
// wprintf(L"Relative Id is %lu in domain %ws.\n",
// ltsTranslatedSID->RelativeId,
// DomainString);
LsaFreeMemory(lrdlDomainList);
return ltsTranslatedSID;
}
BOOL AddPrivileges(PSID AccountSID, LSA_HANDLE PolicyHandle, BOOL bAdd)
{
LSA_UNICODE_STRING lucPrivilege;
NTSTATUS ntsResult;
// Create an LSA_UNICODE_STRING for the privilege name(s).
if (!InitLsaString(&lucPrivilege, L"SeLockMemoryPrivilege"))
{
wprintf(L"Failed InitLsaString\n");
return FALSE;
}
if( bAdd ) {
ntsResult = LsaAddAccountRights(
PolicyHandle, // An open policy handle.
AccountSID, // The target SID.
&lucPrivilege, // The privilege(s).
1 // Number of privileges.
);
}
else {
ntsResult = LsaRemoveAccountRights(
PolicyHandle, // An open policy handle.
AccountSID, // The target SID
FALSE,
&lucPrivilege, // The privilege(s).
1 // Number of privileges.
);
}
if (ntsResult == 0)
{
wprintf(L"Privilege added.\n");
}
else
{
int err = LsaNtStatusToWinError(ntsResult);
char str[255];
_snprintf(str, 255, "Privilege was not added - %lu \n", LsaNtStatusToWinError(ntsResult));
MessageBox(NULL, str, "Privilege error", MB_OK);
return FALSE;
}
return TRUE;
}
#define TARGET_SYSTEM_NAME L"mysystem"
LSA_HANDLE GetPolicyHandle()
{
LSA_OBJECT_ATTRIBUTES ObjectAttributes;
WCHAR SystemName[] = TARGET_SYSTEM_NAME;
USHORT SystemNameLength;
LSA_UNICODE_STRING lusSystemName;
NTSTATUS ntsResult;
LSA_HANDLE lsahPolicyHandle;
// Object attributes are reserved, so initialize to zeroes.
ZeroMemory(&ObjectAttributes, sizeof(ObjectAttributes));
//Initialize an LSA_UNICODE_STRING to the server name.
SystemNameLength = wcslen(SystemName);
lusSystemName.Buffer = SystemName;
lusSystemName.Length = SystemNameLength * sizeof(WCHAR);
lusSystemName.MaximumLength = (SystemNameLength+1) * sizeof(WCHAR);
// Get a handle to the Policy object.
ntsResult = LsaOpenPolicy(
NULL, //Name of the target system.
&ObjectAttributes, //Object attributes.
POLICY_ALL_ACCESS, //Desired access permissions.
&lsahPolicyHandle //Receives the policy handle.
);
if (ntsResult != 0)
{
// An error occurred. Display it as a win32 error code.
wprintf(L"OpenPolicy returned %lu\n",
LsaNtStatusToWinError(ntsResult));
return NULL;
}
return lsahPolicyHandle;
}
/*****************************************************************
LoggedSetLockPagesPrivilege: a function to obtain, if possible, or
release the privilege of locking physical pages.
Inputs:
HANDLE hProcess: Handle for the process for which the
privilege is needed
BOOL bEnable: Enable (TRUE) or disable?
Return value: TRUE indicates success, FALSE failure.
*****************************************************************/
BOOL SysLoggedSetLockPagesPrivilege ( HANDLE hProcess, BOOL bEnable)
{
struct {
u32 Count;
LUID_AND_ATTRIBUTES Privilege [1];
} Info;
HANDLE Token;
BOOL Result;
// Open the token.
Result = OpenProcessToken ( hProcess,
TOKEN_ADJUST_PRIVILEGES,
& Token);
if( Result != TRUE ) {
SysPrintf( "Cannot open process token.\n" );
return FALSE;
}
// Enable or disable?
Info.Count = 1;
if( bEnable )
{
Info.Privilege[0].Attributes = SE_PRIVILEGE_ENABLED;
}
else
{
Info.Privilege[0].Attributes = SE_PRIVILEGE_REMOVED;
}
// Get the LUID.
Result = LookupPrivilegeValue ( NULL,
SE_LOCK_MEMORY_NAME,
&(Info.Privilege[0].Luid));
if( Result != TRUE )
{
SysPrintf( "Cannot get privilege value for %s.\n", SE_LOCK_MEMORY_NAME );
return FALSE;
}
// Adjust the privilege.
Result = AdjustTokenPrivileges ( Token, FALSE,
(PTOKEN_PRIVILEGES) &Info,
0, NULL, NULL);
// Check the result.
if( Result != TRUE )
{
SysPrintf ("Cannot adjust token privileges, error %u.\n", GetLastError() );
return FALSE;
}
else
{
if( GetLastError() != ERROR_SUCCESS )
{
BOOL bSuc = FALSE;
LSA_HANDLE policy;
PLSA_TRANSLATED_SID2 ltsTranslatedSID;
// if( !DialogBox(gApp.hInstance, MAKEINTRESOURCE(IDD_USERNAME), gApp.hWnd, (DLGPROC)UserNameProc) )
// return FALSE;
DWORD len = sizeof(s_szUserName);
GetUserNameW(s_szUserName, &len);
policy = GetPolicyHandle();
if( policy != NULL ) {
ltsTranslatedSID = GetSIDInformation(s_szUserName, policy);
if( ltsTranslatedSID != NULL ) {
bSuc = AddPrivileges(ltsTranslatedSID->Sid, policy, bEnable);
LsaFreeMemory(ltsTranslatedSID);
}
LsaClose(policy);
}
if( bSuc ) {
// Get the LUID.
LookupPrivilegeValue ( NULL, SE_LOCK_MEMORY_NAME, &(Info.Privilege[0].Luid));
bSuc = AdjustTokenPrivileges ( Token, FALSE, (PTOKEN_PRIVILEGES) &Info, 0, NULL, NULL);
}
if( bSuc ) {
if( MessageBox(NULL, "PCSX2 just changed your SE_LOCK_MEMORY privilege in order to gain access to physical memory.\n"
"Log off/on and run pcsx2 again. Do you want to log off?\n",
"Privilege changed query", MB_YESNO) == IDYES ) {
ExitWindows(EWX_LOGOFF, 0);
}
}
else {
MessageBox(NULL, "Failed adding SE_LOCK_MEMORY privilege, please check the local policy.\n"
"Go to security settings->Local Policies->User Rights. There should be a \"Lock pages in memory\".\n"
"Add your user to that and log off/on. This enables pcsx2 to run at real-time by allocating physical memory.\n"
"Also can try Control Panel->Local Security Policy->... (this does not work on Windows XP Home)\n"
"(zerofrog)\n", "Virtual Memory Access Denied", MB_OK);
return FALSE;
}
}
}
CloseHandle( Token );
return TRUE;
}
static u32 s_dwPageSize = 0;
int SysPhysicalAlloc(u32 size, PSMEMORYBLOCK* pblock)
{
//#ifdef WIN32_FILE_MAPPING
// assert(0);
//#endif
ULONG_PTR NumberOfPagesInitial; // initial number of pages requested
int PFNArraySize; // memory to request for PFN array
BOOL bResult;
assert( pblock != NULL );
memset(pblock, 0, sizeof(PSMEMORYBLOCK));
if( s_dwPageSize == 0 ) {
SYSTEM_INFO sSysInfo; // useful system information
GetSystemInfo(&sSysInfo); // fill the system information structure
s_dwPageSize = sSysInfo.dwPageSize;
if( s_dwPageSize != 0x1000 ) {
SysMessage("Error! OS page size must be 4Kb!\n"
"If for some reason the OS cannot have 4Kb pages, then run the TLB build.");
return -1;
}
}
// Calculate the number of pages of memory to request.
pblock->NumberPages = (size+s_dwPageSize-1)/s_dwPageSize;
PFNArraySize = pblock->NumberPages * sizeof (ULONG_PTR);
pblock->aPFNs = (uptr *) HeapAlloc (GetProcessHeap (), 0, PFNArraySize);
if (pblock->aPFNs == NULL) {
SysPrintf("Failed to allocate on heap.\n");
goto eCleanupAndExit;
}
// Allocate the physical memory.
NumberOfPagesInitial = pblock->NumberPages;
bResult = AllocateUserPhysicalPages( GetCurrentProcess(), (PULONG_PTR)&pblock->NumberPages, (PULONG_PTR)pblock->aPFNs );
if( bResult != TRUE )
{
SysPrintf("Cannot allocate physical pages, error %u.\n", GetLastError() );
goto eCleanupAndExit;
}
if( NumberOfPagesInitial != pblock->NumberPages )
{
SysPrintf("Allocated only %p of %p pages.\n", pblock->NumberPages, NumberOfPagesInitial );
goto eCleanupAndExit;
}
pblock->aVFNs = (uptr*)HeapAlloc(GetProcessHeap(), 0, PFNArraySize);
return 0;
eCleanupAndExit:
SysPhysicalFree(pblock);
return -1;
}
void SysPhysicalFree(PSMEMORYBLOCK* pblock)
{
assert( pblock != NULL );
// Free the physical pages.
FreeUserPhysicalPages( GetCurrentProcess(), (PULONG_PTR)&pblock->NumberPages, (PULONG_PTR)pblock->aPFNs );
if( pblock->aPFNs != NULL ) HeapFree(GetProcessHeap(), 0, pblock->aPFNs);
if( pblock->aVFNs != NULL ) HeapFree(GetProcessHeap(), 0, pblock->aVFNs);
memset(pblock, 0, sizeof(PSMEMORYBLOCK));
}
int SysVirtualPhyAlloc(void* base, u32 size, PSMEMORYBLOCK* pblock)
{
BOOL bResult;
int i;
LPVOID lpMemReserved = VirtualAlloc( base, size, MEM_RESERVE | MEM_PHYSICAL, PAGE_READWRITE );
if( lpMemReserved == NULL || base != lpMemReserved )
{
SysPrintf("Cannot reserve memory at 0x%8.8x(%x), error: %d.\n", base, lpMemReserved, GetLastError());
goto eCleanupAndExit;
}
// Map the physical memory into the window.
bResult = MapUserPhysicalPages( base, pblock->NumberPages, (PULONG_PTR)pblock->aPFNs );
for(i = 0; i < pblock->NumberPages; ++i)
pblock->aVFNs[i] = (ULONG_PTR)base + 0x1000*i;
if( bResult != TRUE )
{
SysPrintf("MapUserPhysicalPages failed to map, error %u.\n", GetLastError() );
goto eCleanupAndExit;
}
return 0;
eCleanupAndExit:
SysVirtualFree(base, size);
return -1;
}
void SysVirtualFree(void* lpMemReserved, u32 size)
{
// unmap
if( MapUserPhysicalPages( lpMemReserved, (size+s_dwPageSize-1)/s_dwPageSize, NULL ) != TRUE )
{
SysPrintf("MapUserPhysicalPages failed to unmap, error %u.\n", GetLastError() );
return;
}
// Free virtual memory.
VirtualFree( lpMemReserved, 0, MEM_RELEASE );
}
int SysMapUserPhysicalPages(void* Addr, uptr NumPages, uptr* pfn, int pageoffset)
{
BOOL bResult = MapUserPhysicalPages(Addr, NumPages, (PULONG_PTR)(pfn+pageoffset));
#ifdef _DEBUG
//if( !bResult )
//__Log("Failed to map user pages: 0x%x:0x%x, error = %d\n", Addr, NumPages, GetLastError());
#endif
return bResult;
}
#else
#endif
| [
"saqibakhtar@23c756db-88ba-2448-99d7-e6e4c676ec84"
]
| [
[
[
1,
1937
]
]
]
|
ee07f788bef4898d7575203fc8aad80a0718f6c6 | 8b3f876f510a6d347c12703f284022f4e80896e9 | /SSGUIMenuBar.cpp | c35920576a4dab81c06089e16e741b1711c92613 | []
| no_license | flexoid/SolarSystem | 77bf43464666800da0ad526005cb3a1113cadb55 | 8ee0f4c773704cb47ce234dc87307f879d6b4990 | refs/heads/master | 2021-03-12T20:37:24.346466 | 2009-05-22T18:14:34 | 2009-05-22T18:14:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 11,202 | cpp | #include "SSGUIMenuBar.h"
#include <irrlicht.h>
SSGUIMenuBar::SSGUIMenuBar(ITexture *image, IGUIEnvironment *environment, IGUIElement *parent, s32 id)
:IGUIElement(EGUIET_ELEMENT, environment, parent, id, rect<s32>(0,0,0,0)),
Interval(1), Horizontal(true), HIndention(1,1), VIndention(1,1), HCenter(false), VCenter(false)
{
Background = image;
update();
}
SSGUIMenuBar::~SSGUIMenuBar()
{
if (Background) Background->drop();
if (Separator) Separator->drop();
if (Buttons.size() > 0)
{
for (s32 i = 0; i < (s32)Buttons.size(); i++)
{
Buttons[i].Button->drop();
}
}
}
void SSGUIMenuBar::update()
{
if (Background)
{
position2d<s32> pos = IGUIElement::getRelativePosition().UpperLeftCorner;
IGUIElement::setRelativePosition(rect<s32>(pos, pos + Background->getOriginalSize()));
}
}
void SSGUIMenuBar::setOrientaiton(bool horizontal)
{
Horizontal = horizontal;
rebuild();
}
void SSGUIMenuBar::setBackground(ITexture *image)
{
if (image)
{
Background = image;
update();
rebuild();
}
}
void SSGUIMenuBar::setSeparator(ITexture *separator)
{
if (separator)
{
Separator = separator;
rebuild();
}
}
void SSGUIMenuBar::setHIndention(s32 indention)
{
Indention OldIndention = HIndention;
if (indention < 1)
HIndention = Indention(1, 1);
else
HIndention = Indention(indention, indention);
if (HIndention != OldIndention)
rebuild();
}
void SSGUIMenuBar::setHIndention(s32 LeftIndention, s32 RightIndention)
{
Indention OldIndention = HIndention;
if (LeftIndention < 1)
HIndention.FIndention = 1;
else
HIndention.FIndention = LeftIndention;
if (RightIndention < 1)
HIndention.SIndention = 1;
else
HIndention.SIndention = RightIndention;
if (HIndention != OldIndention)
rebuild();
}
void SSGUIMenuBar::setVIndention(s32 indention)
{
Indention OldIndention = VIndention;
if (indention < 1)
VIndention = Indention(1, 1);
else
VIndention = Indention(indention, indention);
if (VIndention != OldIndention)
rebuild();
}
void SSGUIMenuBar::setVIndention(s32 UpIndention, s32 DownIndention)
{
Indention OldIndention = VIndention;
if (UpIndention < 1)
VIndention.FIndention = 1;
else
VIndention.FIndention = UpIndention;
if (DownIndention < 1)
VIndention.SIndention = 1;
else
VIndention.SIndention = DownIndention;
if (VIndention != OldIndention)
rebuild();
}
void SSGUIMenuBar::setInterval(s32 pixels)
{
s32 OldInterval = Interval;
if (pixels < 1)
Interval = 1;
else
Interval = pixels;
if (Interval != OldInterval)
rebuild();
}
void SSGUIMenuBar::setIntervalAfterButton(s32 buttonID, s32 pixels)
{
if (buttonID >= 0)
{
s32 index = getButtonIndex(buttonID);
if (index != -1)
{
s32 OldInterval = Buttons[index].IntervalAfter;
if (pixels < 0)
Buttons[index].IntervalAfter = -1;
else
Buttons[index].IntervalAfter = pixels;
if (Buttons[index].IntervalAfter != OldInterval)
rebuild();
}
}
}
void SSGUIMenuBar::setHCenter(bool center)
{
bool last = HCenter;
HCenter = center;
if (HCenter != last)
rebuild();
}
void SSGUIMenuBar::setVCenter(bool center)
{
bool last = VCenter;
VCenter = center;
if (VCenter != last)
rebuild();
}
void SSGUIMenuBar::setSeparatorAfterButton(s32 buttonID, bool separator)
{
if (buttonID >= 0)
{
s32 index = getButtonIndex(buttonID);
if (index != -1)
{
bool last = Buttons[index].SeparatorAfter;
Buttons[index].SeparatorAfter = separator;
if (Buttons[index].SeparatorAfter != last)
rebuild();
}
}
}
s32 SSGUIMenuBar::addButton(IGUIButton *button)
{
if (button)
{
s32 ID = getFreeButtonID();
SSMButton Button;
Button.Button = button;
Button.Callback = 0;
Button.SeparatorAfter = false;
Button.IntervalAfter = -1;
Button.ID = ID;
Buttons.push_back(Button);
rebuild();
return ID;
}
else
return -1;
}
bool SSGUIMenuBar::dropButton(s32 buttonID)
{
if (buttonID >= 0)
{
s32 index = getButtonIndex(buttonID);
if(index != -1)
{
if (Container->isMyChild(Buttons[index].Button))
Container->removeChild(Buttons[index].Button);
Buttons.erase(index);
rebuild();
return true;
}
}
return false;
}
void SSGUIMenuBar::rebuild()
{
update();
if (!Container)
{
Container = new IGUIElement(EGUIET_ELEMENT, Environment, this, -1, rect<s32>(0,0,0,0));
}
Container->setRelativePosition(rect<s32>(HIndention.FIndention, VIndention.FIndention,
IGUIElement::getRelativePosition().getWidth() - HIndention.SIndention,
IGUIElement::getRelativePosition().getHeight() - VIndention.SIndention));
if (Horizontal)
{
s32 X = 0;
s32 Y = 0;
s32 lastButtonIndex = -1;
for (s32 i = 0; i < (s32)Buttons.size(); i++)
{
s32 Width = Buttons[i].Button->getRelativePosition().getWidth();
s32 Height = Buttons[i].Button->getRelativePosition().getHeight();
if (Container->isPointInside(position2d<s32>(Container->getAbsolutePosition().UpperLeftCorner.X + X + Width,
Container->getAbsolutePosition().UpperLeftCorner.Y)))
{
Container->addChild(Buttons[i].Button);
if (VCenter)
Y = s32((Container->getRelativePosition().getHeight() - Height) / 2);
Buttons[i].Button->setRelativePosition(rect<s32>(X, Y, X + Width, Y + Height));
Buttons[i].Button->setVisible(true);
X += Width;
if (Buttons[i].IntervalAfter != -1)
X += Buttons[i].IntervalAfter;
else
X += Interval;
if (Buttons[i].SeparatorAfter)
{
X += Separator->getSize().Width;
if (Buttons[i].IntervalAfter != -1)
X += Buttons[i].IntervalAfter;
else
X += Interval;
}
lastButtonIndex = i;
}
else
{
for (; i < (s32)Buttons.size(); i++)
Buttons[i].Button->setVisible(false);
break;
}
}
if (HCenter)
{
if (lastButtonIndex != -1)
{
rect<s32> rectangle = Container->getRelativePosition();
rectangle.LowerRightCorner.X = rectangle.UpperLeftCorner.X + Buttons[lastButtonIndex].Button->getRelativePosition().LowerRightCorner.X;
s32 Width = rectangle.getWidth();
rectangle.UpperLeftCorner.X = s32((IGUIElement::getRelativePosition().getWidth() - rectangle.getWidth()) / 2);
rectangle.LowerRightCorner.X = rectangle.UpperLeftCorner.X + Width;
Container->setRelativePosition(rectangle);
}
}
}
else
{
s32 X = 0;
s32 Y = 0;
s32 lastButtonIndex = -1;
for (s32 i = 0; i < (s32)Buttons.size(); i++)
{
s32 Width = Buttons[i].Button->getRelativePosition().getWidth();
s32 Height = Buttons[i].Button->getRelativePosition().getHeight();
if (Container->isPointInside(position2d<s32>(Container->getAbsolutePosition().UpperLeftCorner.X,
Container->getAbsolutePosition().UpperLeftCorner.Y + Y + Height)))
{
Container->addChild(Buttons[i].Button);
if (HCenter)
X = s32((Container->getRelativePosition().getWidth() - Width) / 2);
Buttons[i].Button->setRelativePosition(rect<s32>(X, Y, X + Width, Y + Height));
Buttons[i].Button->setVisible(true);
Y += Height;
if (Buttons[i].IntervalAfter != -1)
Y += Buttons[i].IntervalAfter;
else
Y += Interval;
if (Buttons[i].SeparatorAfter)
{
Y += Separator->getSize().Height;
if (Buttons[i].IntervalAfter != -1)
Y += Buttons[i].IntervalAfter;
else
Y += Interval;
}
lastButtonIndex = i;
}
else
{
for (; i < (s32)Buttons.size(); i++)
Buttons[i].Button->setVisible(false);
break;
}
}
if (VCenter)
{
if (lastButtonIndex != -1)
{
rect<s32> rectangle = Container->getRelativePosition();
rectangle.LowerRightCorner.Y = rectangle.UpperLeftCorner.Y + Buttons[lastButtonIndex].Button->getRelativePosition().LowerRightCorner.Y;
s32 Height = rectangle.getHeight();
rectangle.UpperLeftCorner.Y = s32((IGUIElement::getRelativePosition().getHeight() - rectangle.getHeight()) / 2);
rectangle.LowerRightCorner.Y = rectangle.UpperLeftCorner.Y + Height;
Container->setRelativePosition(rectangle);
}
}
}
}
void SSGUIMenuBar::setCallback(s32 buttonID, callback cb)
{
if (buttonID >= 0)
{
s32 index = getButtonIndex(buttonID);
if (index != -1)
{
Buttons[index].Callback = cb;
}
}
}
s32 SSGUIMenuBar::getButtonIndex(s32 ID)
{
for (s32 i = 0; i < (s32)Buttons.size(); i++)
{
if (Buttons[i].ID == ID)
return i;
}
return -1;
}
s32 SSGUIMenuBar::getFreeButtonID()
{
s32 ID = -1;
s32 id = 0;
while (ID == -1)
{
bool avalible = true;
for (s32 i = 0; i < (s32)Buttons.size(); i++)
{
if (Buttons[i].ID == id)
avalible = false;
}
if (!avalible)
id++;
else
{
ID = id;
break;
}
}
return ID;
}
void SSGUIMenuBar::draw()
{
if (!IsVisible)
return;
IVideoDriver *driver = Environment->getVideoDriver();
if (Background)
{
driver->draw2DImage(Background, AbsoluteRect.UpperLeftCorner, rect<s32>(position2d<s32>(0,0), Background->getOriginalSize()),
0, SColor(255,255,255,255), true);
if (Horizontal)
{
if (Separator)
{
for (s32 i = 0; i < (s32)Buttons.size(); i++)
{
if (Buttons[i].SeparatorAfter)
{
position2d<s32> pos = Container->getAbsolutePosition().UpperLeftCorner;
pos.X += Buttons[i].Button->getRelativePosition().LowerRightCorner.X;
if (Buttons[i].IntervalAfter != -1)
pos.X += Buttons[i].IntervalAfter;
else
pos.X += Interval;
pos.Y += s32((Container->getRelativePosition().getHeight() - Separator->getSize().Height) / 2);
driver->draw2DImage(Separator, pos, rect<s32>(0, 0, Separator->getSize().Width, Separator->getSize().Height),
0, SColor(255,255,255,255), true);
}
}
}
}
else
{
if (Separator)
{
for (s32 i = 0; i < (s32)Buttons.size(); i++)
{
if (Buttons[i].SeparatorAfter)
{
position2d<s32> pos = Container->getAbsolutePosition().UpperLeftCorner;
pos.X += s32((Container->getRelativePosition().getWidth() - Separator->getSize().Width) / 2);
pos.Y += Buttons[i].Button->getRelativePosition().LowerRightCorner.Y;
if (Buttons[i].IntervalAfter != -1)
pos.Y += Buttons[i].IntervalAfter;
else
pos.Y += Interval;
driver->draw2DImage(Separator, pos, rect<s32>(0, 0, Separator->getSize().Width, Separator->getSize().Height),
0, SColor(255,255,255,255), true);
}
}
}
}
IGUIElement::draw();
}
}
bool SSGUIMenuBar::OnEvent(const SEvent &event)
{
if (event.GUIEvent.EventType == EGET_BUTTON_CLICKED)
{
for (s32 i = 0; i < (s32)Buttons.size(); i++)
{
if (Buttons[i].Button == event.GUIEvent.Caller)
{
if (Buttons[i].Callback)
{
Buttons[i].Callback();
}
break;
}
}
return true;
}
return IGUIElement::OnEvent(event);
} | [
"[email protected]"
]
| [
[
[
1,
506
]
]
]
|
4fab83c2896a3ab454d2af36924dd232fcfd9a35 | 36d0ddb69764f39c440089ecebd10d7df14f75f3 | /プログラム/Ngllib/include/Ngl/Vector2.h | 2f5981b474f7e9a23a2d29cb432178068235c2ce | []
| no_license | weimingtom/tanuki-mo-issyo | 3f57518b4e59f684db642bf064a30fc5cc4715b3 | ab57362f3228354179927f58b14fa76b3d334472 | refs/heads/master | 2021-01-10T01:36:32.162752 | 2009-04-19T10:37:37 | 2009-04-19T10:37:37 | 48,733,344 | 0 | 0 | null | null | null | null | SHIFT_JIS | C++ | false | false | 11,055 | h | /*******************************************************************************/
/**
* @file Vector2.h.
*
* @brief ２次元ベクトル構造体ヘッダファイル.
*
* @date 2008/06/28.
*
* @version 1.00.
*
* @author Kentarou Nishimura.
*/
/******************************************************************************/
#ifndef _NGL_VECTOR2_H_
#define _NGL_VECTOR2_H_
#ifdef __cplusplus
namespace Ngl{
#endif
/**
* @struct Vector2.
* @brief 2次元ベクトル構造体．
*/
typedef struct Vector2
{
/** x成分 */
float x;
/** y成分 */
float y;
#ifdef __cplusplus
/*=========================================================================*/
/**
* @brief コンストラクタ
*
* @param[in] なし.
*/
Vector2();
/*=========================================================================*/
/**
* @brief コンストラクタ
*
* @param[in] other 配列のポインタ.
*/
Vector2( const float* other );
/*=========================================================================*/
/**
* @brief コンストラクタ
*
* @param[in] X x成分.
* @param[in] Y y成分.
*/
Vector2( float X, float Y );
/*=========================================================================*/
/**
* @brief 0.0に初期化する
*
* @param[in] なし.
* @return なし.
*/
void zero();
/*=========================================================================*/
/**
* @brief 初期化する
*
* @param[in] X x成分.
* @param[in] Y y成分.
* @return なし.
*/
void initialize( float X, float Y );
/*=========================================================================*/
/**
* @brief ノルムを求める
*
* @param[in] なし.
* @return なし.
*/
float length() const;
/*=========================================================================*/
/**
* @brief 正規化する
*
* @param[in] なし.
* @return 正規化したベクトル.
*/
Vector2& normalize();
/*=========================================================================*/
/**
* @brief 内積を求める
*
* @param[in] v 内積を求めるベクトル.
* @return 内積.
*/
float dot( const Vector2& v ) const;
/*=========================================================================*/
/**
* @brief ベクトル同士の距離を求める
*
* @param[in] other 距離を求めるベクトル.
* @return ベクトルの距離.
*/
float distance( const Ngl::Vector2& other );
/*=========================================================================*/
/**
* @brief ベクトルの線形補間を行う
*
* @param[in] min 最小値.
* @param[in] max 最大値.
* @param[in] t 補間値( 0.0f〜1.0f ).
* @return 結果のベクトル.
*/
Vector2& lerp( const Vector2& min, const Vector2& max, float t );
/*=========================================================================*/
/**
* @brief ベクトルの2次補間を行う
*
* @param[in] v1 補間要素2次元ベクトル.
* @param[in] v2 補間要素2次元ベクトル.
* @param[in] v3 2次元ベクトル.
* @param[in] t 補間値( 0.0f〜1.0f ).
* @return 結果のベクトル.
*/
Vector2& quadratic( const Vector2& v1, const Vector2& v2, const Vector2& v3, float t );
/*=========================================================================*/
/**
* @brief + 演算子オーバーロード
*
* @param[in] なし.
* @return なし.
*/
Vector2 operator + () const;
/*=========================================================================*/
/**
* @brief - 演算子オーバーロード 逆ベクトルを求める
*
* @param[in] なし.
* @return なし.
*/
Vector2 operator - () const;
/*=========================================================================*/
/**
* @brief += 演算子オーバーロード
*
* @param[in] v 加算するベクトル.
* @return 加算結果のベクトル.
*/
Vector2& operator += ( const Vector2& v );
/*=========================================================================*/
/**
* @brief -= 演算子オーバーロード
*
* @param[in] v 減算するベクトル.
* @return 減算結果のベクトル.
*/
Vector2& operator -= ( const Vector2& v );
/*=========================================================================*/
/**
* @brief *=演算子オーバーロード
*
* @param[in] v 乗算するベクトル.
* @return 演算結果のベクトル.
*/
Vector2& operator *= ( const Vector2& v );
/*=========================================================================*/
/**
* @brief *= 演算子オーバーロード
*
* @param[in] s 乗算するスカラー値.
* @return 乗算結果のベクトル.
*/
Vector2& operator *= ( float s );
/*=========================================================================*/
/**
* @brief /=演算子オーバーロード
*
* @param[in] v 除算するベクトル.
* @return 演算結果のベクトル.
*/
Vector2& operator /= ( const Vector2& v );
/*=========================================================================*/
/**
* @brief /= 演算子オーバーロード
*
* @param[in] s 除算するスカラー値.
* @return 除算結果のベクトル.
*/
Vector2& operator /= ( float s );
/*=========================================================================*/
/**
* @brief float*演算子オーバーロード
*
* @param[in] なし.
* @return キャストした値.
*/
operator float* () const;
/*=========================================================================*/
/**
* @brief float*演算子オーバーロード
*
* @param[in] なし.
* @return キャストした値.
*/
operator const float* () const;
#endif
} NGLvector2;
#ifdef __cplusplus
/** ゼロベクトル */
static const Vector2 VECTOR2_ZERO = Vector2( 0.0f, 0.0f );
/** 上方向ベクトル */
static const Vector2 VECTOR2_UP = Vector2( 0.0f, 1.0f );
} // namespace Ngl
/*===========================================================================*/
/**
* @brief + 演算子オーバーロード
*
* @param[in] v1 加算するベクトル1.
* @param[in] v2 加算するベクトル2.
* @return 加算結果のベクトル.
*/
const Ngl::Vector2 operator + ( const Ngl::Vector2& v1, const Ngl::Vector2& v2 );
/*===========================================================================*/
/**
* @brief - 演算子オーバーロード
*
* @param[in] v1 減算するベクトル1.
* @param[in] v2 減算するベクトル2.
* @return 減算結果のベクトル.
*/
const Ngl::Vector2 operator - ( const Ngl::Vector2& v1, const Ngl::Vector2& v2 );
/*===========================================================================*/
/**
* @brief *演算子オーバーロード 非メンバ関数
*
* @param[in] v1 演算するベクトル1.
* @param[in] v2 演算するベクトル2.
* @return 演算結果のベクトル.
*/
const Ngl::Vector2 operator * ( const Ngl::Vector2& v1, const Ngl::Vector2& v2 );
/*===========================================================================*/
/**
* @brief * 演算子オーバーロード
*
* @param[in] v 乗算するベクトル.
* @param[in] s 乗算するスカラー値.
* @return 乗算結果のベクトル.
*/
const Ngl::Vector2 operator * ( const Ngl::Vector2& v, float s );
/*===========================================================================*/
/**
* @brief * 演算子オーバーロード
*
* @param[in] s 乗算するスカラー.
* @param[in] v 加算するベクトル2.
* @return 加算結果のベクトル.
*/
const Ngl::Vector2 operator * ( float s, const Ngl::Vector2& v );
/*===========================================================================*/
/**
* @brief /演算子オーバーロード 非メンバ関数
*
* @param[in] v1 演算するベクトル1.
* @param[in] v2 演算するベクトル2.
* @return 演算結果のベクトル.
*/
const Ngl::Vector2 operator / ( const Ngl::Vector2& v1, const Ngl::Vector2& v2 );
/*===========================================================================*/
/**
* @brief / 演算子オーバーロード
*
* @param[in] v 除算するベクトル.
* @param[in] s 除算するスカラー.
* @return 除算結果のベクトル.
*/
const Ngl::Vector2 operator / ( const Ngl::Vector2& v, float s );
/*=========================================================================*/
/**
* @brief ==演算子オーバーロード
*
* @param[in] v1 比較する3次元ベクトル1.
* @param[in] v2 比較する3次元ベクトル2.
* @return true 同じ値, false 違う値.
*/
bool operator == ( const Ngl::Vector2& v1, const Ngl::Vector2& v2 );
/*=========================================================================*/
/**
* @brief !=演算子オーバーロード
*
* @param[in] v1 比較する3次元ベクトル1.
* @param[in] v2 比較する3次元ベクトル2.
* @return true 同じ値, false 違う値.
*/
bool operator != ( const Ngl::Vector2& v1, const Ngl::Vector2& v2 );
/*=========================================================================*/
/**
* @brief <演算子オーバーロード
*
* @param[in] v1 比較する3次元ベクトル1.
* @param[in] v2 比較する3次元ベクトル2.
* @return true 同じ値,
*/
bool operator < ( const Ngl::Vector2& v1, const Ngl::Vector2& v2 );
/*=========================================================================*/
/**
* @brief <演算子オーバーロード
*
* @param[in] v1 比較する3次元ベクトル1.
* @param[in] v2 比較する3次元ベクトル2.
* @return true 同じ値,
*/
bool operator > ( const Ngl::Vector2& v1, const Ngl::Vector2& v2 );
/*=========================================================================*/
/**
* @brief <=演算子オーバーロード
*
* @param[in] v1 比較する3次元ベクトル1.
* @param[in] v2 比較する3次元ベクトル2.
* @return true 同じ値,
*/
bool operator <= ( const Ngl::Vector2& v1, const Ngl::Vector2& v2 );
/*=========================================================================*/
/**
* @brief >=演算子オーバーロード
*
* @param[in] v1 比較する3次元ベクトル1.
* @param[in] v2 比較する3次元ベクトル2.
* @return true 同じ値,
*/
bool operator >= ( const Ngl::Vector2& v1, const Ngl::Vector2& v2 );
#endif
#endif
/*===== EOF ==================================================================*/ | [
"rs.drip@aa49b5b2-a402-11dd-98aa-2b35b7097d33"
]
| [
[
[
1,
417
]
]
]
|
cad8d7a01b479f587e3bf0191269dbf03f89bc9f | a84b013cd995870071589cefe0ab060ff3105f35 | /webdriver/branches/chrome_extension/third_party/gecko-1.9.0.11/win32/include/nsIDOMHTMLFrameSetElement.h | 534c05fa8bad17fe08345b422a53dbff6fcfbe3f | [
"Apache-2.0"
]
| permissive | vdt/selenium | 137bcad58b7184690b8785859d77da0cd9f745a0 | 30e5e122b068aadf31bcd010d00a58afd8075217 | refs/heads/master | 2020-12-27T21:35:06.461381 | 2009-08-18T15:56:32 | 2009-08-18T15:56:32 | 13,650,409 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,415 | h | /*
* DO NOT EDIT. THIS FILE IS GENERATED FROM e:/xr19rel/WINNT_5.2_Depend/mozilla/dom/public/idl/html/nsIDOMHTMLFrameSetElement.idl
*/
#ifndef __gen_nsIDOMHTMLFrameSetElement_h__
#define __gen_nsIDOMHTMLFrameSetElement_h__
#ifndef __gen_nsIDOMHTMLElement_h__
#include "nsIDOMHTMLElement.h"
#endif
/* For IDL files that don't want to include root IDL files. */
#ifndef NS_NO_VTABLE
#define NS_NO_VTABLE
#endif
/* starting interface: nsIDOMHTMLFrameSetElement */
#define NS_IDOMHTMLFRAMESETELEMENT_IID_STR "a6cf90b8-15b3-11d2-932e-00805f8add32"
#define NS_IDOMHTMLFRAMESETELEMENT_IID \
{0xa6cf90b8, 0x15b3, 0x11d2, \
{ 0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32 }}
/**
* The nsIDOMHTMLFrameSetElement interface is the interface to a
* [X]HTML frameset element.
*
* For more information on this interface please see
* http://www.w3.org/TR/DOM-Level-2-HTML/
*
* @status FROZEN
*/
class NS_NO_VTABLE NS_SCRIPTABLE nsIDOMHTMLFrameSetElement : public nsIDOMHTMLElement {
public:
NS_DECLARE_STATIC_IID_ACCESSOR(NS_IDOMHTMLFRAMESETELEMENT_IID)
/* attribute DOMString cols; */
NS_SCRIPTABLE NS_IMETHOD GetCols(nsAString & aCols) = 0;
NS_SCRIPTABLE NS_IMETHOD SetCols(const nsAString & aCols) = 0;
/* attribute DOMString rows; */
NS_SCRIPTABLE NS_IMETHOD GetRows(nsAString & aRows) = 0;
NS_SCRIPTABLE NS_IMETHOD SetRows(const nsAString & aRows) = 0;
};
NS_DEFINE_STATIC_IID_ACCESSOR(nsIDOMHTMLFrameSetElement, NS_IDOMHTMLFRAMESETELEMENT_IID)
/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIDOMHTMLFRAMESETELEMENT \
NS_SCRIPTABLE NS_IMETHOD GetCols(nsAString & aCols); \
NS_SCRIPTABLE NS_IMETHOD SetCols(const nsAString & aCols); \
NS_SCRIPTABLE NS_IMETHOD GetRows(nsAString & aRows); \
NS_SCRIPTABLE NS_IMETHOD SetRows(const nsAString & aRows);
/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIDOMHTMLFRAMESETELEMENT(_to) \
NS_SCRIPTABLE NS_IMETHOD GetCols(nsAString & aCols) { return _to GetCols(aCols); } \
NS_SCRIPTABLE NS_IMETHOD SetCols(const nsAString & aCols) { return _to SetCols(aCols); } \
NS_SCRIPTABLE NS_IMETHOD GetRows(nsAString & aRows) { return _to GetRows(aRows); } \
NS_SCRIPTABLE NS_IMETHOD SetRows(const nsAString & aRows) { return _to SetRows(aRows); }
/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIDOMHTMLFRAMESETELEMENT(_to) \
NS_SCRIPTABLE NS_IMETHOD GetCols(nsAString & aCols) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetCols(aCols); } \
NS_SCRIPTABLE NS_IMETHOD SetCols(const nsAString & aCols) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetCols(aCols); } \
NS_SCRIPTABLE NS_IMETHOD GetRows(nsAString & aRows) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetRows(aRows); } \
NS_SCRIPTABLE NS_IMETHOD SetRows(const nsAString & aRows) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetRows(aRows); }
#if 0
/* Use the code below as a template for the implementation class for this interface. */
/* Header file */
class nsDOMHTMLFrameSetElement : public nsIDOMHTMLFrameSetElement
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIDOMHTMLFRAMESETELEMENT
nsDOMHTMLFrameSetElement();
private:
~nsDOMHTMLFrameSetElement();
protected:
/* additional members */
};
/* Implementation file */
NS_IMPL_ISUPPORTS1(nsDOMHTMLFrameSetElement, nsIDOMHTMLFrameSetElement)
nsDOMHTMLFrameSetElement::nsDOMHTMLFrameSetElement()
{
/* member initializers and constructor code */
}
nsDOMHTMLFrameSetElement::~nsDOMHTMLFrameSetElement()
{
/* destructor code */
}
/* attribute DOMString cols; */
NS_IMETHODIMP nsDOMHTMLFrameSetElement::GetCols(nsAString & aCols)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsDOMHTMLFrameSetElement::SetCols(const nsAString & aCols)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* attribute DOMString rows; */
NS_IMETHODIMP nsDOMHTMLFrameSetElement::GetRows(nsAString & aRows)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsDOMHTMLFrameSetElement::SetRows(const nsAString & aRows)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* End of implementation class template. */
#endif
#endif /* __gen_nsIDOMHTMLFrameSetElement_h__ */
| [
"simon.m.stewart@07704840-8298-11de-bf8c-fd130f914ac9"
]
| [
[
[
1,
128
]
]
]
|
50a2bad4f28862351632045f6bc6b094f71c94e0 | 6bdb3508ed5a220c0d11193df174d8c215eb1fce | /Codes/Halak/Internal/FontCache.cpp | 1d05ae4af76317290f6d5258546c0b6e8d1b321a | []
| no_license | halak/halak-plusplus | d09ba78640c36c42c30343fb10572c37197cfa46 | fea02a5ae52c09ff9da1a491059082a34191cd64 | refs/heads/master | 2020-07-14T09:57:49.519431 | 2011-07-09T14:48:07 | 2011-07-09T14:48:07 | 66,716,624 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 15,362 | cpp | #include <Halak/PCH.h>
#include <Halak/Internal/FontCache.h>
#include <Halak/Internal/GlyphTable.h>
#include <Halak/FontLibrary.h>
#include <Halak/Glyph.h>
namespace Halak
{
static FT_Matrix UnitMatrix = { 0x10000L, 0, 0, 0x10000L };
static FT_Vector ZeroVector = { 0, 0 };
// library 26.6 실수계와 C++ float 좌표계를 상호 변환한다.
// http://library.sourceforge.net/library2/docs/glyphs/glyphs-3.html
static inline float F26D6ToFloat(FT_F26Dot6 value)
{
return static_cast<float>(value) / 64.0f;
}
static inline FT_F26Dot6 FloatToF26D6(float value)
{
return static_cast<FT_F26Dot6>(value * 64.0f);
}
static inline float F16D16ToFloat(FT_Fixed value)
{
return static_cast<float>(value) / 65536.0f;
}
static inline FT_Fixed FloatToF16D16(float value)
{
return static_cast<FT_F26Dot6>(value * 65536.0f);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
FontCacheParameters::FontCacheParameters()
: Face(),
FontSize(10.0f),
StrokeSize(0.0f),
Weights(0.0f),
Shear(0.0f),
GlowSize(0),
GlowSpread(0.0f),
GlowThickness(0.0f),
Scale(1.0f),
Hinting(true),
IgnoreBitmap(false)
{
}
FontCacheParameters::FontCacheParameters(const String& face, float fontSize, float strokeSize, float weights, float shear,
int glowSize, float glowSpread, float glowThickness,
float scale, bool hinting, bool ignoreBitmap)
: Face(face),
FontSize(fontSize),
StrokeSize(strokeSize),
Weights(weights),
Shear(shear),
GlowSize(glowSize),
GlowSpread(glowSpread),
GlowThickness(glowThickness),
Scale(scale),
Hinting(hinting),
IgnoreBitmap(ignoreBitmap)
{
}
unsigned int FontCacheParameters::GetHashCode() const
{
unsigned int result = 0;
result += static_cast<unsigned int>(Face.GetLength() * 65536);
result += static_cast<unsigned int>(FloatToF26D6(FontSize));
result += static_cast<unsigned int>(FloatToF26D6(StrokeSize));
result += static_cast<unsigned int>(FloatToF26D6(Weights));
result += static_cast<unsigned int>(FloatToF16D16(Shear));
result += static_cast<unsigned int>(GlowSize);
result += static_cast<unsigned int>(GlowSpread * 100.0f);
result += static_cast<unsigned int>(GlowThickness * 100.0f);
result += static_cast<unsigned int>(Scale * 100.0f);
result += static_cast<unsigned int>(Hinting ? 0x08000000 : 0x00000000);
result += static_cast<unsigned int>(IgnoreBitmap ? 0x00800000 : 0x00000000);
return result;
}
bool FontCacheParameters::operator == (const FontCacheParameters& right) const
{
if (GlowSize > 0 && right.GlowSize > 0)
{
return (Face == right.Face &&
FloatToF26D6(FontSize) == FloatToF26D6(right.FontSize) &&
FloatToF26D6(StrokeSize) == FloatToF26D6(right.StrokeSize) &&
FloatToF26D6(Weights) == FloatToF26D6(right.Weights) &&
FloatToF16D16(Shear) == FloatToF16D16(right.Shear) &&
GlowSize == right.GlowSize &&
GlowSpread == right.GlowSpread &&
GlowThickness == right.GlowThickness &&
FloatToF26D6(Scale) == FloatToF26D6(right.Scale) &&
Hinting == right.Hinting &&
IgnoreBitmap == right.IgnoreBitmap);
}
else if (GlowSize == 0 && right.GlowSize == 0)
{
return (Face == right.Face &&
FloatToF26D6(FontSize) == FloatToF26D6(right.FontSize) &&
FloatToF26D6(StrokeSize) == FloatToF26D6(right.StrokeSize) &&
FloatToF26D6(Weights) == FloatToF26D6(right.Weights) &&
FloatToF16D16(Shear) == FloatToF16D16(right.Shear) &&
FloatToF26D6(Scale) == FloatToF26D6(right.Scale) &&
Hinting == right.Hinting &&
IgnoreBitmap == right.IgnoreBitmap);
}
else
return false;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
FontCache::FontCache(FontLibrary* library, const FontCacheParameters& parameters)
: library(library),
parameters(parameters),
primaryFace(nullptr),
alternativeFace(nullptr),
stroker(nullptr),
transform(UnitMatrix),
ascender(0.0f),
descender(0.0f),
lineHeight(0.0f),
regularGlyphTable(nullptr),
strokedGlyphTable(nullptr),
glowGlyphTable(nullptr)
{
String faceFilename = parameters.Face;
int faceIndex = 0; // *.ttc 파일일 경우 폰트가 존재하는 위치 (TTC = TrueTypeCollection)
int separatorIndex = parameters.Face.ReverseFind('?');
if (separatorIndex != -1)
{
faceFilename = parameters.Face.Substring(0, separatorIndex);
faceIndex = atoi(parameters.Face.Substring(separatorIndex + 1).CStr());
}
if (FT_Error error = FT_New_Face(static_cast<FT_Library>(library->GetFTLibrary()), faceFilename.CStr(), faceIndex, &primaryFace))
{
const String newFaceFilepath = library->GetOSFontDirectory() + faceFilename;
if (FT_New_Face(static_cast<FT_Library>(library->GetFTLibrary()), newFaceFilepath.CStr(), faceIndex, &primaryFace))
{
// ERROR 처리 (return하지는 않음)
}
}
if (FT_Error error = FT_New_Face(static_cast<FT_Library>(library->GetFTLibrary()), library->GetAlternativeFace().CStr(), 0, &alternativeFace))
{
// ERROR 처리 (return하지는 않음)
}
const FT_F26Dot6 scaledFontSize = FloatToF26D6(parameters.FontSize * parameters.Scale);
if (primaryFace)
FT_Set_Char_Size(primaryFace, 0, scaledFontSize, 96, 96);
if (alternativeFace)
FT_Set_Char_Size(alternativeFace, 0, scaledFontSize, 96, 96);
if (parameters.StrokeSize > 0.0f)
{
if (FT_Error error = FT_Stroker_New(static_cast<FT_Library>(library->GetFTLibrary()), &stroker))
{
// ERROR 처리
}
const FT_F26Dot6 scaledStrokeSize = FloatToF26D6(parameters.StrokeSize * parameters.Scale);
if (stroker)
FT_Stroker_Set(stroker, scaledStrokeSize, FT_STROKER_LINECAP_BUTT, FT_STROKER_LINEJOIN_ROUND, 0);
}
if (parameters.Shear != 0.0f)
{
transform.xx = FloatToF16D16(1.0f);
transform.xy = FloatToF16D16(parameters.Shear);
transform.yx = FloatToF16D16(0.0f);
transform.yy = FloatToF16D16(1.0f);
}
const FT_Face metricsFont = primaryFace ? primaryFace : alternativeFace;
const FT_Size_Metrics& metrics = metricsFont->size->metrics;
ascender = F26D6ToFloat(metrics.ascender) / parameters.Scale;
descender = F26D6ToFloat(metrics.descender) / parameters.Scale;
lineHeight = F26D6ToFloat(metrics.height) / parameters.Scale;
regularGlyphTable = new GlyphTable(library->GetGraphicsDevice());
if (stroker)
strokedGlyphTable = new GlyphTable(library->GetGraphicsDevice());
}
FontCache::~FontCache()
{
delete glowGlyphTable;
delete strokedGlyphTable;
delete regularGlyphTable;
if (stroker)
FT_Stroker_Done(stroker);
if (alternativeFace)
FT_Done_Face(alternativeFace);
if (primaryFace)
FT_Done_Face(primaryFace);
}
const Glyph* FontCache::GetGlyph(uint32 code)
{
if (const Glyph* result = regularGlyphTable->Find(code))
return result;
else
{
struct SelectFace
{
// 두 Face에서 Code를 찾아서 반환합니다.
static std::pair<FT_Face, unsigned int> Do(FT_Face primary, FT_Face alternative, uint32 code)
{
if (primary)
{
const unsigned int index = FT_Get_Char_Index(primary, code);
if (index != 0)
return std::pair<FT_Face, unsigned int>(primary, index);
}
if (alternative)
{
const unsigned int index = FT_Get_Char_Index(alternative, code);
if (index != 0)
return std::pair<FT_Face, unsigned int>(alternative, index);
}
return std::pair<FT_Face, unsigned int>(nullptr, 0);
}
};
// Grayscale을 보장하는 Bitmap 구조체.
// 원본 Bitmap이 8bpp라면 그대로 보관하고,
// 만약 8pp가 아니라면 8pp로 변환합니다.
// 새로이 생성된 Bitmap은 자동으로 삭제됩니다.
struct GrayscaleBitmap
{
FT_Library Library;
FT_Bitmap* Bitmap;
bool isNewBitmap;
GrayscaleBitmap(FT_Library library, FT_Bitmap& source)
: Library(library)
{
if (source.pixel_mode == FT_PIXEL_MODE_GRAY)
{
Bitmap = &source;
isNewBitmap = false;
}
else
{
Bitmap = new FT_Bitmap();
FT_Bitmap_Convert(Library, &source, Bitmap, 8);
isNewBitmap = true;
const byte scale = static_cast<byte>(255 / (Bitmap->num_grays - 1));
byte* destination = static_cast<byte*>(Bitmap->buffer);
for (int y = 0; y < Bitmap->rows; y++)
{
for (int x = 0; x < Bitmap->width; x++)
{
destination[x] *= scale;
}
destination += Bitmap->pitch;
}
}
}
~GrayscaleBitmap()
{
if (isNewBitmap)
{
FT_Bitmap_Done(Library, Bitmap);
delete Bitmap;
}
}
};
std::pair<FT_Face, unsigned int> faceGlyphIndex = SelectFace::Do(primaryFace, alternativeFace, code);
if (faceGlyphIndex.first == nullptr)
faceGlyphIndex = SelectFace::Do(primaryFace, alternativeFace, L'?');
FT_Int32 loadFlags = FT_LOAD_DEFAULT;
if (parameters.IgnoreBitmap)
loadFlags |= FT_LOAD_NO_BITMAP;
if (parameters.Hinting == false)
loadFlags |= FT_LOAD_NO_HINTING;
FT_Set_Transform(faceGlyphIndex.first, &transform, &ZeroVector);
if (parameters.StrokeSize > 0.0f)
{
FT_Error result = 0;
FT_Glyph strokedGlyph = nullptr;
FT_Load_Glyph(faceGlyphIndex.first, faceGlyphIndex.second, loadFlags | FT_LOAD_NO_BITMAP);
FT_Get_Glyph(faceGlyphIndex.first->glyph, &strokedGlyph);
if (FT_Glyph_Stroke(&strokedGlyph, stroker, 1) == 0)
{
result = FT_Glyph_To_Bitmap(&strokedGlyph, FT_RENDER_MODE_NORMAL, nullptr, 1);
FT_BitmapGlyph strokedGlyphBitmap = reinterpret_cast<FT_BitmapGlyph>(strokedGlyph);
if (parameters.Weights > 0.0f)
FT_Bitmap_Embolden(static_cast<FT_Library>(library->GetFTLibrary()), &strokedGlyphBitmap->bitmap, FloatToF26D6(parameters.Weights), 0);
GrayscaleBitmap glyphBitmap(static_cast<FT_Library>(library->GetFTLibrary()), strokedGlyphBitmap->bitmap);
const Vector2 advance = Vector2(F16D16ToFloat(strokedGlyph->advance.x), F16D16ToFloat(strokedGlyph->advance.y));
const Vector2 bitmapOffset = Vector2(static_cast<float>(strokedGlyphBitmap->left), GetAscender() - static_cast<float>(strokedGlyphBitmap->top));
const Vector2 bitmapSize = Vector2(glyphBitmap.Bitmap->width, glyphBitmap.Bitmap->rows);
strokedGlyphTable->Add(code,
advance, bitmapOffset / parameters.Scale, bitmapSize / parameters.Scale,
glyphBitmap.Bitmap->buffer,
glyphBitmap.Bitmap->width,
glyphBitmap.Bitmap->rows,
glyphBitmap.Bitmap->pitch);
}
FT_Done_Glyph(strokedGlyph);
}
FT_Load_Glyph(faceGlyphIndex.first, faceGlyphIndex.second, loadFlags);
FT_Render_Glyph(faceGlyphIndex.first->glyph, FT_RENDER_MODE_NORMAL);
if (parameters.Weights > 0.0f)
FT_Bitmap_Embolden(static_cast<FT_Library>(library->GetFTLibrary()), &faceGlyphIndex.first->glyph->bitmap, FloatToF26D6(parameters.Weights), 0);
GrayscaleBitmap glyphBitmap(static_cast<FT_Library>(library->GetFTLibrary()), faceGlyphIndex.first->glyph->bitmap);
FT_GlyphSlot renderedGlyph = faceGlyphIndex.first->glyph;
const Vector2 advance = Vector2(F26D6ToFloat(renderedGlyph->advance.x), F26D6ToFloat(renderedGlyph->advance.y));
const Vector2 bitmapOffset = Vector2(static_cast<float>(renderedGlyph->bitmap_left), GetAscender() - static_cast<float>(renderedGlyph->bitmap_top));
const Vector2 bitmapSize = Vector2(glyphBitmap.Bitmap->width, glyphBitmap.Bitmap->rows);
return regularGlyphTable->Add(code,
advance / parameters.Scale, bitmapOffset / parameters.Scale, bitmapSize / parameters.Scale,
glyphBitmap.Bitmap->buffer,
glyphBitmap.Bitmap->width,
glyphBitmap.Bitmap->rows,
glyphBitmap.Bitmap->pitch);
}
}
} | [
"[email protected]"
]
| [
[
[
1,
349
]
]
]
|
aec23cf7cb03642d7eec115cd1e340ae16398516 | 5f1779f2e881e8817e28bd323440e17add991155 | /addons/amxmodx/scripting/uwc3xmod/Storage_MySQL.inl | 583da897a970abb92966084e6ddbbe8863638210 | []
| no_license | AminTaheri1/uwc3x | 21410162c48c9e8f94e9dd338876d88e30b90bff | 49258229e4e378b81862ab5e176c3e10fd2c9457 | refs/heads/master | 2021-01-18T20:12:17.876048 | 2011-01-03T21:01:02 | 2011-01-03T21:01:02 | 34,625,945 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 52,018 | inl | public IsDBConnected ( )
{
if( bDBConn )
{
return true;
}
return false;
}
public LoadSQLVars ( )
{
//Load the Cvars into locally used strings
log_amx( "[UWC3X] SQL PCVARS :: Config Report: host= ( %s ) user= ( %s ) pass= ( * ) db= ( %s )", CVAR_MYSQL_HOSTNAME, CVAR_MYSQL_USERNAME, CVAR_MYSQL_DATABASE );
//Create handle and then the connection
g_SqlTuple = SQL_MakeDbTuple ( CVAR_MYSQL_HOSTNAME, CVAR_MYSQL_USERNAME, CVAR_MYSQL_PASSWORD, CVAR_MYSQL_DATABASE );
//Try and connect
SqlConnection = SQL_Connect ( g_SqlTuple, ErrorCode, g_Error, 511 );
//Check for an error
if ( !SqlConnection )
{
log_amx( "[UWC3X] Error connecting to SQL database : %s", g_Error );
bDBConn = false;
return PLUGIN_CONTINUE;
}
else
{
log_amx( "[UWC3X] SQL :: Connected [OK]" );
bDBConn = true;
}
format ( squery, 5096, "CREATE TABLE IF NOT EXISTS `%s` ( `steamid` VARCHAR ( 32 ) NOT NULL, `xp` INT, `ip` ", CVAR_MYSQL_TABLE );
format ( squery, 5096, "%s%s", squery, "VARCHAR ( 32 ), `mtime` VARCHAR ( 32 ), `skill1` SMALLINT DEFAULT '0', `skill2` SMALLINT " );
format ( squery, 5096, "%s%s", squery, "DEFAULT '0', `skill3` SMALLINT DEFAULT '0', `skill4` SMALLINT DEFAULT '0', `skill5` " );
format ( squery, 5096, "%s%s", squery, "SMALLINT DEFAULT '0', `skill6` SMALLINT DEFAULT '0', `skill7` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill8` SMALLINT DEFAULT '0', `skill9` SMALLINT DEFAULT '0', `skill10` SMALLINT " );
format ( squery, 5096, "%s%s", squery, "DEFAULT '0', `skill11` SMALLINT DEFAULT '0', `skill12` SMALLINT DEFAULT '0', `skill13` " );
format ( squery, 5096, "%s%s", squery, "SMALLINT DEFAULT '0', `skill14` SMALLINT DEFAULT '0', `skill15` SMALLINT DEFAULT '0', " ) ;
format ( squery, 5096, "%s%s", squery, "`skill16` SMALLINT DEFAULT '0', `skill17` SMALLINT DEFAULT '0', `skill18` SMALLINT " );
format ( squery, 5096, "%s%s", squery, "DEFAULT '0', `skill19` SMALLINT DEFAULT '0', `skill20` SMALLINT DEFAULT '0', `skill21` " );
format ( squery, 5096, "%s%s", squery, "SMALLINT DEFAULT '0', `skill22` SMALLINT DEFAULT '0', `skill23` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill24` SMALLINT DEFAULT '0', `skill25` SMALLINT DEFAULT '0', `skill26` SMALLINT " ) ;
format ( squery, 5096, "%s%s", squery, "DEFAULT '0' , `skill27` SMALLINT DEFAULT '0', `skill28` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill29` SMALLINT DEFAULT '0', `skill30` SMALLINT DEFAULT '0', `skill31` SMALLINT " );
format ( squery, 5096, "%s%s", squery, "DEFAULT '0', `skill32` SMALLINT DEFAULT '0', `skill33` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill34` SMALLINT DEFAULT '0', `skill35` SMALLINT DEFAULT '0', `skill36` SMALLINT " );
format ( squery, 5096, "%s%s", squery, "DEFAULT '0', `skill37` SMALLINT DEFAULT '0', `skill38` SMALLINT DEFAULT '0', " ) ;
format ( squery, 5096, "%s%s", squery, "`skill39` SMALLINT DEFAULT '0', `skill40` SMALLINT DEFAULT '0', `skill41` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill42` SMALLINT DEFAULT '0', `skill43` SMALLINT DEFAULT '0', `skill44` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill45` SMALLINT DEFAULT '0', `skill46` SMALLINT DEFAULT '0', `skill47` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill48` SMALLINT DEFAULT '0', `skill49` SMALLINT DEFAULT '0', `skill50` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill51` SMALLINT DEFAULT '0', `skill52` SMALLINT DEFAULT '0', `skill53` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill54` SMALLINT DEFAULT '0', `skill55` SMALLINT DEFAULT '0', `skill56` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill57` SMALLINT DEFAULT '0', `skill58` SMALLINT DEFAULT '0', `skill59` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill60` SMALLINT DEFAULT '0', `skill61` SMALLINT DEFAULT '0', `skill62` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill63` SMALLINT DEFAULT '0', `skill64` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`att1` SMALLINT DEFAULT '0', `att2` SMALLINT DEFAULT '0', `att3` SMALLINT DEFAULT '0', `att4` SMALLINT " );
format ( squery, 5096, "%s%s", squery, "DEFAULT '0', `att5` SMALLINT DEFAULT '0', `att6` SMALLINT DEFAULT '0', `res1` SMALLINT DEFAULT '0', `res2` SMALLINT " );
format ( squery, 5096, "%s%s", squery, "DEFAULT '0', `res3` SMALLINT DEFAULT '0', `res4` SMALLINT DEFAULT '0', `res5` SMALLINT DEFAULT '0', `res6` SMALLINT DEFAULT '0', `res7` SMALLINT " );
//If save by = 2 (by name) primary key is the name
if( CVAR_SAVE_BY == 2 )
{
format ( squery, 5096, "%s%s", squery, "DEFAULT '0', `name` VARCHAR ( 64 ) DEFAULT NULL, PRIMARY KEY ( `name` ) ) TYPE=MyISAM;" );
}
else
{
format ( squery, 5096, "%s%s", squery, "DEFAULT '0', `name` VARCHAR ( 64 ) DEFAULT NULL, PRIMARY KEY ( `steamid` ) ) TYPE=MyISAM;" );
}
//Set the Query
Query = SQL_PrepareQuery ( SqlConnection, squery );
// run the query
if ( !Query || !SQL_Execute ( Query ) )
{
// if there were any problems
SQL_QueryError ( Query, g_Error, 511 );
log_amx( "[UWC3X] SQL :: Error creating table" );
log_amx( "[UWC3X] Error:: %s", g_Error );
log_amx( "[UWC3X] Query:: %s", squery );
}
else
{
//Free the stuff
SQL_FreeHandle ( Query );
SQL_FreeHandle ( SqlConnection );
}
return PLUGIN_CONTINUE;
}
public SkillSetsMySQL_Table ( )
{
if( CVAR_SAVED_SKILLSETS )
{
log_amx( "[UWC3X] SQL :: Using Saved Skill Sets [OK]" );
//Create handle and then the connection
g_SqlTuple = SQL_MakeDbTuple ( CVAR_MYSQL_HOSTNAME, CVAR_MYSQL_USERNAME, CVAR_MYSQL_PASSWORD, CVAR_MYSQL_DATABASE );
//Try and connect
SqlConnection = SQL_Connect ( g_SqlTuple, ErrorCode, g_Error, 511 );
//Check for an error
if ( !SqlConnection )
{
log_amx( "[UWC3X] SQL :: Created Skill Sets Table [FAILED]" );
log_amx( "[UWC3X] Error connecting to SQL database : %s", g_Error );
bDBConn = false;
return PLUGIN_CONTINUE;
}
log_amx( "[UWC3X] SQL :: Connected [OK]" );
if( CVAR_SAVE_BY == 2 )
{
format ( squery, 5096, "CREATE TABLE IF NOT EXISTS `%s_SkillSets` ( `name` VARCHAR(64), `skillsetid` INTEGER , ", CVAR_MYSQL_TABLE );
}
else
{
format ( squery, 5096, "CREATE TABLE IF NOT EXISTS `%s_SkillSets` ( `steamid` VARCHAR(32), `skillsetid` INTEGER , ", CVAR_MYSQL_TABLE );
}
format ( squery, 5096, "%s%s", squery, "`skill1` SMALLINT DEFAULT '0', `skill2` SMALLINT DEFAULT '0', `skill3` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill4` SMALLINT DEFAULT '0', `skill5` SMALLINT DEFAULT '0', `skill6` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill7` SMALLINT DEFAULT '0', `skill8` SMALLINT DEFAULT '0', `skill9` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill10` SMALLINT DEFAULT '0', `skill11` SMALLINT DEFAULT '0', `skill12` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill13` SMALLINT DEFAULT '0', `skill14` SMALLINT DEFAULT '0', `skill15` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill16` SMALLINT DEFAULT '0', `skill17` SMALLINT DEFAULT '0', `skill18` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill19` SMALLINT DEFAULT '0', `skill20` SMALLINT DEFAULT '0', `skill21` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill22` SMALLINT DEFAULT '0', `skill23` SMALLINT DEFAULT '0', `skill24` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill25` SMALLINT DEFAULT '0', `skill26` SMALLINT DEFAULT '0', `skill27` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill28` SMALLINT DEFAULT '0', `skill29` SMALLINT DEFAULT '0', `skill30` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill31` SMALLINT DEFAULT '0', `skill32` SMALLINT DEFAULT '0', `skill33` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill34` SMALLINT DEFAULT '0', `skill35` SMALLINT DEFAULT '0', `skill36` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill37` SMALLINT DEFAULT '0', `skill38` SMALLINT DEFAULT '0', `skill39` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill40` SMALLINT DEFAULT '0', `skill41` SMALLINT DEFAULT '0', `skill42` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill43` SMALLINT DEFAULT '0', `skill44` SMALLINT DEFAULT '0', `skill45` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill46` SMALLINT DEFAULT '0', `skill47` SMALLINT DEFAULT '0', `skill48` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill49` SMALLINT DEFAULT '0', `skill50` SMALLINT DEFAULT '0', `skill51` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill52` SMALLINT DEFAULT '0', `skill53` SMALLINT DEFAULT '0', `skill54` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill55` SMALLINT DEFAULT '0', `skill56` SMALLINT DEFAULT '0', `skill57` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill58` SMALLINT DEFAULT '0', `skill59` SMALLINT DEFAULT '0', `skill60` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill61` SMALLINT DEFAULT '0', `skill62` SMALLINT DEFAULT '0', `skill63` SMALLINT DEFAULT '0', " );
format ( squery, 5096, "%s%s", squery, "`skill64` SMALLINT DEFAULT '0' ) TYPE=MyISAM;" );
//Set the Query
Query = SQL_PrepareQuery ( SqlConnection, squery );
// run the query
if ( !Query || !SQL_Execute ( Query ) )
{
// if there were any problems
SQL_QueryError ( Query, g_Error, 511 );
log_amx( "[UWC3X] SQL :: Error creating table" );
log_amx( "[UWC3X] Error:: %s", g_Error );
log_amx( "[UWC3X] Query:: %s", squery );
}
else
{
//Free the stuff
SQL_FreeHandle ( Query );
SQL_FreeHandle ( SqlConnection );
}
log_amx( "[UWC3X] SQL :: Created Skill Sets Table [OK]" );
return PLUGIN_CONTINUE;
}
else
{
log_amx( "[UWC3X] SQL :: Using Saved Skill Sets [NO]" );
return PLUGIN_CONTINUE;
}
return PLUGIN_CONTINUE;
}
public CreateTable ( FailState, Handle:Query, Error[], Errcode, Data[], DataSize )
{
if( FailState )
{
new sQuery[4096];
new sFunction[32];
copy(sFunction, 31, "CreateTable");
SQL_GetQueryString( Query, sQuery, 255 );
LogError( Query, sQuery, Error, Errcode, FailState, sFunction );
}
return PLUGIN_CONTINUE;
}
public RunQuerry ( FailState, Handle:Query, Error[], Errcode, Data[], DataSize )
{
if( FailState )
{
new sQuery[4096];
new sFunction[32];
copy(sFunction, 31, "RunQuerry");
SQL_GetQueryString( Query, sQuery, 255 );
LogError( Query, sQuery, Error, Errcode, FailState, sFunction );
}
return PLUGIN_CONTINUE;
}
public _LoadXP ( FailState, Handle:Query, Error[], Errcode, Data[], DataSize )
{
new id = player_id;
new ip[32];
new xp = 0;
new pid[32];
new skills[MAX_SKILLS] = 0;
new att[MAX_ATTRIBS] = 0;
new res[MAX_RESISTS] = 0;
new tempVar[64];
new tempVar44[64], tempVar55[64];
get_user_name ( id, tempVar44, 63 );
get_user_authid ( id, tempVar55, 63 );
//if ( CVAR_DEBUG_MODE )
//{
log_amx( "[UWC3X] DEBUG: MySQL->_LoadXP: Attempting to load XP " );
//}
// error checking
if(FailState == TQUERY_CONNECT_FAILED)
{
log_amx( "[UWC3X] Error: Could not connect to SQL database in LoadXPHandle.");
if( Util_Should_Msg_Client(id) )
{
//client_print(id, print_chat, "%L", id, "LOAD_XP_FAILURE" );
hudchat_show(id, "%L", id, "LOAD_XP_FAILURE");
hudchat_update(id);
}
log_amx( "[UWC3X] DEBUG :: MySQL LoadXPMySQL -> :: [END]^n" );
return PLUGIN_HANDLED;
}
else if(FailState == TQUERY_QUERY_FAILED)
{
log_amx( "[UWC3X] SQL :: Error in LoadXPHandle");
SQL_QueryError(Query,g_Error,511);
log_amx( "[UWC3X] ERROR %s",g_Error);
if( Util_Should_Msg_Client(id) )
{
//client_print(id, print_chat, "%L", id, "LOAD_XP_FAILURE" );
hudchat_show(id, "%L", id, "LOAD_XP_FAILURE");
hudchat_update(id);
}
log_amx( "[UWC3X] DEBUG :: MySQL LoadXPMySQL -> :: [END]^n" );
return PLUGIN_HANDLED;
}
if(Errcode)
{
log_amx( "[UWC3X] Error:_LoadXP - %d", Errcode);
log_amx( "[UWC3X] DEBUG :: MySQL LoadXPMySQL -> :: [END]^n" );
return PLUGIN_HANDLED;
}
//if ( CVAR_DEBUG_MODE )
//{
get_user_name ( id, tempVar, 63 );
log_amx( "[UWC3X] Debug :: _LoadXP : No error, attepting to load XP and skills for %s", tempVar );
//}
//Now that we have no errors, I will reset the xp loading var, this is in case there are
//errors so that it will continue to retry
NumResults = SQL_NumResults(Query);
if ( CVAR_DEBUG_MODE )
{
log_amx( "[UWC3X] DEBUG :: MySQL->_LoadXP: NumResults=%d", NumResults);
}
if ( !NumResults || NumResults == 0 || is_user_bot( id ) )
{
//no data exists
if( Util_Should_Msg_Client(id) )
{
//client_print ( id, print_chat, "%L", id, "LOAD_XP_NO_DATA", MOD );
hudchat_show(id, "%L", id, "LOAD_XP_NO_DATA");
hudchat_update(id);
}
if ( CVAR_DEBUG_MODE && is_user_bot( id ) )
{
log_amx( "[UWC3X] DEBUG: MySQL->_LoadXP: Player is a bot");
}
if ( CVAR_ENABLE_STARTING_SYSTEM )
{
if( CVAR_STARTING_METHOD == 1 )
{
if ( CVAR_DEBUG_MODE )
{
log_amx( "[UWC3X] DEBUG: MySQL->_LoadXP: No Records, client %s given %d starting XP ", tempVar, CVAR_STARTING_XP);
}
if( Util_Should_Msg_Client(id) )
{
//client_print(id, print_chat, "%L", id, "LOAD_XP_STARTING_XP", MOD, CVAR_STARTING_XP );
hudchat_show(id, "%L", id, "LOAD_XP_STARTING_XP", CVAR_STARTING_XP);
hudchat_update(id);
}
playerxp[id] = CVAR_STARTING_XP;
}
else
{
//Override default level if its a bot and use the bot level cvar
if( is_user_bot(id) )
{
if ( CVAR_DEBUG_MODE )
{
log_amx( "[UWC3X] DEBUG: MySQL->_LoadXP: Player is BOT - > BOT %s set to level %d", tempVar, CVAR_BOT_LEVEL);
}
playerxp[id] = xplevel_lev[CVAR_BOT_LEVEL];
}
else
{
if ( CVAR_DEBUG_MODE )
{
log_amx( "[UWC3X] DEBUG: MySQL->_LoadXP: No Records, client %s set to level %d", tempVar, CVAR_STARTING_LEVEL);
}
if( Util_Should_Msg_Client(id) )
{
//client_print(id, print_chat, "%L", id, "LOAD_XP_STARTING_LEVEL", MOD, CVAR_STARTING_LEVEL );
hudchat_show(id, "%L", id, "LOAD_XP_STARTING_LEVEL", CVAR_STARTING_LEVEL);
hudchat_update(id);
}
playerxp[id] = xplevel_lev[CVAR_STARTING_LEVEL];
}
}
}
Set_Ult_Count( id );
xpreadytoload[id] = 0;
log_amx( "[UWC3X] DEBUG :: MySQL LoadXPMySQL -> name %s auth %s :: [END]^n", tempVar44, tempVar55 );
return PLUGIN_CONTINUE;
}
else
{
new sName[64];
//They have data, lets load it
//Set the PlayerID, XP, IP, and Last time
SQL_ReadResult ( Query, 0, pid, 31 );
xp = SQL_ReadResult ( Query, 1 );
SQL_ReadResult ( Query, 2, ip, 31 );
SQL_ReadResult ( Query, 3, mtimet, 31 );
SQL_ReadResult ( Query, 72, sName, 63 );
//Now loading based on field name, and not on position
new temp[32], sqlField;
//Start setting the skills
for ( new k = 1; k < (MAX_SKILLS); k++ )
{
format( temp, 31, "skill%d", k);
sqlField = SQL_FieldNameToNum(Query, temp)
skills[k] = SQL_ReadResult ( Query, sqlField );
}
//Set the attributes
for ( new k = 1; k < (MAX_ATTRIBS); k++ )
{
format( temp, 31, "att%d", k);
sqlField = SQL_FieldNameToNum(Query, temp)
att[k] = SQL_ReadResult ( Query, sqlField );
//If the attrib is less then the base, or greater then max, reset to base
if( ( ATTRIB_MAX_VALUE < att[k] ) || ( att[k] < ATTRIB_BASE ) )
att[k] = ATTRIB_BASE;
}
//Set the resistances
for ( new k = 1; k < (MAX_RESISTS); k++ )
{
format( temp, 31, "res%d", k);
sqlField = SQL_FieldNameToNum(Query, temp)
res[k] = SQL_ReadResult ( Query, sqlField );
}
//If starting XP is enabled, do the check
if ( CVAR_ENABLE_STARTING_SYSTEM )
{
if( CVAR_STARTING_METHOD == 1 )
{
//It is enabled and its set to XP based, so check to see if the starting XP is higher then what they have now
if ( xp < CVAR_STARTING_XP )
{
//it must be, so lets set their XP and let them know
xp = CVAR_STARTING_XP;
if( Util_Should_Msg_Client(id) )
{
//client_print ( id, print_chat, "[%s] %L", id, MOD, "STARTING_XP_MESSAGE", CVAR_STARTING_XP );
hudchat_show(id, "%L", id, "STARTING_XP_MESSAGE", CVAR_STARTING_XP);
hudchat_update(id);
}
}
}
else
{
//Override default level if its a bot and use the bot level cvar
if( is_user_bot(id))
{
xp = xplevel_lev[CVAR_BOT_LEVEL];
}
else
{
//It is enabled and its set to XP based, so check to see if the starting XP is higher then what they have now
if ( xp < xplevel_lev[CVAR_STARTING_LEVEL] )
{
//it must be, so lets set their XP and let them know
xp = xplevel_lev[CVAR_STARTING_LEVEL];
if( Util_Should_Msg_Client(id) )
{
//client_print ( id, print_chat, "[%s] %L", id, MOD, "STARTING_LEVEL_MESSAGE", xp );
hudchat_show(id, "%L", id, "STARTING_LEVEL_MESSAGE", xp);
hudchat_update(id);
}
}
}
}
}
playerxp[id] = xp;
displaylevel ( id, 0 );
p_attribs[id] = att;
p_resists[id] = res;
}
p_skills[id] = skills;
//Check for admin only skills, if they have any, dont add them to the users skill array
for ( new i = 1; i < MAX_SKILLS; i++ )
{
if ( CVAR_ENABLE_ADMIN_ONLY_SKILLS )
{
if ( !admin_only[p_skills[id][i]] || (get_user_flags(id) & CVAR_ADMIN_SKILL_FLAG ) )
{
skills[i] = p_skills[id][i];
}
}
if ( ( p_skills[id][i] >= 1 ) && ( skill_ultimates[i][0] ) && ( !admin_only[p_skills[id][i]] || (get_user_flags(id) & CVAR_ADMIN_SKILL_FLAG ) ) )
{
if( Util_Should_Msg_Client(id) )
{
client_print ( id, print_console, "%L", id, "ULTIMATE_RETRIEVED", MOD, skill_ultimates[i][0] );
}
ultlearned[id]++;
Set_Ult_Count( id );
}
}
Set_Ult_Count( id );
p_skills[id] = skills;
xpreadytoload[id] = 0;
log_amx( "[UWC3X] DEBUG :: MySQL LoadXPMySQL -> name %s auth %s :: [END]^n", tempVar44, tempVar55 );
return PLUGIN_CONTINUE;
}
public _SaveXP ( FailState, Handle:Query, Error[], Errcode, Data[], DataSize )
{
// error checking
if(FailState == TQUERY_CONNECT_FAILED)
{
log_amx( "[UWC3X] Error: Could not connect to SQL database in SaveXPHandle.");
if( is_user_connected( player_id ) && !is_user_bot( player_id ) )
{
//client_print(player_id, print_chat, "%L", player_id, "SAVE_XP_FAILURE" );
hudchat_show(player_id, "%L", player_id, "SAVE_XP_FAILURE");
hudchat_update(player_id);
}
return PLUGIN_HANDLED;
}
else if(FailState == TQUERY_QUERY_FAILED)
{
log_amx( "[UWC3X] SQL :: Error in SaveXPHandle");
SQL_QueryError(Query,g_Error,511);
log_amx( "[UWC3X] ERROR %s",g_Error);
if( is_user_connected( player_id ) && !is_user_bot( player_id ) )
{
//client_print(player_id, print_chat, "%L", player_id, "SAVE_XP_FAILURE" );
hudchat_show(player_id, "%L", player_id, "SAVE_XP_FAILURE");
hudchat_update(player_id);
}
return PLUGIN_HANDLED;
}
else
{
if( CVAR_DEBUG_MODE )
{
log_amx( "[UWC3X] DEBUG :: MySQL _SaveXP -> No Error" );
}
}
if(Errcode )
{
log_amx( "[UWC3X] Error:SaveXPHandle - %s",Error);
return PLUGIN_HANDLED;
}
return PLUGIN_CONTINUE;
}
public LoadXPMySQL2( id )
{
if ( CVAR_ENABLE_UWC3X != 1 )
{
return PLUGIN_HANDLED;
}
if ( CVAR_SAVE_XP != 1 )
{
return PLUGIN_CONTINUE;
}
new tempVar[64], tempVar2[64];
get_user_name ( id, tempVar2, 63 );
log_amx( "[UWC3X] SQL :: Loading XP for user %s :: [Start]", tempVar2);
if( CVAR_SAVE_BY == 2 )
{
copy( tempVar, 32, "name");
get_user_name ( id, tempVar2, 63 );
remove_quotes(tempVar2);
while(replace(tempVar2,63,"'","")) { }
while(replace(tempVar2,63,")","")) { }
while(replace(tempVar2,63,"(","")) { }
while(replace(tempVar2,63,";","")) { }
}
else
{
copy( tempVar, 32, "steamid");
get_user_authid ( id, tempVar2, 63 );
}
format ( squery, 4096, "SELECT steamid, xp, ip, mtime, skill1, skill2, skill3," );
format ( squery, 4096, "%s skill4, skill5, skill6, skill7, skill8, skill9, skill10, ", squery );
format ( squery, 4096, "%s skill11, skill12, skill13, skill14, skill15, skill16, skill17,", squery );
format ( squery, 4096, "%s skill18, skill19, skill20, skill21, skill22, skill23, skill24,", squery );
format ( squery, 4096, "%s skill25, skill26, skill27, skill28, skill29, skill30, skill31,", squery );
format ( squery, 4096, "%s skill32, skill33, skill34, skill35, skill36, skill37, skill38,", squery );
format ( squery, 4096, "%s skill39, skill40, skill41, skill42, skill43, skill44, skill45,", squery );
format ( squery, 4096, "%s skill46, skill47, skill48, skill49, skill50, skill51, skill52,", squery );
format ( squery, 4096, "%s skill53, skill54, skill55, skill56, skill57, skill58, skill59,", squery );
format ( squery, 4096, "%s skill60, skill61, skill62, skill63, skill64,", squery );
format ( squery, 4096, "%s att1, att2, att3, att4, att5, att6, res1, res2,", squery );
format ( squery, 4096, "%s res3, res4, res5, res6, res7, name FROM %s WHERE %s = '%s';", squery, CVAR_MYSQL_TABLE, tempVar, tempVar2 );
player_id = id;
//Create handle and then the connection
g_SqlTuple = SQL_MakeDbTuple ( CVAR_MYSQL_HOSTNAME, CVAR_MYSQL_USERNAME, CVAR_MYSQL_PASSWORD, CVAR_MYSQL_DATABASE );
//Try and connect
SqlConnection = SQL_Connect ( g_SqlTuple, ErrorCode, g_Error, 511 );
//Check for an error
if ( !SqlConnection )
{
log_amx( "[UWC3X] SQL :: Loading XP :: Connected [FAILED]" );
log_amx( "[UWC3X] Error connecting to SQL database : %s", g_Error );
return PLUGIN_CONTINUE;
}
//Set the Query
Query = SQL_PrepareQuery ( SqlConnection, squery );
// run the query
if ( !Query || !SQL_Execute ( Query ) )
{
// if there were any problems
SQL_QueryError ( Query, g_Error, 511 );
log_amx( "[UWC3X] SQL :: Error Loading players XP" );
log_amx( "[UWC3X] Error:: %s", g_Error );
log_amx( "[UWC3X] Query:: %s", squery );
}
else
{
new id = player_id;
new ip[32];
new xp = 0;
new pid[32];
new skills[MAX_SKILLS] = 0;
new att[MAX_ATTRIBS] = 0;
new res[MAX_RESISTS] = 0;
//Now that we have no errors, I will reset the xp loading var, this is in case there are
//errors so that it will continue to retry
NumResults = SQL_NumResults(Query);
if ( CVAR_DEBUG_MODE && is_user_bot( id ) )
{
log_amx( "[UWC3X] DEBUG: MySQL->_LoadXP: NumResults=%d", NumResults);
}
if ( !NumResults || NumResults == 0 || is_user_bot( id ) )
{
//no data exists
if( Util_Should_Msg_Client(id) )
{
//client_print ( id, print_chat, "%L", id, "LOAD_XP_NO_DATA", MOD );
hudchat_show(player_id, "%L", player_id, "LOAD_XP_NO_DATA");
hudchat_update(player_id);
}
//If the enable starting XP is turned on, then give them the XP
// this is for new players who do not yet exist in the database, existing players are below
if ( CVAR_DEBUG_MODE )
{
log_amx( "[UWC3X] DEBUG: MySQL->_LoadXP: Player is a bot or has no results from query");
}
//If starting XP is enabled, do the check
if ( CVAR_ENABLE_STARTING_SYSTEM )
{
if( CVAR_STARTING_METHOD == 1 )
{
//It is enabled and its set to XP based, so check to see if the starting XP is higher then what they have now
if ( xp < CVAR_STARTING_XP )
{
//it must be, so lets set their XP and let them know
xp = CVAR_STARTING_XP;
if( Util_Should_Msg_Client(id) )
{
//client_print ( id, print_chat, "[%s] %L", id, MOD, "STARTING_XP_MESSAGE", CVAR_STARTING_XP );
hudchat_show(player_id, "%L", player_id, "STARTING_XP_MESSAGE", CVAR_STARTING_XP);
hudchat_update(player_id);
}
}
}
else
{
//Override default level if its a bot and use the bot level cvar
if( is_user_bot(id))
{
xp = xplevel_lev[CVAR_BOT_LEVEL];
}
else
{
//It is enabled and its set to XP based, so check to see if the starting XP is higher then what they have now
if ( xp < xplevel_lev[CVAR_STARTING_LEVEL] )
{
//it must be, so lets set their XP and let them know
xp = xplevel_lev[CVAR_STARTING_LEVEL];
if( Util_Should_Msg_Client(id) )
{
//client_print ( id, print_chat, "[%s] %L", id, MOD, "STARTING_LEVEL_MESSAGE", xp );
hudchat_show(player_id, "%L", player_id, "STARTING_LEVEL_MESSAGE", xp);
hudchat_update(player_id);
}
}
}
}
playerxp[id] = xp;
if ( CVAR_DEBUG_MODE )
{
log_amx( "[UWC3X] DEBUG: MySQL->_LoadXP: Set xp to %d", xp);
}
}
else
{
if( Util_Should_Msg_Client(id) )
{
//client_print ( id, print_chat, "[%s] %L", id, MOD, "STARTING_XP_DISABLED" );
hudchat_show(player_id, "%L", player_id, "STARTING_XP_DISABLED");
hudchat_update(player_id);
}
}
xpreadytoload[id] = 0;
}
else
{
new sName[64];
new temp[32], sqlField;
//They have data, lets load it
//Set the PlayerID, XP, IP, and Last time
SQL_ReadResult ( Query, 0, pid, 31 );
xp = SQL_ReadResult ( Query, 1 );
SQL_ReadResult ( Query, 2, ip, 31 );
SQL_ReadResult ( Query, 3, mtimet, 31 );
copy( temp, 31, "name");
sqlField = SQL_FieldNameToNum(Query, temp)
SQL_ReadResult ( Query, sqlField, sName, 63 );
//Start setting the skills
for ( new k = 1; k < (MAX_SKILLS); k++ )
{
format( temp, 31, "skill%d", k);
sqlField = SQL_FieldNameToNum(Query, temp)
skills[k] = SQL_ReadResult ( Query, sqlField );
}
//Set the attributes
for ( new k = 1; k < (MAX_ATTRIBS); k++ )
{
format( temp, 31, "att%d", k);
sqlField = SQL_FieldNameToNum(Query, temp)
att[k] = SQL_ReadResult ( Query, sqlField );
//If the attrib is less then the base, or greater then max, reset to base
if( ( ATTRIB_MAX_VALUE < att[k] ) || ( att[k] < ATTRIB_BASE ) )
att[k] = ATTRIB_BASE;
}
//Set the resistances
for ( new k = 1; k < (MAX_RESISTS); k++ )
{
format( temp, 31, "res%d", k);
sqlField = SQL_FieldNameToNum(Query, temp)
res[k] = SQL_ReadResult ( Query, sqlField );
}
if ( CVAR_ENABLE_STARTING_SYSTEM )
{
if( CVAR_STARTING_METHOD == 1 )
{
if ( CVAR_DEBUG_MODE )
{
log_amx( "[UWC3X] DEBUG: MySQL->_LoadXP: No Records, client %s given %d starting XP ", tempVar, CVAR_STARTING_XP);
}
if( Util_Should_Msg_Client(id) )
{
//client_print(id, print_chat, "%L", "LOAD_XP_STARTING_XP", MOD, CVAR_STARTING_XP );
hudchat_show(id, "%L", id, "LOAD_XP_STARTING_XP", CVAR_STARTING_XP);
hudchat_update(id);
}
playerxp[id] = CVAR_STARTING_XP;
}
else
{
//Override default level if its a bot and use the bot level cvar
if( is_user_bot(id))
{
playerxp[id] = xplevel_lev[CVAR_BOT_LEVEL];
}
else
{
if( Util_Should_Msg_Client(id) )
{
//client_print(id, print_chat, "%L", "LOAD_XP_STARTING_LEVEL", MOD, CVAR_STARTING_LEVEL );
hudchat_show(id, "%L", id, "LOAD_XP_STARTING_LEVEL", CVAR_STARTING_LEVEL);
hudchat_update(id);
}
playerxp[id] = xplevel_lev[CVAR_STARTING_LEVEL];
}
}
}
playerxp[id] = xp;
displaylevel ( id, 0 );
p_attribs[id] = att;
p_resists[id] = res;
}
//Set Player Value
Set_Wisdom_Bonuses( id );
p_skills[id] = skills;
//Check for admin only skills, if they have any, dont add them to the users skill array
for ( new i = 1; i < MAX_SKILLS; i++ )
{
if ( CVAR_ENABLE_ADMIN_ONLY_SKILLS )
{
if ( !admin_only[p_skills[id][i]] )
{
skills[i] = p_skills[id][i];
}
}
if ( ( p_skills[id][i] >= 1 ) && ( skill_ultimates[i][0] ) && ( !admin_only[p_skills[id][i]] ) )
{
if( Util_Should_Msg_Client(id) )
{
client_print ( id, print_console, "%L", id, "ULTIMATE_RETRIEVED", MOD, skill_ultimates[i][0] );
}
}
}
Set_Ult_Count( id );
p_skills[id] = skills;
xpreadytoload[id] = 0;
if( CVAR_DEBUG_MODE )
{
log_amx( "[UWC3X] DEBUG :: MySQL -> Ultimates allowed after loading = %d", ultlearned[id] );
}
//Free the stuff
SQL_FreeHandle ( Query );
SQL_FreeHandle ( SqlConnection );
}
log_amx( "[UWC3X] SQL :: Loading XP :: [Done]" );
return PLUGIN_CONTINUE;
}
public LoadXPMySQL ( id )
{
if ( CVAR_ENABLE_UWC3X != 1 )
{
return PLUGIN_HANDLED;
}
if ( CVAR_SAVE_XP != 1 )
{
return PLUGIN_CONTINUE;
}
new tempVar[64], tempVar2[64];
get_user_name ( id, tempVar, 63 );
get_user_authid ( id, tempVar2, 63 );
log_amx( "[UWC3X] DEBUG :: MySQL LoadXPMySQL -> name %s auth %s :: [Start]", tempVar, tempVar2 );
if( CVAR_SAVE_BY == 2 )
{
copy( tempVar, 32, "name");
get_user_name ( id, tempVar2, 63 );
remove_quotes(tempVar2);
while(replace(tempVar2,63,"'","")) { }
while(replace(tempVar2,63,")","")) { }
while(replace(tempVar2,63,"(","")) { }
while(replace(tempVar2,63,";","")) { }
}
else
{
copy( tempVar, 32, "steamid");
get_user_authid ( id, tempVar2, 63 );
}
format ( squery, 4096, "SELECT steamid, xp, ip, mtime, skill1, skill2, skill3," );
format ( squery, 4096, "%s skill4, skill5, skill6, skill7, skill8, skill9, skill10, ", squery );
format ( squery, 4096, "%s skill11, skill12, skill13, skill14, skill15, skill16, skill17,", squery );
format ( squery, 4096, "%s skill18, skill19, skill20, skill21, skill22, skill23, skill24,", squery );
format ( squery, 4096, "%s skill25, skill26, skill27, skill28, skill29, skill30, skill31,", squery );
format ( squery, 4096, "%s skill32, skill33, skill34, skill35, skill36, skill37, skill38,", squery );
format ( squery, 4096, "%s skill39, skill40, skill41, skill42, skill43, skill44, skill45,", squery );
format ( squery, 4096, "%s skill46, skill47, skill48, skill49, skill50, skill51, skill52,", squery );
format ( squery, 4096, "%s skill53, skill54, skill55, skill56, skill57, skill58, skill59,", squery );
format ( squery, 4096, "%s skill60, skill61, skill62, skill63, skill64,", squery );
format ( squery, 4096, "%s att1, att2, att3, att4, att5, att6, res1, res2,", squery );
format ( squery, 4096, "%s res3, res4, res5, res6, res7, name FROM %s WHERE %s = '%s';", squery, CVAR_MYSQL_TABLE, tempVar, tempVar2 );
player_id = id;
SQL_ThreadQuery ( g_SqlTuple, "_LoadXP", squery );
return PLUGIN_CONTINUE;
}
public SaveXPMySQL ( id )
{
if ( CVAR_ENABLE_UWC3X != 1 )
{
return PLUGIN_HANDLED;
}
if ( CVAR_SAVE_XP != 1 )
{
return PLUGIN_CONTINUE;
}
new tempVar[64];
get_user_name ( id, tempVar, 63 );
get_user_authid ( id, steamid, 34 );
remove_quotes(tempVar);
while(replace(tempVar,63,"'","")) { }
while(replace(tempVar,63,")","")) { }
while(replace(tempVar,63,"(","")) { }
while(replace(tempVar,63,";","")) { }
if ( CVAR_ENABLE_STARTING_SYSTEM )
{
if( CVAR_STARTING_METHOD == 1 )
{
if ( playerxp[id] <= CVAR_STARTING_XP )
{
playerxp[id] = CVAR_STARTING_XP;
}
}
else
{
if( is_user_bot( id ))
{
if ( playerxp[id] <= xplevel_lev[CVAR_BOT_LEVEL] )
{
playerxp[id] = xplevel_lev[CVAR_BOT_LEVEL];
}
}
else
{
//If they are a bot, then dont save, always use the bot level insetead to set XP
if( is_user_bot( id ))
{
playerxp[id] = xplevel_lev[CVAR_BOT_LEVEL];
if( CVAR_DEBUG_MODE )
{
log_amx( "[UWC3X] DEBUG :: MySQL SaveXPMySQL -> is_user_bot1 name %s auth %s xp %d", tempVar, steamid, playerxp[id] );
}
}
else
{
//if( CVAR_DEBUG_MODE )
//{
log_amx( "[UWC3X] DEBUG :: MySQL SaveXPMySQL -> User is Human - name %s auth %s xp %d", tempVar, steamid, playerxp[id] );
//}
if ( playerxp[id] <= xplevel_lev[CVAR_STARTING_LEVEL] )
{
playerxp[id] = xplevel_lev[CVAR_STARTING_LEVEL];
}
}
}
}
}
get_time ( "%d/%m/%Y %H:%M:%S", mtimet, 31 );
format ( squery, 4096, "REPLACE INTO `%s` SET steamid='%s', xp='%d',", CVAR_MYSQL_TABLE, steamid, playerxp[id] );
format ( squery, 4096, "%s mtime='%s' , skill1='%d' , skill2='%d' ,", squery, mtimet, p_skills[id][1], p_skills[id][2] ) ;
format ( squery, 4096, "%s skill3='%d' , skill4='%d' , skill5='%d' ,", squery,p_skills[id][3], p_skills[id][4], p_skills[id][5] );
format ( squery, 4096, "%s skill6='%d' , skill7='%d' , skill8='%d' ,", squery,p_skills[id][6], p_skills[id][7], p_skills[id][8] );
format ( squery, 4096, "%s skill9='%d' , skill10='%d', skill11='%d',", squery,p_skills[id][9], p_skills[id][10], p_skills[id][11] );
format ( squery, 4096, "%s skill12='%d', skill13='%d', skill14='%d',", squery,p_skills[id][12], p_skills[id][13], p_skills[id][14] );
format ( squery, 4096, "%s skill15='%d', skill16='%d', skill17='%d',", squery,p_skills[id][15], p_skills[id][16], p_skills[id][17] ) ;
format ( squery, 4096, "%s skill18='%d', skill19='%d', skill20='%d',", squery,p_skills[id][18], p_skills[id][19], p_skills[id][20] );
format ( squery, 4096, "%s skill21='%d', skill22='%d', skill23='%d',", squery,p_skills[id][21], p_skills[id][22], p_skills[id][23] );
format ( squery, 4096, "%s skill24='%d', skill25='%d', skill26='%d',", squery,p_skills[id][24], p_skills[id][25], p_skills[id][26] );
format ( squery, 4096, "%s skill27='%d', skill28='%d', skill29='%d',", squery,p_skills[id][27], p_skills[id][28], p_skills[id][29] );
format ( squery, 4096, "%s skill30='%d', skill31='%d', skill32='%d',", squery,p_skills[id][30], p_skills[id][31], p_skills[id][32] );
format ( squery, 4096, "%s skill33='%d', skill34='%d', skill35='%d',", squery,p_skills[id][33], p_skills[id][34], p_skills[id][35] );
format ( squery, 4096, "%s skill36='%d', skill37='%d', skill38='%d',", squery,p_skills[id][36], p_skills[id][37], p_skills[id][38] );
format ( squery, 4096, "%s skill39='%d', skill40='%d', skill41='%d',", squery,p_skills[id][39], p_skills[id][40], p_skills[id][41] );
format ( squery, 4096, "%s skill42='%d', skill43='%d', skill44='%d',", squery,p_skills[id][42], p_skills[id][43], p_skills[id][44] );
format ( squery, 4096, "%s skill45='%d', skill46='%d', skill47='%d',", squery,p_skills[id][45], p_skills[id][46], p_skills[id][47] );
format ( squery, 4096, "%s skill48='%d', skill49='%d', skill50='%d',", squery,p_skills[id][48], p_skills[id][49], p_skills[id][50] );
format ( squery, 4096, "%s skill51='%d', skill52='%d', skill53='%d',", squery,p_skills[id][51], p_skills[id][52], p_skills[id][53] );
format ( squery, 4096, "%s skill54='%d', skill55='%d', skill56='%d',", squery, p_skills[id][54],p_skills[id][55], p_skills[id][56] );
format ( squery, 4096, "%s skill57='%d', skill58='%d', skill59='%d',", squery,p_skills[id][57], p_skills[id][58], p_skills[id][59] );
format ( squery, 4096, "%s skill60='%d', skill61='%d', skill62='%d',", squery,p_skills[id][60], p_skills[id][61], p_skills[id][62] );
format ( squery, 4096, "%s skill63='%d', skill64='%d', ", squery, p_skills[id][63],p_skills[id][64] );
format ( squery, 4096, "%s att1='%d' , att2='%d' , att3='%d' , att4='%d' ,", squery, p_attribs[id][ATTRIBIDX_STR], p_attribs[id][ATTRIBIDX_INT], p_attribs[id][ATTRIBIDX_DEX], p_attribs[id][ATTRIBIDX_AGI] );
format ( squery, 4096, "%s att5='%d' , att6='%d' , res1='%d' , res2='%d' ,", squery, p_attribs[id][ATTRIBIDX_CON], p_attribs[id][ATTRIBIDX_WIS], p_resists[id][RESISTIDX_POISON], p_resists[id][RESISTIDX_DISEASE] );
format ( squery, 4096, "%s res3='%d' , res4='%d' , res5='%d' , res6='%d', res7='%d', name='%s' ;", squery, p_resists[id][RESISTIDX_ELECTRIC], p_resists[id][RESISTIDX_FIRE], p_resists[id][RESISTIDX_MAGIC], p_resists[id][RESISTIDX_ROT],p_resists[id][RESISTIDX_ICE], tempVar );
player_id = id;
SQL_ThreadQuery ( g_SqlTuple, "_SaveXP", squery );
return PLUGIN_CONTINUE;
}
public LogError( Handle:Query, sQuery[], sError[], iErrNum, failstate, sFunction[] )
{
log_amx( "[UWC3X] Threaded query error, location: %s", sFunction );
log_amx( "[UWC3X] Message: %s (%d)", sError, iErrNum );
log_amx( "[UWC3X] Query statement: %s ", sQuery );
// Connection failed
if ( failstate == TQUERY_CONNECT_FAILED )
{
log_amx( "[UWC3X] Fail state: Connection Failed" );
}
// Query failed
else if ( failstate == TQUERY_QUERY_FAILED )
{
log_amx( "[UWC3X] Fail state: Query Failed" );
}
// Free the handle
SQL_FreeHandle( Query );
}
public MySQLClose()
{
if ( g_SqlTuple )
{
SQL_FreeHandle( g_SqlTuple );
}
if ( SqlConnection )
{
SQL_FreeHandle( SqlConnection );
}
}
public TableHandle(FailState,Handle:Query,Error[],Errcode,Data[],DataSize)
{
// lots of error checking
if(FailState == TQUERY_CONNECT_FAILED)
{
log_amx( "[UWC3X] Error: Could not connect to SQL database in TableHandle.");
set_fail_state("Could not connect to SQL database in TableHandle.");
}
else if(FailState == TQUERY_QUERY_FAILED)
{
log_amx( "[UWC3X] SQL :: Error creating table.");
SQL_QueryError(Query,g_Error,511);
log_amx( "[UWC3X] ERROR %s",g_Error);
set_fail_state("Could not execute query in TableHandle.");
}
if(Errcode)
log_amx( "[UWC3X] TableHandle - Error on query: %s",Error);
return PLUGIN_CONTINUE;
}
public QueryHandle(FailState,Handle:Query,Error[],Errcode,Data[],DataSize)
{
// lots of error checking
if(FailState == TQUERY_CONNECT_FAILED)
{
log_amx( "[UWC3X] Error: Could not connect to SQL database in QueryHandle.");
set_fail_state("Could not connect to SQL database in QueryHandle.");
}
else if(FailState == TQUERY_QUERY_FAILED)
{
log_amx( "[UWC3X] SQL :: Error in QueryHandle");
SQL_QueryError(Query,g_Error,511);
log_amx( "[UWC3X] ERROR %s",g_Error);
set_fail_state("Could not execute query in QueryHandle.");
}
if(Errcode)
log_amx( "[UWC3X] Error: QueryHandle - Code %d", ErrorCode);
return PLUGIN_CONTINUE;
}
public _SaveSkillSet( FailState, Handle:Query, Error[], Errcode, Data[], DataSize )
{
// lots of error checking
if(FailState == TQUERY_CONNECT_FAILED)
{
log_amx( "[UWC3X] Error: Could not connect to SQL database in _SaveSkillSet.");
if( Util_Should_Msg_Client(player_id) )
{
//client_print(player_id, print_chat, "%L", player_id, "SAVESKILLSET_ERROR", MOD);
hudchat_show(player_id, "%L", player_id, "SAVESKILLSET_ERROR");
hudchat_update(player_id);
}
return PLUGIN_HANDLED;
}
else if(FailState == TQUERY_QUERY_FAILED)
{
log_amx( "[UWC3X] SQL :: Error in _SaveSkillSet");
SQL_QueryError(Query,g_Error,511);
log_amx( "[UWC3X] ERROR %s",g_Error);
if( Util_Should_Msg_Client(player_id) )
{
//client_print(player_id, print_chat, "%L", player_id, "SAVESKILLSET_ERROR", MOD);
hudchat_show(player_id, "%L", player_id, "SAVESKILLSET_ERROR");
hudchat_update(player_id);
}
return PLUGIN_HANDLED;
}
if(Errcode)
{
log_amx( "[UWC3X] Error:_SaveSkillSet - %d", Errcode);
return PLUGIN_HANDLED;
}
if ( CVAR_DEBUG_MODE )
{
new tempVar[64];
get_user_name ( player_id, tempVar, 63 );
log_amx( "[UWC3X] Debug:: MySQL->_SaveSkillSet : No error, attepting to Save skillset %d for %s", skills_id, tempVar );
}
if( Util_Should_Msg_Client(player_id) )
{
//client_print(player_id, print_chat, "%L", player_id, "SAVESKILLSET", MOD, skills_id );
hudchat_show(player_id, "%L", player_id, "SAVESKILLSET", skills_id);
hudchat_update(player_id);
}
return PLUGIN_CONTINUE;
}
public _LoadSkillSet( FailState, Handle:Query, Error[], Errcode, Data[], DataSize )
{
new skills[MAX_SKILLS] = 0;
new tempVar[64];
// lots of error checking
if(FailState == TQUERY_CONNECT_FAILED)
{
log_amx( "[UWC3X] Error: Could not connect to SQL database in _LoadSkillSet.");
if( Util_Should_Msg_Client(player_id) )
{
//client_print(player_id, print_chat, "%L", player_id, "LOADSKILLSET_ERROR", MOD);
hudchat_show(player_id, "%L", player_id, "LOADSKILLSET_ERROR", MOD);
hudchat_update(player_id);
}
return PLUGIN_HANDLED;
}
else if(FailState == TQUERY_QUERY_FAILED)
{
log_amx( "[UWC3X] SQL :: Error in _LoadSkillSet");
SQL_QueryError(Query,g_Error,511);
log_amx( "[UWC3X] ERROR %s",g_Error);
if( Util_Should_Msg_Client(player_id) )
{
//client_print(player_id, print_chat, "%L", player_id, "LOADSKILLSET_ERROR", MOD);
hudchat_show(player_id, "%L", player_id, "LOADSKILLSET_ERROR", MOD);
hudchat_update(player_id);
}
return PLUGIN_HANDLED;
}
if(Errcode)
{
log_amx( "[UWC3X] Error:_LoadSkillSet - %d", Errcode);
return PLUGIN_HANDLED;
}
//Now that we have no errors, I will reset the xp loading var, this is in case there are
//errors so that it will continue to retry
NumResults = SQL_NumResults(Query);
if ( CVAR_DEBUG_MODE )
{
get_user_name ( player_id, tempVar, 63 );
}
if ( !NumResults || NumResults == 0 )
{
//No results, tell them and then exit
if( Util_Should_Msg_Client(player_id) )
{
//client_print(player_id, print_chat, "%L", player_id, "LOADSKILLSET_NODATA", MOD, skills_id);
hudchat_show(player_id, "%L", player_id, "LOADSKILLSET_NODATA", skills_id);
hudchat_update(player_id);
}
return PLUGIN_CONTINUE;
}
else
{
//Since they are resetting their skills, and choosing new ones
//Zero out anything they had previously so that the new ones can take effect
for ( new j=0; j<MAX_SKILLS; j++ )
{
// Set all skills to 0
p_skills[player_id][j]=0;
}
ultlearned[player_id] = 0;
if( p_attribs[player_id][ATTRIBIDX_WIS] >= 18 )
{
p_maxultimates[player_id] = MAX_ULTIMATES + 1;
}
else
{
p_maxultimates[player_id] = MAX_ULTIMATES;
}
new name[32];
get_user_name ( player_id, name, 31 );
new temp[32], sqlField;
//Start setting the skills
for ( new k = 1; k < (MAX_SKILLS); k++ )
{
format( temp, 31, "skill%d", k);
sqlField = SQL_FieldNameToNum(Query, temp)
skills[k] = SQL_ReadResult ( Query, sqlField );
if( skill_ultimates[k][0] && ( ultlearned[player_id] < p_maxultimates[player_id] ) )
{
if( Util_Should_Msg_Client(player_id) )
{
client_print ( player_id, print_console, "%L", player_id, "ULTIMATE_RETRIEVED", MOD, skill_ultimates[k][0] );
}
ultlearned[player_id]++;
Set_Ult_Count(player_id);
}
}
}
p_skills[player_id] = skills;
xpreadytoload[player_id] = 0;
if( Util_Should_Msg_Client(player_id) )
{
//client_print(player_id, print_chat, "%L", player_id, "LOADSKILLSET", MOD, skills_id );
hudchat_show(player_id, "%L", player_id, "LOADSKILLSET", skills_id);
hudchat_update(player_id);
}
return PLUGIN_CONTINUE;
}
public _DelSkillSet(FailState, Handle:Query, Error[], Errcode, Data[], DataSize )
{
// lots of error checking
if(FailState == TQUERY_CONNECT_FAILED)
{
log_amx( "[UWC3X] Error: Could not connect to SQL database in _DelSkillSet.");
if( Util_Should_Msg_Client(player_id) )
{
//client_print(player_id, print_chat, "%L", player_id, "DELETESKILLSET_ERROR", MOD);
hudchat_show(player_id, "%L", player_id, "DELETESKILLSET_ERROR");
hudchat_update(player_id);
}
return PLUGIN_HANDLED;
}
else if(FailState == TQUERY_QUERY_FAILED)
{
log_amx( "[UWC3X] SQL :: Error in _DelSkillSet");
SQL_QueryError(Query,g_Error,511);
log_amx( "[UWC3X] ERROR %s",g_Error);
if( Util_Should_Msg_Client(player_id) )
{
//client_print(player_id, print_chat, "%L", player_id, "DELETESKILLSET_ERROR", MOD);
hudchat_show(player_id, "%L", player_id, "DELETESKILLSET_ERROR");
hudchat_update(player_id);
}
return PLUGIN_HANDLED;
}
if(Errcode)
{
log_amx( "[UWC3X] Error:_DelSkillSet - %d", Errcode);
return PLUGIN_HANDLED;
}
if( Util_Should_Msg_Client(player_id) )
{
//client_print( player_id, print_chat, "%L", player_id, "DELETESKILLSET_OK", MOD, skills_id );
hudchat_show(player_id, "%L", player_id, "DELETESKILLSET_OK", skills_id);
hudchat_update(player_id);
}
return PLUGIN_CONTINUE;
}
public DeleteSkillSetMySQL ( id, skillsetIDX )
{
if ( CVAR_ENABLE_UWC3X != 1 )
{
return PLUGIN_HANDLED;
}
if ( CVAR_SAVE_XP != 1 )
{
return PLUGIN_CONTINUE;
}
if( CVAR_SAVE_BY == 2 )
{
new userName[63];
get_user_name ( id, userName, 63 );
format ( squery, 4096, "Delete from `%s_SkillSets` where name='%s' and skillsetid='%d',", CVAR_MYSQL_TABLE, userName, skillsetIDX );
}
else
{
get_user_authid ( id, steamid, 34 );
format ( squery, 4096, "Delete from `%s_SkillSets` where steamid='%s' and skillsetid='%d',", CVAR_MYSQL_TABLE, steamid, skillsetIDX );
}
player_id = id;
skills_id = skillsetIDX;
if ( CVAR_DEBUG_MODE )
{
log_amx( "[UWC3X] DEBUG: MySQL->DeleteSkillSetMySQL: Set SQL_ThreadQuery" );
}
SQL_ThreadQuery ( g_SqlTuple, "_DelSkillSet", squery );
return PLUGIN_CONTINUE;
}
public SaveSkillSetMySQL( id, skillsetIDX )
{
if ( CVAR_ENABLE_UWC3X != 1 )
{
return PLUGIN_HANDLED;
}
if ( CVAR_SAVE_XP != 1 )
{
return PLUGIN_CONTINUE;
}
if( CVAR_SAVE_BY == 2 )
{
new userName[63];
get_user_name ( id, userName, 63 );
format ( squery, 5096, "REPLACE INTO `%s_SkillSets` SET name='%s', skillsetid='%d',", CVAR_MYSQL_TABLE, userName, skillsetIDX );
}
else
{
get_user_authid ( id, steamid, 34 );
format ( squery, 5096, "REPLACE INTO `%s_SkillSets` SET steamid='%s', skillsetid='%d',", CVAR_MYSQL_TABLE, steamid, skillsetIDX );
}
format ( squery, 4096, "%s skill1='%d' , skill2='%d' ,", squery, p_skills[id][1], p_skills[id][2] ) ;
format ( squery, 4096, "%s skill3='%d' , skill4='%d' , skill5='%d' ,", squery,p_skills[id][3], p_skills[id][4], p_skills[id][5] );
format ( squery, 4096, "%s skill6='%d' , skill7='%d' , skill8='%d' ,", squery,p_skills[id][6], p_skills[id][7], p_skills[id][8] );
format ( squery, 4096, "%s skill9='%d' , skill10='%d', skill11='%d',", squery,p_skills[id][9], p_skills[id][10], p_skills[id][11] );
format ( squery, 4096, "%s skill12='%d', skill13='%d', skill14='%d',", squery,p_skills[id][12], p_skills[id][13], p_skills[id][14] );
format ( squery, 4096, "%s skill15='%d', skill16='%d', skill17='%d',", squery,p_skills[id][15], p_skills[id][16], p_skills[id][17] ) ;
format ( squery, 4096, "%s skill18='%d', skill19='%d', skill20='%d',", squery,p_skills[id][18], p_skills[id][19], p_skills[id][20] );
format ( squery, 4096, "%s skill21='%d', skill22='%d', skill23='%d',", squery,p_skills[id][21], p_skills[id][22], p_skills[id][23] );
format ( squery, 4096, "%s skill24='%d', skill25='%d', skill26='%d',", squery,p_skills[id][24], p_skills[id][25], p_skills[id][26] );
format ( squery, 4096, "%s skill27='%d', skill28='%d', skill29='%d',", squery,p_skills[id][27], p_skills[id][28], p_skills[id][29] );
format ( squery, 4096, "%s skill30='%d', skill31='%d', skill32='%d',", squery,p_skills[id][30], p_skills[id][31], p_skills[id][32] );
format ( squery, 4096, "%s skill33='%d', skill34='%d', skill35='%d',", squery,p_skills[id][33], p_skills[id][34], p_skills[id][35] );
format ( squery, 4096, "%s skill36='%d', skill37='%d', skill38='%d',", squery,p_skills[id][36], p_skills[id][37], p_skills[id][38] );
format ( squery, 4096, "%s skill39='%d', skill40='%d', skill41='%d',", squery,p_skills[id][39], p_skills[id][40], p_skills[id][41] );
format ( squery, 4096, "%s skill42='%d', skill43='%d', skill44='%d',", squery,p_skills[id][42], p_skills[id][43], p_skills[id][44] );
format ( squery, 4096, "%s skill45='%d', skill46='%d', skill47='%d',", squery,p_skills[id][45], p_skills[id][46], p_skills[id][47] );
format ( squery, 4096, "%s skill48='%d', skill49='%d', skill50='%d',", squery,p_skills[id][48], p_skills[id][49], p_skills[id][50] );
format ( squery, 4096, "%s skill51='%d', skill52='%d', skill53='%d',", squery,p_skills[id][51], p_skills[id][52], p_skills[id][53] );
format ( squery, 4096, "%s skill54='%d', skill55='%d', skill56='%d',", squery, p_skills[id][54],p_skills[id][55], p_skills[id][56] );
format ( squery, 4096, "%s skill57='%d', skill58='%d', skill59='%d',", squery,p_skills[id][57], p_skills[id][58], p_skills[id][59] );
format ( squery, 4096, "%s skill60='%d', skill61='%d', skill62='%d',", squery,p_skills[id][60], p_skills[id][61], p_skills[id][62] );
format ( squery, 4096, "%s skill63='%d', skill64='%d' ;", squery, p_skills[id][63],p_skills[id][64] );
player_id = id;
skills_id = skillsetIDX;
if ( CVAR_DEBUG_MODE )
{
log_amx( "[UWC3X] DEBUG: MySQL->SaveSkillSetMySQL: Set SQL_ThreadQuery" );
}
SQL_ThreadQuery ( g_SqlTuple, "_SaveSkillSet", squery );
return PLUGIN_CONTINUE;
}
public LoadSkillSetMySQL( id, skillsetIDX )
{
if ( CVAR_ENABLE_UWC3X != 1 )
{
return PLUGIN_HANDLED;
}
if ( CVAR_SAVE_XP != 1 )
{
return PLUGIN_CONTINUE;
}
if( CVAR_SAVE_BY == 2 )
{
format ( squery, 4096, "SELECT name, skill1, skill2, skill3," );
}
else
{
format ( squery, 4096, "SELECT steamid, skill1, skill2, skill3," );
}
format ( squery, 4096, "%s skill4, skill5, skill6, skill7, skill8, skill9, skill10, ", squery );
format ( squery, 4096, "%s skill11, skill12, skill13, skill14, skill15, skill16, skill17,", squery );
format ( squery, 4096, "%s skill18, skill19, skill20, skill21, skill22, skill23, skill24,", squery );
format ( squery, 4096, "%s skill25, skill26, skill27, skill28, skill29, skill30, skill31,", squery );
format ( squery, 4096, "%s skill32, skill33, skill34, skill35, skill36, skill37, skill38,", squery );
format ( squery, 4096, "%s skill39, skill40, skill41, skill42, skill43, skill44, skill45,", squery );
format ( squery, 4096, "%s skill46, skill47, skill48, skill49, skill50, skill51, skill52,", squery );
format ( squery, 4096, "%s skill53, skill54, skill55, skill56, skill57, skill58, skill59,", squery );
format ( squery, 4096, "%s skill60, skill61, skill62, skill63, skill64 ", squery );
if( CVAR_SAVE_BY == 2 )
{
new userName[63];
get_user_name ( id, userName, 63 );
format ( squery, 4096, "%s FROM %s_SkillSets WHERE name = '%s' and skillsetid = '%d';", squery, CVAR_MYSQL_TABLE, userName, skillsetIDX );
}
else
{
get_user_authid ( id, steamid, 34 );
format ( squery, 4096, "%s FROM %s_SkillSets WHERE steamid = '%s' and skillsetid = '%d';", squery, CVAR_MYSQL_TABLE, steamid, skillsetIDX );
}
player_id = id;
skills_id = skillsetIDX;
if ( CVAR_DEBUG_MODE )
{
log_amx( "[UWC3X] DEBUG: MySQL->LoadSkillSetMySQL: Set SQL_ThreadQuery" );
}
SQL_ThreadQuery ( g_SqlTuple, "_LoadSkillSet", squery );
return PLUGIN_CONTINUE;
} | [
"hostcheap@840eb890-4279-fec9-49b3-ec91e02591cc",
"stormzone.site@840eb890-4279-fec9-49b3-ec91e02591cc"
]
| [
[
[
1,
6
],
[
8,
14
],
[
16,
17
],
[
19,
20
],
[
22,
33
],
[
35,
62
],
[
64,
72
],
[
74,
75
],
[
77,
91
],
[
93,
102
],
[
104,
105
],
[
107,
114
],
[
116,
116
],
[
118,
125
],
[
127,
148
],
[
150,
151
],
[
153,
167
],
[
169,
176
],
[
178,
216
],
[
218,
220
],
[
222,
223
],
[
225,
225
],
[
227,
230
],
[
232,
245
],
[
247,
252
],
[
254,
256
],
[
258,
263
],
[
265,
266
],
[
269,
269
],
[
271,
273
],
[
275,
278
],
[
280,
288
],
[
290,
302
],
[
304,
309
],
[
311,
314
],
[
316,
322
],
[
324,
331
],
[
333,
338
],
[
340,
343
],
[
345,
348
],
[
350,
353
],
[
355,
361
],
[
363,
364
],
[
366,
372
],
[
374,
379
],
[
381,
384
],
[
386,
392
],
[
394,
403
],
[
405,
436
],
[
438,
442
],
[
444,
444
],
[
446,
455
],
[
457,
458
],
[
460,
463
],
[
465,
468
],
[
470,
473
],
[
475,
496
],
[
498,
512
],
[
514,
518
],
[
520,
525
],
[
527,
530
],
[
532,
535
],
[
537,
538
],
[
540,
540
],
[
542,
545
],
[
547,
557
],
[
559,
570
],
[
572,
572
],
[
574,
575
],
[
577,
578
],
[
580,
586
],
[
588,
589
],
[
591,
608
],
[
610,
612
],
[
614,
617
],
[
620,
628
],
[
630,
631
],
[
633,
636
],
[
638,
678
],
[
680,
694
],
[
696,
701
],
[
703,
708
],
[
710,
712
],
[
714,
720
],
[
722,
727
],
[
729,
732
],
[
734,
740
],
[
742,
749
],
[
751,
756
],
[
758,
758
],
[
760,
775
],
[
777,
780
],
[
782,
785
],
[
787,
787
],
[
789,
791
],
[
793,
802
],
[
804,
813
],
[
815,
816
],
[
818,
821
],
[
823,
826
],
[
828,
829
],
[
831,
834
],
[
836,
839
],
[
841,
844
],
[
846,
849
],
[
851,
854
],
[
856,
860
],
[
862,
867
],
[
869,
880
],
[
882,
884
],
[
886,
892
],
[
894,
906
],
[
908,
942
],
[
944,
951
],
[
953,
953
],
[
955,
980
],
[
982,
991
],
[
993,
997
],
[
999,
1003
],
[
1005,
1013
],
[
1015,
1024
],
[
1026,
1038
],
[
1040,
1041
],
[
1043,
1060
],
[
1062,
1063
],
[
1065,
1069
],
[
1071,
1074
],
[
1076,
1081
],
[
1083,
1097
],
[
1099,
1103
],
[
1105,
1110
],
[
1112,
1117
],
[
1119,
1122
],
[
1124,
1125
],
[
1127,
1136
],
[
1138,
1152
],
[
1154,
1158
],
[
1160,
1162
],
[
1164,
1167
],
[
1169,
1181
],
[
1183,
1189
],
[
1191,
1191
],
[
1193,
1200
],
[
1202,
1203
],
[
1205,
1211
],
[
1213,
1218
],
[
1220,
1224
],
[
1226,
1227
],
[
1229,
1234
],
[
1236,
1250
],
[
1252,
1266
],
[
1268,
1272
],
[
1274,
1279
],
[
1281,
1281
],
[
1283,
1290
],
[
1292,
1295
],
[
1297,
1307
],
[
1309,
1314
],
[
1316,
1317
],
[
1319,
1321
],
[
1323,
1326
],
[
1328,
1331
],
[
1333,
1366
],
[
1368,
1373
],
[
1375,
1376
],
[
1378,
1381
],
[
1383,
1386
],
[
1388,
1391
],
[
1393,
1400
],
[
1402,
1410
],
[
1412,
1429
],
[
1431,
1433
]
],
[
[
7,
7
],
[
15,
15
],
[
18,
18
],
[
21,
21
],
[
34,
34
],
[
63,
63
],
[
73,
73
],
[
76,
76
],
[
92,
92
],
[
103,
103
],
[
106,
106
],
[
115,
115
],
[
117,
117
],
[
126,
126
],
[
149,
149
],
[
152,
152
],
[
168,
168
],
[
177,
177
],
[
217,
217
],
[
221,
221
],
[
224,
224
],
[
226,
226
],
[
231,
231
],
[
246,
246
],
[
253,
253
],
[
257,
257
],
[
264,
264
],
[
267,
268
],
[
270,
270
],
[
274,
274
],
[
279,
279
],
[
289,
289
],
[
303,
303
],
[
310,
310
],
[
315,
315
],
[
323,
323
],
[
332,
332
],
[
339,
339
],
[
344,
344
],
[
349,
349
],
[
354,
354
],
[
362,
362
],
[
365,
365
],
[
373,
373
],
[
380,
380
],
[
385,
385
],
[
393,
393
],
[
404,
404
],
[
437,
437
],
[
443,
443
],
[
445,
445
],
[
456,
456
],
[
459,
459
],
[
464,
464
],
[
469,
469
],
[
474,
474
],
[
497,
497
],
[
513,
513
],
[
519,
519
],
[
526,
526
],
[
531,
531
],
[
536,
536
],
[
539,
539
],
[
541,
541
],
[
546,
546
],
[
558,
558
],
[
571,
571
],
[
573,
573
],
[
576,
576
],
[
579,
579
],
[
587,
587
],
[
590,
590
],
[
609,
609
],
[
613,
613
],
[
618,
619
],
[
629,
629
],
[
632,
632
],
[
637,
637
],
[
679,
679
],
[
695,
695
],
[
702,
702
],
[
709,
709
],
[
713,
713
],
[
721,
721
],
[
728,
728
],
[
733,
733
],
[
741,
741
],
[
750,
750
],
[
757,
757
],
[
759,
759
],
[
776,
776
],
[
781,
781
],
[
786,
786
],
[
788,
788
],
[
792,
792
],
[
803,
803
],
[
814,
814
],
[
817,
817
],
[
822,
822
],
[
827,
827
],
[
830,
830
],
[
835,
835
],
[
840,
840
],
[
845,
845
],
[
850,
850
],
[
855,
855
],
[
861,
861
],
[
868,
868
],
[
881,
881
],
[
885,
885
],
[
893,
893
],
[
907,
907
],
[
943,
943
],
[
952,
952
],
[
954,
954
],
[
981,
981
],
[
992,
992
],
[
998,
998
],
[
1004,
1004
],
[
1014,
1014
],
[
1025,
1025
],
[
1039,
1039
],
[
1042,
1042
],
[
1061,
1061
],
[
1064,
1064
],
[
1070,
1070
],
[
1075,
1075
],
[
1082,
1082
],
[
1098,
1098
],
[
1104,
1104
],
[
1111,
1111
],
[
1118,
1118
],
[
1123,
1123
],
[
1126,
1126
],
[
1137,
1137
],
[
1153,
1153
],
[
1159,
1159
],
[
1163,
1163
],
[
1168,
1168
],
[
1182,
1182
],
[
1190,
1190
],
[
1192,
1192
],
[
1201,
1201
],
[
1204,
1204
],
[
1212,
1212
],
[
1219,
1219
],
[
1225,
1225
],
[
1228,
1228
],
[
1235,
1235
],
[
1251,
1251
],
[
1267,
1267
],
[
1273,
1273
],
[
1280,
1280
],
[
1282,
1282
],
[
1291,
1291
],
[
1296,
1296
],
[
1308,
1308
],
[
1315,
1315
],
[
1318,
1318
],
[
1322,
1322
],
[
1327,
1327
],
[
1332,
1332
],
[
1367,
1367
],
[
1374,
1374
],
[
1377,
1377
],
[
1382,
1382
],
[
1387,
1387
],
[
1392,
1392
],
[
1401,
1401
],
[
1411,
1411
],
[
1430,
1430
]
]
]
|
36c6cde715e10e3c0a85c0f08a7da2dc8068e6f8 | b4d726a0321649f907923cc57323942a1e45915b | /CODE/MENUUI/pilotmanage.cpp | 1cdbc7370da911666c69399aa180d4ca8cd9ba35 | []
| no_license | chief1983/Imperial-Alliance | f1aa664d91f32c9e244867aaac43fffdf42199dc | 6db0102a8897deac845a8bd2a7aa2e1b25086448 | refs/heads/master | 2016-09-06T02:40:39.069630 | 2010-10-06T22:06:24 | 2010-10-06T22:06:24 | 967,775 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 34,303 | cpp | /*
* Copyright (C) Volition, Inc. 1999. All rights reserved.
*
* All source code herein is the property of Volition, Inc. You may not sell
* or otherwise commercially exploit the source or things you created based on the
* source.
*
*/
/*
* $Logfile: /Freespace2/code/MenuUI/pilotmanage.cpp $
* $Revision: 1.2 $
* $Date: 2004/09/07 22:56:14 $
* $Author: Darkhill $
*
* C file for implementing pilot manage section
*
* $Log: pilotmanage.cpp,v $
* Revision 1.2 2004/09/07 22:56:14 Darkhill
* -Hopefully fixed a lot of the linker warnings.
*
* -Cleaned up some of the interface stuff.
*
* -Add a tag to the mission file so that up to three flight groups can be selected to have the player edit ships and weapons. This gets rid of the old Alpha, Beta, and Gamma groups that were hard coded.
*
* Revision 1.1.1.1 2004/08/13 22:47:41 Spearhawk
* no message
*
* Revision 1.1.1.1 2004/08/13 21:47:42 Darkhill
* no message
*
* Revision 2.6 2004/02/14 00:18:33 randomtiger
* Please note that from now on OGL will only run with a registry set by Launcher v4. See forum for details.
* OK, these changes effect a lot of file, I suggest everyone updates ASAP:
* Removal of many files from project.
* Removal of meanless Gr_bitmap_poly variable.
* Removal of glide, directdraw, software modules all links to them, and all code specific to those paths.
* Removal of redundant Fred paths that arent needed for Fred OGL.
* Have seriously tidied the graphics initialisation code and added generic non standard mode functionality.
* Fixed many D3D non standard mode bugs and brought OGL up to the same level.
* Removed texture section support for D3D8, voodoo 2 and 3 cards will no longer run under fs2_open in D3D, same goes for any card with a maximum texture size less than 1024.
*
* Revision 2.5 2004/02/10 21:47:47 Goober5000
* fixed the barracks crash bug
* --Goober5000
*
* Revision 2.4 2003/08/20 08:11:00 wmcoolmon
* Added error screens to the barracks and start screens when a pilot file can't be deleted
*
* Revision 2.3 2003/03/18 10:07:03 unknownplayer
* The big DX/main line merge. This has been uploaded to the main CVS since I can't manage to get it to upload to the DX branch. Apologies to all who may be affected adversely, but I'll work to debug it as fast as I can.
*
* Revision 2.2.2.1 2002/09/24 18:56:43 randomtiger
* DX8 branch commit
*
* This is the scub of UP's previous code with the more up to date RT code.
* For full details check previous dev e-mails
*
* Revision 2.2 2002/08/01 01:41:06 penguin
* The big include file move
*
* Revision 2.1 2002/07/07 19:55:59 penguin
* Back-port to MSVC
*
* Revision 2.0 2002/06/03 04:02:24 penguin
* Warpcore CVS sync
*
* Revision 1.2 2002/05/04 04:52:22 mharris
* 1st draft at porting
*
* Revision 1.1 2002/05/02 18:03:09 mharris
* Initial checkin - converted filenames and includes to lower case
*
*
* 42 10/25/99 5:47p Jefff
* reassigned some xstr ids
*
* 41 9/14/99 11:01p Jefff
* stats area coord fix
*
* 40 9/09/99 11:24a Jefff
*
* 39 9/02/99 11:26a Jefff
* fixed incorrect pilot list dimensions
*
* 38 8/17/99 2:24p Dave
* Fixed wacky squad color stuff.
*
* 37 8/16/99 4:27p Jefff
* fix button position on squad change error popup
*
* 36 8/11/99 3:58p Jefff
* fixed player list box coord bug
*
* 35 8/05/99 2:46p Jefff
* added popup to the disabled squad selection buttons in single player
*
* 34 8/02/99 11:02p Dave
* Fixed up squad filename and squad name copying when converting a pilot
* between single and multiplayer.
*
* 33 7/27/99 7:17p Jefff
* Replaced some art text with XSTR() text.
*
* 32 7/15/99 9:20a Andsager
* FS2_DEMO initial checkin
*
* 31 6/29/99 7:39p Dave
* Lots of small bug fixes.
*
* 30 6/16/99 4:06p Dave
* New pilot info popup. Added new draw-bitmap-as-poly function.
*
* 29 6/11/99 11:13a Dave
* last minute changes before press tour build.
*
* 28 4/25/99 7:43p Dave
* Misc small bug fixes. Made sun draw properly.
*
* 27 4/25/99 3:02p Dave
* Build defines for the E3 build.
*
* 26 3/24/99 4:05p Dave
* Put in support for assigning the player to a specific squadron with a
* specific logo. Preliminary work for doing pos/orient checksumming in
* multiplayer to reduce bandwidth.
*
* 25 2/25/99 4:19p Dave
* Added multiplayer_beta defines. Added cd_check define. Fixed a few
* release build warnings. Added more data to the squad war request and
* response packets.
*
* 24 2/02/99 12:09p Neilk
* Fixed text coords, centered pilot and squad pics in 1024x768, added vss
* comment template
*
* $NoKeywords: $
*/
#include "globalincs/pstypes.h"
#include "menuui/barracks.h"
#include "playerman/managepilot.h"
#include "ui/ui.h"
#include "graphics/font.h"
#include "io/key.h"
#include "gamesnd/gamesnd.h"
#include "osapi/osapi.h"
#include "popup/popup.h"
#include "menuui/playermenu.h"
#include "gamesequence/gamesequence.h"
#include "gamehelp/contexthelp.h"
#include "graphics/2d.h"
#include "ctype.h"
#include "freespace2/freespace.h"
#include "globalincs/systemvars.h"
#include "bmpman/bmpman.h"
#include "io/mouse.h"
#include "osapi/osregistry.h"
#include "globalincs/alphacolors.h"
#include "debugconsole/dbugfile.h"
#include "menuui/snazzyui.h"
#include "Playerman/Player.h"
#include "parse/parselo.h"
#include "ship/ship.h"
#include "popup/popuptc.h"
#include "EH_Medals/idline.h"
#include "EH_Medals/convert.h"
static int prev_single_player = -1;
static int prev_multi_player = -1;
void pilot_manage_maybe_show_button_text();
void pilot_manage_force_button_frame();
//////////////////////////////////////////////////////////
// button defines
#define PM_NUM_BUTTONS 11
#define PM_UP_BUTTON 0
#define PM_DOWN_BUTTON 1
#define PM_SINGLE_MODE_BUTTON 2
#define PM_MULTI_MODE_BUTTON 3
#define PM_ACTIVE_BUTTON 4
#define PM_CREATE_BUTTON 5
#define PM_CLONE_BUTTON 6
#define PM_DELETE_BUTTON 7
#define PM_CONVERT_BUTTON 8
#define PM_EXIT_BUTTON 9
#define PM_TC_BUTTON 10
static char *PilotManage_bitmap_fname[GR_NUM_RESOLUTIONS] = {
"PilotMan",
"2_PilotMan"
};
static char *PilotManage_bitmap_mask_fname[GR_NUM_RESOLUTIONS] = {
"PilotMan-M",
"2_PilotMan-M"
};
struct pilot_manage_buttons {
char *filename;
int x, y;
int text_x, text_y; // this is where the text label is
int hotspot;
int repeat;
UI_BUTTON button; // because we have a class inside this struct, we need the constructor below..
pilot_manage_buttons(char *name, int x1, int y1, int x2, int y2, int h, int r = 0) : filename(name), x(x1), y(y1), text_x(x2), text_y(y2), hotspot(h), repeat(r) {}
};
static pilot_manage_buttons Buttons[GR_NUM_RESOLUTIONS][PM_NUM_BUTTONS] = {
{
pilot_manage_buttons("PMB_00", 565, 47, 11, 157, 0),
pilot_manage_buttons("PMB_01", 565, 345, 0, 0, 1),
pilot_manage_buttons("PMB_02", 325, 375, 0, 0, 2),
pilot_manage_buttons("PMB_03", 325, 405, 0, 0, 3),
pilot_manage_buttons("PMB_04", 485, 375, 0, 0, 4),
pilot_manage_buttons("PMB_05", 45, 375, 326, 441, 5),
pilot_manage_buttons("PMB_06", 100, 375, 395, 441, 6),
pilot_manage_buttons("PMB_07", 155, 375, 457, 441, 7),
pilot_manage_buttons("PMB_08", 210, 375, 519, 441, 8),
pilot_manage_buttons("PMB_09", 540, 375, 0, 0, 9),
pilot_manage_buttons("PMB_10", 265, 375, 0, 0, 10),
},
{
pilot_manage_buttons("PMB_00", 904, 76, 11, 157, 0),
pilot_manage_buttons("PMB_01", 904, 552, 0, 0, 1),
pilot_manage_buttons("PMB_02", 520, 600, 0, 0, 2),
pilot_manage_buttons("PMB_03", 520, 648, 0, 0, 3),
pilot_manage_buttons("PMB_04", 776, 600, 0, 0, 4),
pilot_manage_buttons("PMB_05", 72, 600, 0, 0, 5),
pilot_manage_buttons("PMB_06", 160, 600, 0, 0, 6),
pilot_manage_buttons("PMB_07", 248, 600, 0, 0, 7),
pilot_manage_buttons("PMB_08", 336, 600, 0, 0, 8),
pilot_manage_buttons("PMB_09", 864, 600, 0, 0, 9),
pilot_manage_buttons("PMB_10", 424, 600, 0, 0, 10),
}
};
#define PILOT_MANAGE_NUM_TEXT 11
UI_XSTR Pilot_manage_text[GR_NUM_RESOLUTIONS][PILOT_MANAGE_NUM_TEXT] = {
{ // GR_640
{ "", -1, 350, 381, UI_XSTR_COLOR_GREEN, -1, NULL },
{ "", -1, 350, 381, UI_XSTR_COLOR_GREEN, -1, NULL },
{ "Single Player", -1, 350, 381, UI_XSTR_COLOR_GREEN, -1, NULL },
{ "Multi Player", -1, 350, 411, UI_XSTR_COLOR_GREEN, -1, NULL },
{ "Select", -1, 487, 396, UI_XSTR_COLOR_GREEN, -1, NULL },
{ "Create", -1, 47, 396, UI_XSTR_COLOR_GREEN, -1, NULL },
{ "Clone", -1, 104, 396, UI_XSTR_COLOR_GREEN, -1, NULL },
{ "Remove", -1, 155, 396, UI_XSTR_COLOR_GREEN, -1, NULL },
{ "Convert", -1, 207, 396, UI_XSTR_COLOR_GREEN, -1, NULL },
{ "Accept", -1, 541, 396, UI_XSTR_COLOR_GREEN, -1, NULL },
{ "TC PIN", -1, 265, 396, UI_XSTR_COLOR_GREEN, -1, NULL},
},
{ // GR_1024
{ "", -1, 350, 381, UI_XSTR_COLOR_GREEN, -1, NULL },
{ "", -1, 350, 381, UI_XSTR_COLOR_GREEN, -1, NULL },
{ "Single Player", -1, 560, 610, UI_XSTR_COLOR_GREEN, -1, NULL },
{ "Multi Player", -1, 560, 658, UI_XSTR_COLOR_GREEN, -1, NULL },
{ "Select", -1, 779, 634, UI_XSTR_COLOR_GREEN, -1, NULL },
{ "Create", -1, 75, 634, UI_XSTR_COLOR_GREEN, -1, NULL },
{ "Clone", -1, 166, 634, UI_XSTR_COLOR_GREEN, -1, NULL },
{ "Remove", -1, 248, 634, UI_XSTR_COLOR_GREEN, -1, NULL },
{ "Convert", -1, 331, 634, UI_XSTR_COLOR_GREEN, -1, NULL },
{ "Accept", -1, 866, 634, UI_XSTR_COLOR_GREEN, -1, NULL },
{ "TC PIN", -1, 424, 634, UI_XSTR_COLOR_GREEN, -1, NULL},
}
};
//Returns 0 on failure, 1 on success
int delete_pilot_file( char *pilot_name, int single ); // manage_pilot.cpp
// constants for coordinate lookup
#define PM_X_COORD 0
#define PM_Y_COORD 1
#define PM_W_COORD 2
#define PM_H_COORD 3
// pilot selection field
static int Pilot_manage_list_coords[GR_NUM_RESOLUTIONS][4] = {
{ // GR_640
67, 47, 510, 318
},
{ // GR_1024
80, 76, 816, 509
}
};
static int Background_bitmap = -1;
static UI_WINDOW Ui_window;
static UI_BUTTON List_region;
static UI_INPUTBOX Inputbox;
extern int Player_sel_mode;
extern player *Cur_pilot;
static int Num_pilots;
static int Selected_line;
static char Pilots_arr[MAX_PILOTS][MAX_FILENAME_LEN];
static char *Pilots[MAX_PILOTS];
static int Pic_number;
static int Pic_squad_number;
static bool pilot_manage_callsign_enter_mode;
static int Pilot_ranks[MAX_PILOTS];
static int List_scroll_offset;
static int Clone_flag;
static int Pilot_images[MAX_PILOT_IMAGES];
static int Pilot_squad_images[MAX_PILOT_IMAGES];
static int Rank_pips_bitmaps;
static int Rank_pips_count;
// needs to go with new pilot management crap
// sets or clears hotkeys for pilot selection.
void pilot_manage_set_hotkeys(bool pilot_text_enter_mode)
{
Buttons[gr_screen.res][PM_UP_BUTTON].button.set_hotkey(pilot_text_enter_mode ? KEY_UP : -1);
Buttons[gr_screen.res][PM_DOWN_BUTTON].button.set_hotkey(pilot_text_enter_mode ? KEY_DOWN : -1);
Buttons[gr_screen.res][PM_SINGLE_MODE_BUTTON].button.set_hotkey(pilot_text_enter_mode ? KEY_LEFT : -1);
Buttons[gr_screen.res][PM_ACTIVE_BUTTON].button.set_hotkey(pilot_text_enter_mode ? KEY_ENTER : -1);
Buttons[gr_screen.res][PM_DELETE_BUTTON].button.set_hotkey(pilot_text_enter_mode ? KEY_DELETE : -1);
Buttons[gr_screen.res][PM_MULTI_MODE_BUTTON].button.set_hotkey(pilot_text_enter_mode ? KEY_RIGHT : -1);
Buttons[gr_screen.res][PM_ACTIVE_BUTTON].button.set_hotkey(pilot_text_enter_mode ? KEY_ENTER : -1);
Buttons[gr_screen.res][PM_CREATE_BUTTON].button.set_hotkey(pilot_text_enter_mode ? KEY_CTRLED | KEY_ENTER : -1);
Buttons[gr_screen.res][PM_TC_BUTTON].button.set_hotkey(pilot_text_enter_mode ? KEY_T : -1);
}
// new pilot name has focus, so update stats/pic to that pilot
int pilot_manage_new_pilot_selected()
{
//char stripped[MAX_FILENAME_LEN+1] = "";
// save the previous pilot first, so changes to it are kept
if (strlen(Cur_pilot->callsign)) {
write_pilot_file();
}
// check if we have a valid pilot hilighted. If so, attempt to active it
if ((Num_pilots < 1) || (Selected_line < 0) || (Selected_line >= Num_pilots)) {
Cur_pilot->callsign[0] = 0; // this indicates no pilot active
return -1;
}
if (read_pilot_file(Pilots[Selected_line], !Player_sel_mode, Cur_pilot)) {
Cur_pilot->callsign[0] = 0; // this indicates no pilot active
return -1;
}
return 0;
}
void pilot_manage_set_callsign_enter_mode(bool set_callsign_enter_mode)
{
// set global mode variable
pilot_manage_callsign_enter_mode = set_callsign_enter_mode;
// disable/enable all buttons
for (int idx=0; idx<PM_NUM_BUTTONS; idx++) {
Buttons[gr_screen.res][idx].button.enable(!set_callsign_enter_mode);
}
// enable/disable hotkeys
pilot_manage_set_hotkeys(!set_callsign_enter_mode);
// disable/enable inputbox
Inputbox.enable(set_callsign_enter_mode);
// hide/unhide inputbox
Inputbox.hide(!set_callsign_enter_mode);
}
// creates a new pilot file
void pilot_manage_create_new_pilot()//UI_INPUTBOX *Inputbox)
{
// check if too many pilots
if (Num_pilots >= MAX_PILOTS) {
gamesnd_play_iface(SND_GENERAL_FAIL);
return;
}
// play sound for pilot creation
gamesnd_play_iface(SND_SCROLL);
// only write pilot file if there is an active pilot
if (strlen(Player->callsign)) {
write_pilot_file();
}
// move other pilot names and ranks down to make room for the new one
int idx = Num_pilots;
Assert(Num_pilots >= 0);
while (idx--) {
strcpy(Pilots[idx + 1], Pilots[idx]);
Pilot_ranks[idx + 1] = Pilot_ranks[idx];
}
Selected_line = 0;
Num_pilots++;
Pilots[Selected_line][0] = 0;
Pilot_ranks[Selected_line] = 0;
List_scroll_offset = 0;
// set mode to accept pilot name text
pilot_manage_set_callsign_enter_mode(true);
// set focus to input box
Inputbox.set_focus();
// set initial pilot name to ""
Inputbox.set_text("");
// reset size of input box to only 1 line
Inputbox.update_dimensions(Pilot_manage_list_coords[gr_screen.res][PM_X_COORD], Pilot_manage_list_coords[gr_screen.res][PM_Y_COORD], Pilot_manage_list_coords[gr_screen.res][PM_W_COORD], gr_get_font_height());
}
// exiting screen without canceling, so load in the new pilot selected here
int pilot_manage_pilot_accepted()
{
char str[CALLSIGN_LEN + 1];
// check if pilot active. If not, don't allow accept.
if (!Cur_pilot->callsign[0]){
return -1;
}
// set his image
player_set_squad_bitmap(Cur_pilot, Cur_pilot->squad_filename);
// Skill_level = get_default_skill_level();
// MWA -- I think that we should be writing Cur_pilot here.
//write_pilot_file(!is_pilot_multi(Cur_pilot));
write_pilot_file( Cur_pilot );
// when we store the LastPlayer key, we have to mark it as being single or multiplayer, so we know where to look for him
// (since we could have a single and a multiplayer pilot with the same callsign)
// we'll distinguish them by putting an M and the end of the multiplayer callsign and a P at the end of a single player
strcpy(str, Cur_pilot->callsign);
strcat(str, is_pilot_multi(Cur_pilot) ? NOX("M") : NOX("S"));
os_config_write_string( NULL, "LastPlayer", str );
return 0;
}
// scroll up pilot list one line
void pilot_manage_scroll_callsign_up()
{
if (Selected_line > 0) {
Selected_line--;
gamesnd_play_iface(SND_SCROLL);
} else {
gamesnd_play_iface(SND_GENERAL_FAIL);
}
if ((Selected_line >= 0) && (Selected_line < List_scroll_offset)) {
List_scroll_offset = Selected_line;
}
}
// scroll down pilot list one line
void pilot_manage_scroll_callsign_down()
{
if (Selected_line < Num_pilots - 1) {
Selected_line++;
gamesnd_play_iface(SND_SCROLL);
} else {
gamesnd_play_iface(SND_GENERAL_FAIL);
}
// num_pilots_to_fill_height is the number of pilots that can fit in given height
int num_pilots_to_fill_height = Pilot_manage_list_coords[gr_screen.res][PM_H_COORD] / gr_get_font_height();
if (Selected_line >= List_scroll_offset + num_pilots_to_fill_height) {
List_scroll_offset++;
}
}
void pilot_manage_delete_pilot()
{
char buf[MAX_FILENAME_LEN];
int active = 0;
if (!Num_pilots) {
gamesnd_play_iface(SND_GENERAL_FAIL);
return;
}
int popup_rval = popup(PF_TITLE_BIG | PF_TITLE_RED, 2, POPUP_NO, POPUP_YES, XSTR( "Warning!\n\nAre you sure you wish to delete this pilot?", 65));
if (popup_rval != 1) {
return;
}
if (!stricmp(Pilots[Selected_line], Cur_pilot->callsign)) {
active = 1;
}
strcpy(buf, Pilots[Selected_line]);
for (int i=Selected_line; i<Num_pilots-1; i++) {
strcpy(Pilots[i], Pilots[i + 1]);
Pilot_ranks[i] = Pilot_ranks[i + 1];
}
Num_pilots--;
if (Selected_line >= Num_pilots) {
Selected_line = Num_pilots - 1;
}
if (active) {
if (Selected_line >= 0) {
pilot_manage_new_pilot_selected();
} else {
Cur_pilot->callsign[0] = 0;
}
}
delete_pilot_file(buf, Player_sel_mode == PLAYER_SELECT_MODE_SINGLE ? 1 : 0);
gamesnd_play_iface(SND_USER_SELECT);
}
// Filter out pilots of wrong type (which shouldn't be in the directory we are checking, but just to be safe..)
int pilot_manage_pilot_filter(char *filename)
{
int r, rank;
r = verify_pilot_file(filename, Player_sel_mode == PLAYER_SELECT_MODE_SINGLE, &rank);
if (rank >= Rank_pips_count)
rank = Rank_pips_count - 1;
if (!r) {
Pilot_ranks[Num_pilots++] = rank;
}
return !r;
}
void pilot_manage_init_player_stuff(int mode)
{
// determine if we should be looking for single or multiplayers at the outset
Player_sel_mode = mode;
// get the list of pilots based upon whether we're in single or multiplayer mode
Num_pilots = 0;
Get_file_list_filter = pilot_manage_pilot_filter;
// single player specific stuff
if (mode == PLAYER_SELECT_MODE_SINGLE) {
Num_pilots = cf_get_file_list_preallocated(MAX_PILOTS, Pilots_arr, Pilots, CF_TYPE_SINGLE_PLAYERS, NOX("*.plr"), CF_SORT_TIME);
}
// multiplayer specific stuff
else {
Num_pilots = cf_get_file_list_preallocated(MAX_PILOTS, Pilots_arr, Pilots, CF_TYPE_MULTI_PLAYERS, NOX("*.plr"), CF_SORT_TIME);
}
int ranks[MAX_PILOTS];
int i;
for (i=0; i<Num_pilots; i++) {
int j;
for (j=0; j<Num_pilots; j++) {
if (!strcmp(Pilots[i], Pilots_arr[j])) {
ranks[i] = Pilot_ranks[j];
break;
}
}
Assert(j < Num_pilots); // Pilot not found? How is that possible?
}
for (i=0; i<Num_pilots; i++) {
Pilot_ranks[i] = ranks[i];
}
List_scroll_offset = 0;
Selected_line = 0;
// select whatever pilot was highlighted before switching modes
if (mode == PLAYER_SELECT_MODE_SINGLE && prev_single_player > -1) {
Selected_line = prev_single_player;
} else if (mode == PLAYER_SELECT_MODE_MULTI && prev_multi_player > -1) {
Selected_line = prev_multi_player;
} else {
// first time in select pilot from reg desk
for(int idx=0;idx<Num_pilots;idx++){
if(strcmp(Player->callsign, Pilots_arr[idx])==0){
Selected_line = idx;
break;
}
}
}
pilot_manage_new_pilot_selected();
}
void pilot_manage_display_pilot_callsigns(int prospective_pilot)
{
int y = 0;
int cur_pilot_idx = List_scroll_offset;
int multi = 0;
if (Player_sel_mode == PLAYER_SELECT_MODE_MULTI) {
multi = 1;
}
int font_height = gr_get_font_height();
//cur_pilot_idx = 1;
while (y + font_height <= Pilot_manage_list_coords[gr_screen.res][PM_H_COORD]) {
if (cur_pilot_idx >= Num_pilots)
break;
if (!stricmp(Cur_pilot->callsign, Pilots[cur_pilot_idx]) && (is_pilot_multi(Cur_pilot) == multi)) {
if ((cur_pilot_idx == Selected_line) || (cur_pilot_idx == prospective_pilot)) {
gr_set_color_fast(&Color_text_active_hi);
} else {
gr_set_color_fast(&Color_text_active);
}
} else {
if (cur_pilot_idx == Selected_line) {
gr_set_color_fast(&Color_text_selected);
} else if (cur_pilot_idx == prospective_pilot) {
gr_set_color_fast(&Color_text_subselected);
} else {
gr_set_color_fast(&Color_text_normal);
}
}
gr_printf(Pilot_manage_list_coords[gr_screen.res][PM_X_COORD], Pilot_manage_list_coords[gr_screen.res][PM_Y_COORD] + y, Pilots[cur_pilot_idx]);
gr_set_bitmap(Rank_pips_bitmaps + Pilot_ranks[cur_pilot_idx]);
gr_bitmap(Pilot_manage_list_coords[gr_screen.res][PM_X_COORD] - 34, Pilot_manage_list_coords[gr_screen.res][PM_Y_COORD] + y);
y += font_height;
cur_pilot_idx++;
}
}
// process pilot callsign
void pilot_manage_accept_new_pilot_callsign()
{
char buf[CALLSIGN_LEN + 1];
char name[MAX_FILENAME_LEN];
int i;
int z = 0;
Inputbox.get_text(buf);
drop_white_space(buf);
if (!isalpha(*buf)) {
z = 1;
} else {
for (i=1; buf[i]; i++) {
if (!isalpha(buf[i]) && !isdigit(buf[i]) && !strchr(VALID_PILOT_CHARS, buf[i])) {
z = 1;
return;
}
}
}
for (i=1; i<Num_pilots; i++) {
if (!stricmp(buf, Pilots[i])) {
z = 1;
if (pilot_verify_overwrite() == 1) {
strcpy(name, Pilots[Selected_line]);
for (z=i; z<Num_pilots-1; z++) {
strcpy(Pilots[z], Pilots[z + 1]);
Pilot_ranks[z] = Pilot_ranks[z + 1];
}
Num_pilots--;
delete_pilot_file(name, Player_sel_mode == PLAYER_SELECT_MODE_SINGLE ? 1 : 0);
z = 0;
}
return;
}
}
if (!*buf || (i < Num_pilots)) { // duplicate name, alert user
z = 1;
}
if (z) {
gamesnd_play_iface(SND_GENERAL_FAIL);
return;
}
strcpy(Pilots[0], buf);
strcpy(Cur_pilot->callsign, buf);
init_new_pilot(Cur_pilot, !Clone_flag);
// again, make sure we set his flags correctly to ensure that he gets saved to the proper directory and gets
// displayed correctly
if (Player_sel_mode == PLAYER_SELECT_MODE_SINGLE) {
Cur_pilot->flags &= ~(PLAYER_FLAGS_IS_MULTI);
} else {
Cur_pilot->flags |= PLAYER_FLAGS_IS_MULTI;
Cur_pilot->stats.flags |= STATS_FLAG_MULTIPLAYER;
}
if ( !(Game_mode & GM_STANDALONE_SERVER) ) {
write_pilot_file(Cur_pilot);
}
Selected_line = 0;
pilot_manage_new_pilot_selected();
pilot_manage_set_callsign_enter_mode(false);
}
void pilot_manage_button_pressed(int n)
{
switch (n) {
//scroll pilot list up
case PM_UP_BUTTON:
pilot_manage_scroll_callsign_up();
break;
// scroll pilot list down
case PM_DOWN_BUTTON:
pilot_manage_scroll_callsign_down();
break;
// switch to single mode
case PM_SINGLE_MODE_BUTTON:
if (Player_sel_mode != PLAYER_SELECT_MODE_SINGLE) {
gamesnd_play_iface(SND_USER_SELECT);
// switching to multi so save multi player offset
prev_multi_player = Selected_line;
pilot_manage_init_player_stuff(PLAYER_SELECT_MODE_SINGLE);
}
break;
// switch to multi mode
case PM_MULTI_MODE_BUTTON:
if (Player_sel_mode != PLAYER_SELECT_MODE_MULTI) {
gamesnd_play_iface(SND_USER_SELECT);
// switching to multi so save single player offset
prev_single_player = Selected_line;
pilot_manage_init_player_stuff(PLAYER_SELECT_MODE_MULTI);
}
break;
//create new pilot
case PM_CREATE_BUTTON:
Clone_flag = 0;
pilot_manage_create_new_pilot();
break;
// select pilot
case PM_ACTIVE_BUTTON:
if (pilot_manage_new_pilot_selected()){
gamesnd_play_iface(SND_GENERAL_FAIL);
// throw up a popup telling the player that he should create a pilot first
if(Player_sel_mode == PLAYER_SELECT_MODE_SINGLE){
popup(PF_USE_AFFIRMATIVE_ICON,1,POPUP_OK,XSTR( "You must create a single player pilot.", 66));
} else {
popup(PF_USE_AFFIRMATIVE_ICON,1,POPUP_OK,XSTR( "You must create a multi player pilot.", 67));
}
} else {
gamesnd_play_iface(SND_SCROLL);
}
break;
// clone pilot
case PM_CLONE_BUTTON:
//case B_PILOT_CLONE_BUTTON:
if (Num_pilots < 1) {
gamesnd_play_error_beep();
break;
}
Clone_flag = 1;
pilot_manage_create_new_pilot();
break;
// convert pilot single/multi
case PM_CONVERT_BUTTON:
{
char temp[256], *str;
char old_pic[256] = "";
char old_squad_pic[256] = "";
char old_squad[256] = "";
int z;
if (!pilot_manage_new_pilot_selected()) {
if (Player_sel_mode == PLAYER_SELECT_MODE_SINGLE)
str = XSTR( "multiplayer", 68);
else
str = XSTR( "single player", 69);
sprintf(temp, XSTR( "This will overwrite your %s pilot. Proceed?", 70), str);
if (!verify_pilot_file(Cur_pilot->callsign, Player_sel_mode == PLAYER_SELECT_MODE_MULTI)) {
z = popup(0, 2, POPUP_CANCEL, POPUP_OK, temp);
if (z != 1)
break;
}
strcpy(old_pic, Cur_pilot->image_filename);
strcpy(old_squad_pic, Cur_pilot->squad_filename);
strcpy(old_squad, Cur_pilot->squad_name);
init_new_pilot(Cur_pilot, 0);
strcpy(Cur_pilot->image_filename, old_pic);
strcpy(Cur_pilot->squad_filename, old_squad_pic);
strcpy(Cur_pilot->squad_name, old_squad);
if (Player_sel_mode == PLAYER_SELECT_MODE_SINGLE) {
Cur_pilot->flags |= PLAYER_FLAGS_IS_MULTI;
write_pilot_file();
pilot_manage_init_player_stuff(PLAYER_SELECT_MODE_MULTI);
} else {
write_pilot_file();
pilot_manage_init_player_stuff(PLAYER_SELECT_MODE_SINGLE);
}
gamesnd_play_iface(SND_USER_SELECT);
} else {
gamesnd_play_iface(SND_GENERAL_FAIL);
}
break;
}
// delete pilot
case PM_DELETE_BUTTON:
pilot_manage_delete_pilot();
break;
// exit pilot selection
case PM_EXIT_BUTTON:
if (Num_pilots && !pilot_manage_pilot_accepted()) {
gamesnd_play_iface(SND_COMMIT_PRESSED);
gameseq_post_event(GS_EVENT_PREVIOUS_STATE);
} else {
gamesnd_play_iface(SND_GENERAL_FAIL);
// throw up a popup telling the player that he should create a pilot first
if(Player_sel_mode == PLAYER_SELECT_MODE_SINGLE){
popup(PF_USE_AFFIRMATIVE_ICON,1,POPUP_OK,XSTR( "You must create a single player pilot.", 66));
} else {
popup(PF_USE_AFFIRMATIVE_ICON,1,POPUP_OK,XSTR( "You must create a multi player pilot.", 67));
}
}
break;
case PM_TC_BUTTON:
popup_tc();
// want to switch it over to multiplayer pilots
prev_single_player = Selected_line;
pilot_manage_init_player_stuff(PLAYER_SELECT_MODE_MULTI);
break;
}
}
void pilot_manage_init(void)
{
UI_WINDOW *w = &Ui_window;
// create interface
Ui_window.create(0, 0, gr_screen.max_w, gr_screen.max_h, 0);
Ui_window.set_mask_bmap(PilotManage_bitmap_mask_fname[gr_screen.res]);
// load background bitmap
Background_bitmap = bm_load(PilotManage_bitmap_fname[gr_screen.res]);
if(Background_bitmap < 0){
// we failed to load the bitmap - this is very bad
Int3();
}
for (int i=0; i<PM_NUM_BUTTONS; i++) {
// create the object
Buttons[gr_screen.res][i].button.create(&Ui_window, "", Buttons[gr_screen.res][i].x, Buttons[gr_screen.res][i].y, 60, 30, Buttons[gr_screen.res][i].repeat, 1);
// set the sound to play when highlighted
Buttons[gr_screen.res][i].button.set_highlight_action(common_play_highlight_sound);
// set the ani for the button
Buttons[gr_screen.res][i].button.set_bmaps(Buttons[gr_screen.res][i].filename);
// set the hotspot
Buttons[gr_screen.res][i].button.link_hotspot(Buttons[gr_screen.res][i].hotspot);
}
// load in help overlay bitmap
// needs to be fixed, taked out to get to compile
// help_overlay_load(PILOT_MANAGE_OVERLAY);
// help_overlay_set_state(PILOT_MANAGE_OVERLAY,0);
// button for selecting pilot
List_region.create(&Ui_window, "", Pilot_manage_list_coords[gr_screen.res][PM_X_COORD], Pilot_manage_list_coords[gr_screen.res][PM_Y_COORD], Pilot_manage_list_coords[gr_screen.res][PM_W_COORD], Pilot_manage_list_coords[gr_screen.res][PM_H_COORD], 0, 1);
List_region.hide();
// create input box (for new pilot)
Inputbox.create(&Ui_window, Pilot_manage_list_coords[gr_screen.res][PM_X_COORD], Pilot_manage_list_coords[gr_screen.res][PM_Y_COORD], Pilot_manage_list_coords[gr_screen.res][PM_W_COORD], CALLSIGN_LEN - 1, "", UI_INPUTBOX_FLAG_INVIS | UI_INPUTBOX_FLAG_KEYTHRU | UI_INPUTBOX_FLAG_LETTER_FIRST);
Inputbox.set_valid_chars(VALID_PILOT_CHARS);
Inputbox.disable();
Inputbox.hide();
Rank_pips_bitmaps = bm_load_animation("IconRankMini.ani", &Rank_pips_count);
pilot_manage_callsign_enter_mode = 0;
List_scroll_offset = Pic_number = Pic_squad_number;// = Selected_line = 0;
prev_single_player = -1;
prev_multi_player = -1;
pilot_manage_init_player_stuff(is_pilot_multi(Player));
// enable hotkeys from start
pilot_manage_set_callsign_enter_mode(false);
}
void pilot_manage_do(void)
{
int k = Ui_window.process();
int i;
if ( k > 0 ) {
// put back in when overlay stuff is fixed
// if ( help_overlay_active(PILOT_MANAGE_OVERLAY) ) {
// help_overlay_set_state(PILOT_MANAGE_OVERLAY,0);
// k = 0;
// }
}
switch (k)
{
case KEY_ESC: // cancel only if not trying to enter a pilot name
if (!pilot_manage_callsign_enter_mode)
gameseq_post_event(GS_EVENT_BARRACKS_MENU);//GS_EVENT_PREVIOUS_STATE
break;
} // end switch
int prospective_pilot = -1;
// Entering pilot callsign
if (pilot_manage_callsign_enter_mode) {
// set focus to inputbox
Inputbox.set_focus();
switch (k) {
case KEY_ESC:
// cancel create pilot
Num_pilots--;
for (i=0; i<Num_pilots; i++) {
strcpy(Pilots[i], Pilots[i + 1]);
Pilot_ranks[i] = Pilot_ranks[i + 1];
}
pilot_manage_set_callsign_enter_mode(false);
break;
case KEY_ENTER:
pilot_manage_accept_new_pilot_callsign();
break;
}
}
// process buttons
for (i=0; i<PM_NUM_BUTTONS; i++) {
if (Buttons[gr_screen.res][i].button.pressed()) {
pilot_manage_button_pressed(i);
}
}
// pilot that mouse is over
// if mouse is over a pilot, find index into Pilots array
if (List_region.is_mouse_on()) {
int y;
List_region.get_mouse_pos(NULL, &y);
int pilot_index = List_scroll_offset + (y / gr_get_font_height());
if ((pilot_index >= 0) && (pilot_index < Num_pilots)) {
prospective_pilot = pilot_index;
}
}
// if mouse clicked in list region, find index into Pilots array
if (List_region.pressed()) {
if (prospective_pilot != -1) {
Selected_line = prospective_pilot;
gamesnd_play_iface(SND_USER_SELECT);
}
}
gr_reset_clip();
GR_MAYBE_CLEAR_RES(Background_bitmap);
if (Background_bitmap >= 0) {
gr_set_bitmap(Background_bitmap);
gr_bitmap(0, 0);
}
Ui_window.draw();
//light up the correct mode button (single or multi)
if (Player_sel_mode == PLAYER_SELECT_MODE_SINGLE) {
Buttons[gr_screen.res][PM_SINGLE_MODE_BUTTON].button.draw_forced(2);
} else {
Buttons[gr_screen.res][PM_MULTI_MODE_BUTTON].button.draw_forced(2);
}
pilot_manage_display_pilot_callsigns(prospective_pilot);
pilot_manage_force_button_frame();
pilot_manage_maybe_show_button_text();
// needs to be fixed help_overlay_maybe_blit(PILOT_MANAGE_OVERLAY);
gr_flip();
}
void pilot_manage_close(void)
{
// destroy window
Ui_window.destroy();
// release background bitmap
if (Background_bitmap >= 0) {
bm_unload(Background_bitmap);
}
// unload the overlay bitmap
// fix it help_overlay_unload(PILOT_MANAGE_OVERLAY);
game_flush();
}
void pilot_manage_force_button_frame()
{
for (int x=0; x<PM_NUM_BUTTONS; x++) {
if ( !Buttons[gr_screen.res][x].button.button_down())
Buttons[gr_screen.res][x].button.draw_forced(1);
}
}
void pilot_manage_maybe_show_button_text()
{
pilot_manage_buttons *b;
// skip the up/down arrows
for (int i=0; i<PM_NUM_BUTTONS; i++) {
b = &Buttons[gr_screen.res][i];
if (b->button.button_hilighted()) {
gr_set_color_fast(&Color_bright_white);
gr_string(Pilot_manage_text[gr_screen.res][i].x, Pilot_manage_text[gr_screen.res][i].y, Pilot_manage_text[gr_screen.res][i].xstr);
}
}
}
// this will make a TC pilot based on his info from the database
void pilot_manage_make_tc_pilot(Idline id, char *name)
{
// play sound for pilot creation
gamesnd_play_iface(SND_SCROLL);
// only write pilot file if there is an active pilot
if (strlen(Player->callsign)) {
write_pilot_file();
}
int z = 0;
for (int i=0; i<Num_pilots; i++) {
if (!stricmp(name, Pilots[i])) {
z = 1;
if (pilot_verify_overwrite() == 1) {
for (z=i; z<Num_pilots-1; z++) {
strcpy(Pilots[z], Pilots[z + 1]);
Pilot_ranks[z] = Pilot_ranks[z + 1];
}
Num_pilots--;
delete_pilot_file(name, 0);
z = 0;
} else
return;
}
}
if (!*name || (i < Num_pilots)) { // duplicate name, alert user
z = 1;
}
if (z) {
gamesnd_play_iface(SND_GENERAL_FAIL);
return;
}
// move other pilot names and ranks down to make room for the new one
int idx = Num_pilots;
Assert(Num_pilots >= 0);
while (idx--) {
strcpy(Pilots[idx + 1], Pilots[idx]);
Pilot_ranks[idx + 1] = Pilot_ranks[idx];
}
Selected_line = 0;
Num_pilots++;
Pilots[Selected_line][0] = 0;
Pilot_ranks[Selected_line] = 0;
List_scroll_offset = 0;
strcpy(Pilots[0], name);
// make sure his rank pip matches his actual rank
Pilot_ranks[0] = get_rank(id.rank);
strcpy(Cur_pilot->callsign, name);
init_new_pilot(Cur_pilot, !Clone_flag);
Cur_pilot->flags |= PLAYER_FLAGS_IS_MULTI;
Cur_pilot->stats.flags |= STATS_FLAG_MULTIPLAYER;
Cur_pilot->stats.rank = get_rank(id.rank);
Cur_pilot->stats.fchg = get_fchg(id.fchg);
make_medals(&Cur_pilot->stats, id.medals);
write_pilot_file(Cur_pilot);
pilot_manage_new_pilot_selected();
}
| [
"[email protected]"
]
| [
[
[
1,
1135
]
]
]
|
ddeedfa8746a346815b4af2557bf4764b112d3f4 | 83ed25c6e6b33b2fabd4f81bf91d5fae9e18519c | /code/Q3DLoader.cpp | 2b69dce61802c849e0bc82a0a427a7447590549c | [
"BSD-3-Clause"
]
| permissive | spring/assimp | fb53b91228843f7677fe8ec18b61d7b5886a6fd3 | db29c9a20d0dfa9f98c8fd473824bba5a895ae9e | refs/heads/master | 2021-01-17T23:19:56.511185 | 2011-11-08T12:15:18 | 2011-11-08T12:15:18 | 2,017,841 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 18,673 | cpp | /*
---------------------------------------------------------------------------
Open Asset Import Library (ASSIMP)
---------------------------------------------------------------------------
Copyright (c) 2006-2010, ASSIMP Development Team
All rights reserved.
Redistribution and use of this software in source and binary forms,
with or without modification, are permitted provided that the following
conditions are met:
* Redistributions of source code must retain the above
copyright notice, this list of conditions and the
following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other
materials provided with the distribution.
* Neither the name of the ASSIMP team, nor the names of its
contributors may be used to endorse or promote products
derived from this software without specific prior
written permission of the ASSIMP Development Team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------
*/
/** @file Q3DLoader.cpp
* @brief Implementation of the Q3D importer class
*/
#include "AssimpPCH.h"
#ifndef ASSIMP_BUILD_NO_Q3D_IMPORTER
// internal headers
#include "Q3DLoader.h"
#include "StreamReader.h"
#include "fast_atof.h"
using namespace Assimp;
// ------------------------------------------------------------------------------------------------
// Constructor to be privately used by Importer
Q3DImporter::Q3DImporter()
{}
// ------------------------------------------------------------------------------------------------
// Destructor, private as well
Q3DImporter::~Q3DImporter()
{}
// ------------------------------------------------------------------------------------------------
// Returns whether the class can handle the format of the given file.
bool Q3DImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
{
const std::string extension = GetExtension(pFile);
if (extension == "q3s" || extension == "q3o")
return true;
else if (!extension.length() || checkSig) {
if (!pIOHandler)
return true;
const char* tokens[] = {"quick3Do","quick3Ds"};
return SearchFileHeaderForToken(pIOHandler,pFile,tokens,2);
}
return false;
}
// ------------------------------------------------------------------------------------------------
void Q3DImporter::GetExtensionList(std::set<std::string>& extensions)
{
extensions.insert("q3o");
extensions.insert("q3s");
}
// ------------------------------------------------------------------------------------------------
// Imports the given file into the given scene structure.
void Q3DImporter::InternReadFile( const std::string& pFile,
aiScene* pScene, IOSystem* pIOHandler)
{
StreamReaderLE stream(pIOHandler->Open(pFile,"rb"));
// The header is 22 bytes large
if (stream.GetRemainingSize() < 22)
throw DeadlyImportError("File is either empty or corrupt: " + pFile);
// Check the file's signature
if (ASSIMP_strincmp( (const char*)stream.GetPtr(), "quick3Do", 8 ) &&
ASSIMP_strincmp( (const char*)stream.GetPtr(), "quick3Ds", 8 ))
{
throw DeadlyImportError("Not a Quick3D file. Signature string is: " +
std::string((const char*)stream.GetPtr(),8));
}
// Print the file format version
DefaultLogger::get()->info("Quick3D File format version: " +
std::string(&((const char*)stream.GetPtr())[8],2));
// ... an store it
char major = ((const char*)stream.GetPtr())[8];
char minor = ((const char*)stream.GetPtr())[9];
stream.IncPtr(10);
unsigned int numMeshes = (unsigned int)stream.GetI4();
unsigned int numMats = (unsigned int)stream.GetI4();
unsigned int numTextures = (unsigned int)stream.GetI4();
std::vector<Material> materials;
materials.reserve(numMats);
std::vector<Mesh> meshes;
meshes.reserve(numMeshes);
// Allocate the scene root node
pScene->mRootNode = new aiNode();
aiColor3D fgColor (0.6f,0.6f,0.6f);
// Now read all file chunks
while (true)
{
if (stream.GetRemainingSize() < 1)break;
char c = stream.GetI1();
switch (c)
{
// Meshes chunk
case 'm':
{
for (unsigned int quak = 0; quak < numMeshes; ++quak)
{
meshes.push_back(Mesh());
Mesh& mesh = meshes.back();
// read all vertices
unsigned int numVerts = (unsigned int)stream.GetI4();
if (!numVerts)
throw DeadlyImportError("Quick3D: Found mesh with zero vertices");
std::vector<aiVector3D>& verts = mesh.verts;
verts.resize(numVerts);
for (unsigned int i = 0; i < numVerts;++i)
{
verts[i].x = stream.GetF4();
verts[i].y = stream.GetF4();
verts[i].z = stream.GetF4();
}
// read all faces
numVerts = (unsigned int)stream.GetI4();
if (!numVerts)
throw DeadlyImportError("Quick3D: Found mesh with zero faces");
std::vector<Face >& faces = mesh.faces;
faces.reserve(numVerts);
// number of indices
for (unsigned int i = 0; i < numVerts;++i)
{
faces.push_back(Face(stream.GetI2()) );
if (faces.back().indices.empty())
throw DeadlyImportError("Quick3D: Found face with zero indices");
}
// indices
for (unsigned int i = 0; i < numVerts;++i)
{
Face& vec = faces[i];
for (unsigned int a = 0; a < (unsigned int)vec.indices.size();++a)
vec.indices[a] = stream.GetI4();
}
// material indices
for (unsigned int i = 0; i < numVerts;++i)
{
faces[i].mat = (unsigned int)stream.GetI4();
}
// read all normals
numVerts = (unsigned int)stream.GetI4();
std::vector<aiVector3D>& normals = mesh.normals;
normals.resize(numVerts);
for (unsigned int i = 0; i < numVerts;++i)
{
normals[i].x = stream.GetF4();
normals[i].y = stream.GetF4();
normals[i].z = stream.GetF4();
}
numVerts = (unsigned int)stream.GetI4();
if (numTextures && numVerts)
{
// read all texture coordinates
std::vector<aiVector3D>& uv = mesh.uv;
uv.resize(numVerts);
for (unsigned int i = 0; i < numVerts;++i)
{
uv[i].x = stream.GetF4();
uv[i].y = stream.GetF4();
}
// UV indices
for (unsigned int i = 0; i < (unsigned int)faces.size();++i)
{
Face& vec = faces[i];
for (unsigned int a = 0; a < (unsigned int)vec.indices.size();++a)
{
vec.uvindices[a] = stream.GetI4();
if (!i && !a)
mesh.prevUVIdx = vec.uvindices[a];
else if (vec.uvindices[a] != mesh.prevUVIdx)
mesh.prevUVIdx = UINT_MAX;
}
}
}
// we don't need the rest, but we need to get to the next chunk
stream.IncPtr(36);
if (minor > '0' && major == '3')
stream.IncPtr(mesh.faces.size());
}
// stream.IncPtr(4); // unknown value here
}
break;
// materials chunk
case 'c':
for (unsigned int i = 0; i < numMats; ++i)
{
materials.push_back(Material());
Material& mat = materials.back();
// read the material name
while (( c = stream.GetI1()))
mat.name.data[mat.name.length++] = c;
// add the terminal character
mat.name.data[mat.name.length] = '\0';
// read the ambient color
mat.ambient.r = stream.GetF4();
mat.ambient.g = stream.GetF4();
mat.ambient.b = stream.GetF4();
// read the diffuse color
mat.diffuse.r = stream.GetF4();
mat.diffuse.g = stream.GetF4();
mat.diffuse.b = stream.GetF4();
// read the ambient color
mat.specular.r = stream.GetF4();
mat.specular.g = stream.GetF4();
mat.specular.b = stream.GetF4();
// read the transparency
mat.transparency = stream.GetF4();
// unknown value here
// stream.IncPtr(4);
// FIX: it could be the texture index ...
mat.texIdx = (unsigned int)stream.GetI4();
}
break;
// texture chunk
case 't':
pScene->mNumTextures = numTextures;
if (!numTextures)break;
pScene->mTextures = new aiTexture*[pScene->mNumTextures];
// to make sure we won't crash if we leave through an exception
::memset(pScene->mTextures,0,sizeof(void*)*pScene->mNumTextures);
for (unsigned int i = 0; i < pScene->mNumTextures; ++i)
{
aiTexture* tex = pScene->mTextures[i] = new aiTexture();
// skip the texture name
while (stream.GetI1());
// read texture width and height
tex->mWidth = (unsigned int)stream.GetI4();
tex->mHeight = (unsigned int)stream.GetI4();
if (!tex->mWidth || !tex->mHeight)
throw DeadlyImportError("Quick3D: Invalid texture. Width or height is zero");
register unsigned int mul = tex->mWidth * tex->mHeight;
aiTexel* begin = tex->pcData = new aiTexel[mul];
aiTexel* const end = & begin [mul];
for (;begin != end; ++begin)
{
begin->r = stream.GetI1();
begin->g = stream.GetI1();
begin->b = stream.GetI1();
begin->a = 0xff;
}
}
break;
// scene chunk
case 's':
{
// skip position and rotation
stream.IncPtr(12);
for (unsigned int i = 0; i < 4;++i)
for (unsigned int a = 0; a < 4;++a)
pScene->mRootNode->mTransformation[i][a] = stream.GetF4();
stream.IncPtr(16);
// now setup a single camera
pScene->mNumCameras = 1;
pScene->mCameras = new aiCamera*[1];
aiCamera* cam = pScene->mCameras[0] = new aiCamera();
cam->mPosition.x = stream.GetF4();
cam->mPosition.y = stream.GetF4();
cam->mPosition.z = stream.GetF4();
cam->mName.Set("Q3DCamera");
// skip eye rotation for the moment
stream.IncPtr(12);
// read the default material color
fgColor .r = stream.GetF4();
fgColor .g = stream.GetF4();
fgColor .b = stream.GetF4();
// skip some unimportant properties
stream.IncPtr(29);
// setup a single point light with no attenuation
pScene->mNumLights = 1;
pScene->mLights = new aiLight*[1];
aiLight* light = pScene->mLights[0] = new aiLight();
light->mName.Set("Q3DLight");
light->mType = aiLightSource_POINT;
light->mAttenuationConstant = 1;
light->mAttenuationLinear = 0;
light->mAttenuationQuadratic = 0;
light->mColorDiffuse.r = stream.GetF4();
light->mColorDiffuse.g = stream.GetF4();
light->mColorDiffuse.b = stream.GetF4();
light->mColorSpecular = light->mColorDiffuse;
// We don't need the rest, but we need to know where
// this fucking chunk ends.
unsigned int temp = (unsigned int)(stream.GetI4() * stream.GetI4());
// skip the background file name
while (stream.GetI1());
// skip background texture data + the remaining fields
stream.IncPtr(temp*3 + 20); // 4 bytes of unknown data here
// TODO
goto outer;
}
break;
default:
throw DeadlyImportError("Quick3D: Unknown chunk");
break;
};
}
outer:
// If we have no mesh loaded - break here
if (meshes.empty())
throw DeadlyImportError("Quick3D: No meshes loaded");
// If we have no materials loaded - generate a default mat
if (materials.empty())
{
DefaultLogger::get()->info("Quick3D: No material found, generating one");
materials.push_back(Material());
materials.back().diffuse = fgColor ;
}
// find out which materials we'll need
typedef std::pair<unsigned int, unsigned int> FaceIdx;
typedef std::vector< FaceIdx > FaceIdxArray;
FaceIdxArray* fidx = new FaceIdxArray[materials.size()];
unsigned int p = 0;
for (std::vector<Mesh>::iterator it = meshes.begin(), end = meshes.end();
it != end; ++it,++p)
{
unsigned int q = 0;
for (std::vector<Face>::iterator fit = (*it).faces.begin(), fend = (*it).faces.end();
fit != fend; ++fit,++q)
{
if ((*fit).mat >= materials.size())
{
DefaultLogger::get()->warn("Quick3D: Material index overflow");
(*fit).mat = 0;
}
if (fidx[(*fit).mat].empty())++pScene->mNumMeshes;
fidx[(*fit).mat].push_back( FaceIdx(p,q) );
}
}
pScene->mNumMaterials = pScene->mNumMeshes;
pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials];
pScene->mMeshes = new aiMesh*[pScene->mNumMaterials];
for (unsigned int i = 0, real = 0; i < (unsigned int)materials.size(); ++i)
{
if (fidx[i].empty())continue;
// Allocate a mesh and a material
aiMesh* mesh = pScene->mMeshes[real] = new aiMesh();
aiMaterial* mat = new aiMaterial();
pScene->mMaterials[real] = mat;
mesh->mMaterialIndex = real;
// Build the output material
Material& srcMat = materials[i];
mat->AddProperty(&srcMat.diffuse, 1,AI_MATKEY_COLOR_DIFFUSE);
mat->AddProperty(&srcMat.specular, 1,AI_MATKEY_COLOR_SPECULAR);
mat->AddProperty(&srcMat.ambient, 1,AI_MATKEY_COLOR_AMBIENT);
// NOTE: Ignore transparency for the moment - it seems
// unclear how to interpret the data
#if 0
if (!(minor > '0' && major == '3'))
srcMat.transparency = 1.0f - srcMat.transparency;
mat->AddProperty(&srcMat.transparency, 1, AI_MATKEY_OPACITY);
#endif
// add shininess - Quick3D seems to use it ins its viewer
srcMat.transparency = 16.f;
mat->AddProperty(&srcMat.transparency, 1, AI_MATKEY_SHININESS);
int m = (int)aiShadingMode_Phong;
mat->AddProperty(&m, 1, AI_MATKEY_SHADING_MODEL);
if (srcMat.name.length)
mat->AddProperty(&srcMat.name,AI_MATKEY_NAME);
// Add a texture
if (srcMat.texIdx < pScene->mNumTextures || real < pScene->mNumTextures)
{
srcMat.name.data[0] = '*';
srcMat.name.length = ASSIMP_itoa10(&srcMat.name.data[1],1000,
(srcMat.texIdx < pScene->mNumTextures ? srcMat.texIdx : real));
mat->AddProperty(&srcMat.name,AI_MATKEY_TEXTURE_DIFFUSE(0));
}
mesh->mNumFaces = (unsigned int)fidx[i].size();
aiFace* faces = mesh->mFaces = new aiFace[mesh->mNumFaces];
// Now build the output mesh. First find out how many
// vertices we'll need
for (FaceIdxArray::const_iterator it = fidx[i].begin(),end = fidx[i].end();
it != end; ++it)
{
mesh->mNumVertices += (unsigned int)meshes[(*it).first].faces[
(*it).second].indices.size();
}
aiVector3D* verts = mesh->mVertices = new aiVector3D[mesh->mNumVertices];
aiVector3D* norms = mesh->mNormals = new aiVector3D[mesh->mNumVertices];
aiVector3D* uv;
if (real < pScene->mNumTextures)
{
uv = mesh->mTextureCoords[0] = new aiVector3D[mesh->mNumVertices];
mesh->mNumUVComponents[0] = 2;
}
else uv = NULL;
// Build the final array
unsigned int cnt = 0;
for (FaceIdxArray::const_iterator it = fidx[i].begin(),end = fidx[i].end();
it != end; ++it, ++faces)
{
Mesh& m = meshes[(*it).first];
Face& face = m.faces[(*it).second];
faces->mNumIndices = (unsigned int)face.indices.size();
faces->mIndices = new unsigned int [faces->mNumIndices];
aiVector3D faceNormal;
bool fnOK = false;
for (unsigned int n = 0; n < faces->mNumIndices;++n, ++cnt, ++norms, ++verts)
{
if (face.indices[n] >= m.verts.size())
{
DefaultLogger::get()->warn("Quick3D: Vertex index overflow");
face.indices[n] = 0;
}
// copy vertices
*verts = m.verts[ face.indices[n] ];
if (face.indices[n] >= m.normals.size() && faces->mNumIndices >= 3)
{
// we have no normal here - assign the face normal
if (!fnOK)
{
const aiVector3D& pV1 = m.verts[ face.indices[0] ];
const aiVector3D& pV2 = m.verts[ face.indices[1] ];
const aiVector3D& pV3 = m.verts[ face.indices.size() - 1 ];
faceNormal = (pV2 - pV1) ^ (pV3 - pV1).Normalize();
fnOK = true;
}
*norms = faceNormal;
}
else *norms = m.normals[ face.indices[n] ];
// copy texture coordinates
if (uv && m.uv.size())
{
if (m.prevUVIdx != 0xffffffff && m.uv.size() >= m.verts.size()) // workaround
{
*uv = m.uv[face.indices[n]];
}
else
{
if (face.uvindices[n] >= m.uv.size())
{
DefaultLogger::get()->warn("Quick3D: Texture coordinate index overflow");
face.uvindices[n] = 0;
}
*uv = m.uv[face.uvindices[n]];
}
uv->y = 1.f - uv->y;
++uv;
}
// setup the new vertex index
faces->mIndices[n] = cnt;
}
}
++real;
}
// Delete our nice helper array
delete[] fidx;
// Now we need to attach the meshes to the root node of the scene
pScene->mRootNode->mNumMeshes = pScene->mNumMeshes;
pScene->mRootNode->mMeshes = new unsigned int [pScene->mNumMeshes];
for (unsigned int i = 0; i < pScene->mNumMeshes;++i)
pScene->mRootNode->mMeshes[i] = i;
/*pScene->mRootNode->mTransformation *= aiMatrix4x4(
1.f, 0.f, 0.f, 0.f,
0.f, -1.f,0.f, 0.f,
0.f, 0.f, 1.f, 0.f,
0.f, 0.f, 0.f, 1.f);*/
// Add cameras and light sources to the scene root node
pScene->mRootNode->mNumChildren = pScene->mNumLights+pScene->mNumCameras;
if (pScene->mRootNode->mNumChildren)
{
pScene->mRootNode->mChildren = new aiNode* [ pScene->mRootNode->mNumChildren ];
// the light source
aiNode* nd = pScene->mRootNode->mChildren[0] = new aiNode();
nd->mParent = pScene->mRootNode;
nd->mName.Set("Q3DLight");
nd->mTransformation = pScene->mRootNode->mTransformation;
nd->mTransformation.Inverse();
// camera
nd = pScene->mRootNode->mChildren[1] = new aiNode();
nd->mParent = pScene->mRootNode;
nd->mName.Set("Q3DCamera");
nd->mTransformation = pScene->mRootNode->mChildren[0]->mTransformation;
}
}
#endif // !! ASSIMP_BUILD_NO_Q3D_IMPORTER
| [
"aramis_acg@67173fc5-114c-0410-ac8e-9d2fd5bffc1f"
]
| [
[
[
1,
600
]
]
]
|
c6290c4c4138bb92565a629ff60142267f5339c1 | b8c3d2d67e983bd996b76825f174bae1ba5741f2 | /RTMP/utils/gil_2/boost/gil/extension/io_new/detail/read_and_convert_view.hpp | 66e20d66926309ba2771b5908801722aaba53790 | []
| no_license | wangscript007/rtmp-cpp | 02172f7a209790afec4c00b8855d7a66b7834f23 | 3ec35590675560ac4fa9557ca7a5917c617d9999 | refs/heads/master | 2021-05-30T04:43:19.321113 | 2008-12-24T20:16:15 | 2008-12-24T20:16:15 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12,618 | hpp | /*
Copyright 2007-2008 Christian Henning, Andreas Pokorny, Lubomir Bourdev
Use, modification and distribution are subject to the Boost Software License,
Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt).
*/
/*************************************************************************************************/
#ifndef BOOST_GIL_EXTENSION_IO_READ_AND_CONVERT_VIEW_HPP_INCLUDED
#define BOOST_GIL_EXTENSION_IO_READ_AND_CONVERT_VIEW_HPP_INCLUDED
////////////////////////////////////////////////////////////////////////////////////////
/// \file
/// \brief
/// \author Christian Henning, Andreas Pokorny, Lubomir Bourdev \n
///
/// \date 2007-2008 \n
///
////////////////////////////////////////////////////////////////////////////////////////
#include <boost/type_traits/is_base_and_derived.hpp>
#include <boost/mpl/and.hpp>
#include <boost/utility/enable_if.hpp>
#include "base.hpp"
#include "io_device.hpp"
#include "path_spec.hpp"
#include "conversion_policies.hpp"
namespace boost{ namespace gil {
// ----- View --- Reader --------- With ColorConverter -----------------
/// \ingroup IO
template< typename Device
, typename View
, typename ColorConverter
, typename FormatTag
>
inline
void read_and_convert_view( Device& file
, const View& view
, const point_t& top_left
, const ColorConverter& cc
, const FormatTag& tag
, typename enable_if< typename mpl::and_< typename is_format_tag< FormatTag >::type
, typename detail::is_input_device< Device >::type
>::type
>::type* ptr = 0
)
{
typedef detail::read_and_convert< ColorConverter > reader_color_convert;
detail::reader< Device
, FormatTag
, reader_color_convert
> reader( file
, cc
);
reader.init_view( view
, top_left
, reader.get_info()
);
reader.apply( view );
}
template< typename Device
, typename View
, typename ColorConverter
, typename FormatTag
>
inline
void read_and_convert_view( Device& file
, const View& view
, const point_t& top_left
, const ColorConverter& cc
, const FormatTag& tag
, typename enable_if< typename mpl::and_< typename detail::is_adaptable_input_device< FormatTag
, Device
>::type
, typename is_format_tag< FormatTag >::type
>::type
>::type* ptr = 0
)
{
typedef typename detail::is_adaptable_input_device< FormatTag
, Device
>::device_type device_type;
device_type dev( file );
read_and_convert_view( dev
, view
, top_left
, cc
, tag
);
}
template < typename String
, typename View
, typename ColorConverter
, typename FormatTag
>
inline
void read_and_convert_view( const String& file_name
, const View& view
, const point_t& top_left
, const ColorConverter& cc
, const FormatTag& tag
, typename enable_if< typename mpl::and_< typename is_format_tag< FormatTag >::type
, typename detail::is_supported_path_spec< String >::type
>::type
>::type* ptr = 0
)
{
detail::file_stream_device< FormatTag > device( detail::convert_to_string( file_name )
, detail::file_stream_device< FormatTag >::read_tag()
);
read_and_convert_view( device
, view
, top_left
, cc
, tag
);
}
/// \ingroup IO
template < typename String
, typename View
, typename ColorConverter
, typename FormatTag
>
inline
void read_and_convert_view( const String& file_name
, const View& view
, const ColorConverter& cc
, const FormatTag& tag
, typename enable_if< typename mpl::and_< typename is_format_tag< FormatTag >::type
, typename detail::is_supported_path_spec< String >::type
>::type
>::type* ptr = 0
)
{
read_and_convert_view( file_name
, view
, point_t( 0, 0 )
, cc
, tag
);
}
template < typename Device
, typename View
, typename ColorConverter
, typename FormatTag
>
inline
void read_and_convert_view( Device& device
, const View& view
, const ColorConverter& cc
, const FormatTag& tag
, typename enable_if< typename mpl::and_< typename mpl::or_< typename detail::is_input_device< Device >::type
, typename detail::is_adaptable_input_device< FormatTag
, Device
>::type
>::type
, typename is_format_tag< FormatTag >::type
>::type
>::type* ptr = 0
)
{
read_and_convert_view( device
, view
, point_t( 0, 0 )
, cc
, tag
);
}
/// \ingroup IO
template < typename String
, typename View
, typename FormatTag
>
inline
void read_and_convert_view( const String& file_name
, const View& view
, const point_t& top_left
, const FormatTag& tag
, typename enable_if< typename mpl::and_< typename is_format_tag< FormatTag >::type
, typename detail::is_supported_path_spec< String >::type
>::type
>::type* ptr = 0
)
{
read_and_convert_view( file_name
, view
, top_left
, default_color_converter()
, tag
);
}
template < typename Device
, typename View
, typename FormatTag
>
inline
void read_and_convert_view( Device& device
, const View& view
, const point_t& top_left
, const FormatTag& tag
, typename enable_if< typename mpl::and_< typename mpl::or_< typename detail::is_input_device< Device >::type
, typename detail::is_adaptable_input_device< FormatTag
, Device
>::type
>::type
, typename is_format_tag< FormatTag >::type
>::type
>::type* ptr = 0
)
{
read_and_convert_view( device
, view
, top_left
, default_color_converter()
, tag
);
}
/// \ingroup IO
template < typename String
, typename View
, typename FormatTag
>
inline
void read_and_convert_view( const String& file_name
, const View& view
, const FormatTag& tag
, typename enable_if< typename mpl::and_< typename is_format_tag< FormatTag >::type
, typename detail::is_supported_path_spec< String >::type
>::type
>::type* ptr = 0
)
{
read_and_convert_view( file_name
, view
, point_t( 0, 0 )
, default_color_converter()
, tag
);
}
template < typename Device
, typename View
, typename FormatTag
>
inline
void read_and_convert_view( Device& device
, const View& view
, const FormatTag& tag
, typename enable_if< typename mpl::and_< typename mpl::or_< typename detail::is_input_device< Device >::type
, typename detail::is_adaptable_input_device< FormatTag
, Device
>::type
>::type
, typename is_format_tag< FormatTag >::type
>::type
>::type* ptr = 0
)
{
read_and_convert_view( device
, view
, point_t( 0, 0 )
, default_color_converter()
, tag
);
}
} // namespace gil
} // namespace boost
#endif // BOOST_GIL_EXTENSION_IO_READ_AND_CONVERT_VIEW_HPP_INCLUDED | [
"fpelliccioni@71ea4c15-5055-0410-b3ce-cda77bae7b57"
]
| [
[
[
1,
289
]
]
]
|
b9ced5201121943716316aba1290b7e738e79222 | 60791ce953e9891f156b6862ad59ac4830a7cad2 | /CATL/display3D.cpp | e087db6aa1b635f866fc78e7c0112fdd9c470535 | []
| no_license | siavashmi/catl-code | 05283c6e24a1d3aa9652421a93f094c46c477014 | a668431b661c59f597c6f9408c371ec013bb9072 | refs/heads/master | 2021-01-10T03:17:38.898659 | 2011-06-30T10:27:35 | 2011-06-30T10:27:35 | 36,600,037 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 38,449 | cpp | #include "display3D.h"
#include <math.h>
#include <stdio.h>
#include <GL/glut.h>
#include "common.h"
#include "assert.h"
#include <ctype.h>
#include "sensor.h"
#include "field.h"
float xrange = 120;
float yrange = 200;
float zrange = 50;
float RotateAngle = 0.0f; // Angle in degrees of rotation around y-axis
float Azimuth = 0.0; // Rotated up or down by this amount
float scale = 15;
float scalestepsize = 0.3f;
float AngleStepSize = 3.0f; // Step three degrees at a time
const float AngleStepMax = 10.0f;
const float AngleStepMin = 0.1f;
// The next global variable controls the animation's state and speed.
float CurrentAngle = 0.0f; // Angle in degrees
float AnimateStep = 0.5f; // Rotation step per update
int WireFrameOn = 1; // == 1 for wire frame mode
int displayMode=0;
double xoffset=0;
double yoffset=0;
void myKeyboardFunc3D( unsigned char key, int x, int y )
{
switch ( key ) {
case 'y'://
WireFrameOn = 1-WireFrameOn;
if ( WireFrameOn ) {
glPolygonMode ( GL_FRONT_AND_BACK, GL_LINE ); // Just show wireframes
}
else {
glPolygonMode ( GL_FRONT_AND_BACK, GL_FILL ); // Show solid polygons
}// the glpolygonmode : wire solid and point ; front and back views,
glutPostRedisplay();// window redisplayed,
break;
case 'R':
AngleStepSize *= 1.5;
if (AngleStepSize>AngleStepMax ) {
AngleStepSize = AngleStepMax;// what is the use of these parameters,
}
break;
case 'r':
AngleStepSize /= 1.5;
if (AngleStepSize<AngleStepMin ) {
AngleStepSize = AngleStepMin;
}
break;
case 'c':
changeDisplayMode3D();
break;
case 27: // Escape key
exit(1);
case 'a':
xoffset+=20;
break;
case'd':
xoffset-=20;
break;
case 'w':
yoffset+=20;
break;
case 's':
yoffset-=20;
break;
}
}
void mySpecialKeyFunc3D( int key, int x, int y )
{
switch ( key ) {
case GLUT_KEY_UP:
Azimuth += AngleStepSize;
if ( Azimuth>180.0f ) {
Azimuth -= 360.0f;
}
break;
case GLUT_KEY_DOWN:
Azimuth -= AngleStepSize;
if ( Azimuth < -180.0f ) {
Azimuth += 360.0f;
}
break;
case GLUT_KEY_LEFT:
RotateAngle += AngleStepSize;
if ( RotateAngle > 180.0f ) {
RotateAngle -= 360.0f;
}
break;
case GLUT_KEY_RIGHT:
RotateAngle -= AngleStepSize;
if ( RotateAngle < -180.0f ) {
RotateAngle += 360.0f;
}
break;
case GLUT_KEY_PAGE_UP:
scale += scalestepsize;
if(scale > 50) {
scale = 50;
}
break;
case GLUT_KEY_PAGE_DOWN:
scale -= scalestepsize;
if(scale < 0) {
scale = 0;
}
break;
}
glutPostRedisplay();
}
void drawScene3D(void)
{
if(topologyIndex==0)
drawPointOf83D();
else
if(topologyIndex==1)
drawPointOfSmile3D();
else
if(topologyIndex==2)
drawPointOfTorus3D();
else if ( topologyIndex ==3)
drawPointOfHourglass();
else if (topologyIndex ==4)
drawPointOfcrossRing();
}
void initRendering3D()
{
glEnable( GL_DEPTH_TEST ); // Depth testing must be turned on
glClearColor(1,1,1,1);
glEnable( GL_NORMALIZE );
glEnable( GL_BLEND );
glPointSize(2);//change the size of the node sensors,
glPolygonMode ( GL_FRONT_AND_BACK, GL_LINE );
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
void resizeWindow3D(int w, int h)
{
float aspectRatio;
glViewport( 0, 0, w, h ); // View port uses whole window
h = (h == 0) ? 1 : h;
aspectRatio = (float)w/(float)h;
// Set up the projection view matrix
glMatrixMode( GL_PROJECTION );// this is projection,
glLoadIdentity();
gluPerspective( 60.0, aspectRatio, 1.0, 30.0 );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
// Move system 8 units away to be able to view from the origin.
glTranslatef(0.0, 0.0, -8.0);
// Tilt system 15 degrees downward in order to view from above
// the xy-plane.
glRotatef(15.0, 1.0,0.0,0.0);
}
void drawPointOf83D()
{
switch(displayMode)
{
case 0:
showOriginalOf8();
break;
case 1:
showLolizedOf8();
break;
case 2:
showTrasferedOf8();
break;
}
}
void changeDisplayMode3D(){
displayMode=(displayMode+1)%3;
}
void drawPointOfSmile3D()
{
if(displayMode==0)
{
showOriginalOfSmile();
}
if ( displayMode == 1)
{
showLolizedOfSmile();
}
if(displayMode==2)
{
showTrasferedOfSmile();
}
}
void showOriginalOf8()
{
glClear(GL_COLOR_BUFFER_BIT);
glClear(GL_DEPTH_BUFFER_BIT);
// Rotate the image
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
glTranslatef( 0, 0, -25);
glScalef(scale/X_RANGE,scale/Y_RANGE,scale/Z_RANGE);// scale,
glRotatef( RotateAngle, 0.0, 1.0, 0.0 ); // Rotate around y-axis
glRotatef( Azimuth, 1.0, 0.0, 0.0 ); // Set Azimuth angle
glPushMatrix();
glTranslatef( -xrange/2, -yrange/2, -zrange/2 );
glColor4f( 1.0, 0.2, 0.2, 0.3 ); // Reddish color the last one is about the transparency
glBegin( GL_QUAD_STRIP );//
glVertex3f( 0.0, 0.0, 0.0 );
glVertex3f( 0.0, 0.0, zrange );
glVertex3f( 0.0, yrange, 0.0 );
glVertex3f( 0.0, yrange, zrange );
glVertex3f( xrange, yrange, 0.0 );
glVertex3f( xrange, yrange, zrange );
glVertex3f( xrange, 0.0, 0.0 );
glVertex3f( xrange, 0.0, zrange );
glVertex3f( 0.0, 0.0, 0.0 );
glVertex3f( 0.0, 0.0, zrange );
glEnd();
glColor4f( 0.2, 1.0, 0.2, 0.3 ); // Greenish color
glBegin( GL_QUAD_STRIP );
glVertex3f( xrange/3, yrange/5, 0.0 );
glVertex3f( xrange/3, yrange/5, zrange );
glVertex3f( xrange/3, yrange/5*2, 0.0 );
glVertex3f( xrange/3, yrange/5*2, zrange );
glVertex3f( xrange/3*2, yrange/5*2, 0.0 );
glVertex3f( xrange/3*2, yrange/5*2, zrange );
glVertex3f( xrange/3*2, yrange/5, 0.0 );
glVertex3f( xrange/3*2, yrange/5, zrange );
glVertex3f( xrange/3, yrange/5, 0.0 );
glVertex3f( xrange/3, yrange/5, zrange );
glEnd();
glBegin( GL_QUAD_STRIP );
glVertex3f( xrange/3, yrange/5*3, 0.0 );
glVertex3f( xrange/3, yrange/5*3, zrange );
glVertex3f( xrange/3, yrange/5*4, 0.0 );
glVertex3f( xrange/3, yrange/5*4, zrange );
glVertex3f( xrange/3*2, yrange/5*4, 0.0 );
glVertex3f( xrange/3*2, yrange/5*4, zrange );
glVertex3f( xrange/3*2, yrange/5*3, 0.0 );
glVertex3f( xrange/3*2, yrange/5*3, zrange );
glVertex3f( xrange/3, yrange/5*3, 0.0 );
glVertex3f( xrange/3, yrange/5*3, zrange );
glEnd();
glPopMatrix();
glPushMatrix();
glColor3f( 1.0, 1.0, 1.0 );
glTranslatef( -xrange/2, -yrange/2, -zrange/2 );
for(int i = 0; i < globalField->nSensors; i++)
{
Sensor *s =globalField->sensorPool+i;
if(s->notchDegree>globalField->edgeLandmarks.size() *0.1)
{
glColor3f( 1.0, 0.0, 0.0 );
glPointSize(2);
glBegin( GL_POINTS );
glVertex3f(s->location.x+xoffset,s->location.y+yoffset,s->location.z);
glEnd();
}
else
{
glColor3f( 0.0,0.0, 0.0 );
glPointSize(2);
glBegin( GL_POINTS );
glVertex3f(s->location.x+xoffset,s->location.y+yoffset,s->location.z);
glEnd();
}
}
glPopMatrix();
glFlush();
glutSwapBuffers();
}
void showLolizedOf8()
{
glClear(GL_COLOR_BUFFER_BIT);
glClear(GL_DEPTH_BUFFER_BIT);
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
glTranslatef( 0, 0, -7);
glScalef(scale/X_RANGE,scale/Y_RANGE,scale/Z_RANGE);// scale,
glRotatef( RotateAngle, 0.0, 1.0, 0.0 ); // Rotate around y-axis
glRotatef( Azimuth, 1.0, 0.0, 0.0 );
glPushMatrix();
glColor3f( 1.0, 1.0, 1.0 );
glTranslatef( -xrange/10, -yrange/10, -zrange/10 );
for(int i =0;i<globalField->nSensors;i++){
Sensor *s=globalField->sensorPool+i;
if(s->localizedPosition!=INVALID_POINT)
{
s->displayPoint=s->localizedPosition;
if(s->notchDegree > globalField ->initLandmarks.size()*0.1){
glColor3f( 1.0, 0, 0 );
glPointSize(3);
glBegin( GL_POINTS );
glVertex3f(s->displayPoint.x+xoffset,s->displayPoint.y+yoffset,s->displayPoint.z);
glEnd();
}
else{
glColor3f( 0.0, 0, 0 );
glPointSize(2);
glBegin( GL_POINTS );
glVertex3f(s->displayPoint.x+xoffset,s->displayPoint.y+yoffset,s->displayPoint.z);
glEnd();
}
}
}
glPopMatrix();
glFlush();
glutSwapBuffers();
}
void showTrasferedOf8()
{
glClear(GL_COLOR_BUFFER_BIT);
glClear(GL_DEPTH_BUFFER_BIT);
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
glTranslatef( 0, 0, -25);
glScalef(scale/X_RANGE,scale/Y_RANGE,scale/Z_RANGE);// scale,
glRotatef( RotateAngle, 0.0, 1.0, 0.0 ); // Rotate around y-axis
glRotatef( Azimuth, 1.0, 0.0, 0.0 ); // Set Azimuth angle
glPushMatrix();
glTranslatef( -xrange/2, -yrange/2, -zrange/2 );
glColor4f( 1.0, 0.2, 0.2, 0.3 ); // Reddish color the last one is about the transparency
glBegin( GL_QUAD_STRIP );//
glVertex3f( 0.0, 0.0, 0.0 );
glVertex3f( 0.0, 0.0, zrange );
glVertex3f( 0.0, yrange, 0.0 );
glVertex3f( 0.0, yrange, zrange );
glVertex3f( xrange, yrange, 0.0 );
glVertex3f( xrange, yrange, zrange );
glVertex3f( xrange, 0.0, 0.0 );
glVertex3f( xrange, 0.0, zrange );
glVertex3f( 0.0, 0.0, 0.0 );
glVertex3f( 0.0, 0.0, zrange );
glEnd();
glColor4f( 0.2, 1.0, 0.2, 0.3 ); // Greenish color
glBegin( GL_QUAD_STRIP );
glVertex3f( xrange/3, yrange/5, 0.0 );
glVertex3f( xrange/3, yrange/5, zrange );
glVertex3f( xrange/3, yrange/5*2, 0.0 );
glVertex3f( xrange/3, yrange/5*2, zrange );
glVertex3f( xrange/3*2, yrange/5*2, 0.0 );
glVertex3f( xrange/3*2, yrange/5*2, zrange );
glVertex3f( xrange/3*2, yrange/5, 0.0 );
glVertex3f( xrange/3*2, yrange/5, zrange );
glVertex3f( xrange/3, yrange/5, 0.0 );
glVertex3f( xrange/3, yrange/5, zrange );
glEnd();
glBegin( GL_QUAD_STRIP );
glVertex3f( xrange/3, yrange/5*3, 0.0 );
glVertex3f( xrange/3, yrange/5*3, zrange );
glVertex3f( xrange/3, yrange/5*4, 0.0 );
glVertex3f( xrange/3, yrange/5*4, zrange );
glVertex3f( xrange/3*2, yrange/5*4, 0.0 );
glVertex3f( xrange/3*2, yrange/5*4, zrange );
glVertex3f( xrange/3*2, yrange/5*3, 0.0 );
glVertex3f( xrange/3*2, yrange/5*3, zrange );
glVertex3f( xrange/3, yrange/5*3, 0.0 );
glVertex3f( xrange/3, yrange/5*3, zrange );
glEnd();
glPopMatrix();
glPushMatrix();
glColor3f( 1.0, 1.0, 1.0 );
glTranslatef( -xrange/2, -yrange/2, -zrange/2 );
for(int i =0;i<globalField->nSensors;i++){
Sensor *s=globalField->sensorPool+i;
if(s->localizedPosition!=INVALID_POINT)
{
if(s->notchDegree > globalField->initLandmarks.size()*0.1){
glColor3f( 1.0, 0, 0 );
glPointSize(3);
glBegin( GL_POINTS );
glVertex3f(s->finalLocalization.x+xoffset,s->finalLocalization.y+yoffset,s->finalLocalization.z);
glEnd();
}
else{
glColor3f( 0.0, 0, 0 );
glPointSize(2);
glBegin( GL_POINTS );
glVertex3f(s->finalLocalization.x+xoffset,s->finalLocalization.y+yoffset,s->finalLocalization.z);
glEnd();
}
}
}
glPopMatrix();
glFlush();
glutSwapBuffers();
}
void showOriginalOfSmile()
{
GLUquadricObj* myReusableQuadric = NULL;
xrange = 100;
xrange = 100;
yrange = 100;
zrange = 100;
float radius = xrange/2;
float H = 1.8;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if ( ! myReusableQuadric ) {
myReusableQuadric = gluNewQuadric();
gluQuadricNormals( myReusableQuadric, GL_TRUE );
}
glMatrixMode( GL_MODELVIEW ); // Current matrix affects objects positions
glLoadIdentity(); // Initialize to the identity
glTranslatef( 0.0, 0.0, -20.0 ); // Translate from origin (in front of viewer)
glScalef(scale/xrange,scale/yrange,scale/zrange);
glRotatef( RotateAngle, 0.0, 1.0, 0.0 ); // Rotate around y-axis
glRotatef( Azimuth, 1.0, 0.0, 0.0 ); // Set Azimuth angle
for(int i =0;i<globalField->nSensors;i++)
{
Sensor *s=globalField->sensorPool+i;
if(s->notchDegree> globalField->edgeLandmarks.size()*0.1)
{
glPointSize(2);
glColor3f(1,0,0);
glBegin( GL_POINTS );
glVertex3f(s->location.x-X_RANGE/2, s->location.y-Y_RANGE/2, s->location.z-Z_RANGE/2);
glEnd();
}
else{
glPointSize(2);
glColor3f(0,0,0);
glBegin( GL_POINTS );
glVertex3f(s->location.x-X_RANGE/2, s->location.y-Y_RANGE/2, s->location.z-Z_RANGE/2);
glEnd();
}
}
//Draw the face
glPushMatrix();
glColor4f( 0.2, 0.2, 1, 0.5 );
glTranslatef( -radius/3, radius/3, -radius*H/2 );
gluCylinder(myReusableQuadric, radius/5, radius/5, radius*H, 20, 20);
glPopMatrix();
glPushMatrix();
glTranslatef( radius/3, radius/3, -radius*H/2 );
gluCylinder(myReusableQuadric, radius/5, radius/5, radius*H, 20, 20);
glPopMatrix();
//Draw glasses
glPushMatrix();
glColor4f( 0.2, 0.2, 1,0.5);
glTranslatef(radius/3, radius/3, radius*H/2);
gluDisk( myReusableQuadric, 0.0, radius/5, 20, 20 );
glPopMatrix();
glPushMatrix();
glTranslatef(radius/3, radius/3, -radius*H/2);
gluDisk( myReusableQuadric, 0.0, radius/5, 20, 20 );
glPopMatrix();
glPushMatrix();
glTranslatef(-radius/3, radius/3, radius*H/2);
gluDisk( myReusableQuadric, 0.0, radius/5, 20, 20 );
glPopMatrix();
glPushMatrix();
glTranslatef(-radius/3, radius/3, -radius*H/2);
gluDisk( myReusableQuadric, 0.0, radius/5, 20, 20 );
glPopMatrix();
//Draw mouth
glPushMatrix();
glColor4f( 0.2, 1.0, 0.2, 0.5 );
glTranslatef(-xrange/3/2, -yrange/6/2-radius/3, -zrange*0.9/2);
glBegin( GL_QUAD_STRIP );
glVertex3f( 0.0, 0.0, 0.0 );
glVertex3f( xrange/3, 0.0, 0.0 );
glVertex3f( 0.0, yrange/6, 0.0 );
glVertex3f( xrange/3, yrange/6, 0.0 );
glVertex3f( 0.0, yrange/6, zrange*0.9 );
glVertex3f( xrange/3, yrange/6, zrange*0.9 );
glVertex3f( 0.0, 0.0, zrange*0.9 );
glVertex3f( xrange/3, 0.0, zrange*0.9 );
glVertex3f( 0.0, 0.0, 0.0 );
glVertex3f( xrange/3, 0.0, 0.0 );
glEnd();
glPopMatrix();
// Flush the pipeline, swap the buffers
glFlush();
glutSwapBuffers();
}
void showLolizedOfSmile()
{
GLUquadricObj* myReusableQuadric = NULL;
xrange = 100;
xrange = 100;
yrange = 100;
zrange = 100;
float radius = xrange/2;
float H = 1.8;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if ( ! myReusableQuadric ) {
myReusableQuadric = gluNewQuadric();
gluQuadricNormals( myReusableQuadric, GL_TRUE );
}
// Rotate the image
glMatrixMode( GL_MODELVIEW ); // Current matrix affects objects positions
glLoadIdentity(); // Initialize to the identity
glTranslatef( 0.0, 0.0, -15 ); // Translate from origin (in front of viewer)
glScalef(scale/xrange,scale/yrange,scale/zrange);
glRotatef( RotateAngle, 0.0, 1.0, 0.0 ); // Rotate around y-axis
glRotatef( Azimuth, 1.0, 0.0, 0.0 ); // Set Azimuth angle
//Draw face
glPushMatrix();
glColor3f( 1.0, 1.0, 1.0 );
for(int i =0;i<globalField->nSensors;i++)
{
Sensor *s=globalField->sensorPool+i;
s->displayPoint=s->localizedPosition;
if(s->notchDegree> globalField->edgeLandmarks.size()*0.1)
{
glPointSize(2);
glColor3f(1,0,0);
glBegin( GL_POINTS );
glVertex3f(s->displayPoint.x, s->displayPoint.y, s->displayPoint.z);
glEnd();
}
else{
glPointSize(2);
glColor3f(0,0,0);
glBegin( GL_POINTS );
glVertex3f(s->displayPoint.x, s->displayPoint.y, s->displayPoint.z);
glEnd();
}
}
glPopMatrix();
glFlush();
glutSwapBuffers();
}
void showTrasferedOfSmile()
{
xrange = 100;
xrange = 100;
yrange = 100;
zrange = 100;
float radius = xrange/2;
float H = 1.8;
GLUquadricObj* myReusableQuadric = NULL;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if ( ! myReusableQuadric ) {
myReusableQuadric = gluNewQuadric();
gluQuadricNormals( myReusableQuadric, GL_TRUE );
}
// Rotate the image
glMatrixMode( GL_MODELVIEW ); // Current matrix affects objects positions
glLoadIdentity(); // Initialize to the identity
glTranslatef( 0.0, 0.0, -20.0 ); // Translate from origin (in front of viewer)
glScalef(scale/xrange,scale/yrange,scale/zrange);
glRotatef( RotateAngle, 0.0, 1.0, 0.0 ); // Rotate around y-axis
glRotatef( Azimuth, 1.0, 0.0, 0.0 ); // Set Azimuth angle
//Draw face
glPushMatrix();
glPopMatrix();
glPushMatrix();
glBegin( GL_POINTS );
for(int i = 0; i < globalField->nSensors; i++)
{
glColor3f( 1.0, 0.0, 0.0 );
Sensor *s=globalField->sensorPool+i;
if ( s->notchDegree > globalField->initLandmarks.size()*0.1)
glVertex3f(s->finalLocalization.x-X_RANGE/2, s->finalLocalization.y-Y_RANGE/2, s->finalLocalization.z-Z_RANGE/2);
}
glEnd();
glBegin(GL_POINTS);
for (int i =0; i< globalField ->nSensors; i++) {
glColor3f( 0.0, 0.0, 0.0 );
Sensor *s=globalField->sensorPool+i;
glVertex3f(s->finalLocalization.x-X_RANGE/2, s->finalLocalization.y-Y_RANGE/2, s->finalLocalization.z-Z_RANGE/2);
}
glEnd();
glPopMatrix();
// Flush the pipeline, swap the buffers
glFlush();
glutSwapBuffers();
}
void drawPointOfTorus3D()
{
if(displayMode==0)
showOriginalOfTorus();
if (displayMode==1)
showLocalizedOfTorus();
if(displayMode==2)
showTrasferedOfTorus();
}
void drawPointOfHourglass()
{
if(displayMode==0)
showOriginalOfHourglass();
if (displayMode==1)
showlocalizedOfHourglass();
if(displayMode==2)
showTrasferedOfHourglass();
}
void putVert3D(int i, int j) {
float MajorRadius = 70;
float MinorRadius = 30;
int NumWraps = 40;
int NumPerWrap = 32;
float wrapFrac = (j%NumPerWrap)/(float)NumPerWrap;
float phi = PI*2*wrapFrac;
float theta = PI*2*(i%NumWraps+wrapFrac)/(float)NumWraps;
float sinphi = sin(phi);
float cosphi = cos(phi);
float sintheta = sin(theta);
float costheta = cos(theta);
float y = MinorRadius*sinphi;
float r = MajorRadius + MinorRadius*cosphi;
float x = sintheta*r;
float z = costheta*r;
glNormal3f(sintheta*cosphi, sinphi, costheta*cosphi);
glVertex3f(x,y,z);
}
void putVert3D1(int i, int j)
{
float MajorRadius = 70;
float MinorRadius = 30;
int NumWraps = 40;
int NumPerWrap = 32;
float wrapFrac = (j%NumPerWrap)/(float)NumPerWrap;
float phi = PI*2*wrapFrac;
float theta = PI*2*(i%NumWraps+wrapFrac)/(float)NumWraps;
float sinphi = sin(phi);
float cosphi = cos(phi);
float sintheta = sin(theta);
float costheta = cos(theta);
float y = MinorRadius*sinphi;
float r = MajorRadius + MinorRadius*cosphi;
float x = sintheta*r;
float z = costheta*r;
glNormal3f(sintheta*cosphi, sinphi, costheta*cosphi);
glVertex3f(x,z,y);
}
void showOriginalOfTorus()
{
int i,j;
GLenum shadeModel = GL_SMOOTH;
GLenum polygonMode = GL_LINE;
GLenum LocalMode = GL_TRUE;
float scale = 8.0f;
float Noemit[4] = {0.0, 0.0, 0.0, 1.0};
float Matspec[4] = {1.0, 1.0, 1.0, 1.0};
float Matnonspec[4] = {0.8, 1.0, 1.0, 1.0};
float Matshiny = 16.0;
float RotX = 90.0f; // Rotational position around x-axis
float RotY = 0.0f;
int QuadMode = 1;
int NumWraps = 40;
int NumPerWrap = 32;
float MajorRadius = 70;
float MinorRadius = 30;
float PNoemit[4] = {0.0, 0.0, 0.0, 1.0};
float PMatspec[4] = {1.0, 1.0, 1.0, 1.0};
float PMatnonspec[4] = {1.0, 0.0, 0.0, 1.0};
float PMatshiny = 10.0;
// Clear the rendering window
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glShadeModel( shadeModel ); // Set the shading to flat or smooth.
glPolygonMode(GL_FRONT_AND_BACK, polygonMode); // Set to be "wire" or "solid"
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, LocalMode);
// Torus Materials
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, Matnonspec);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, Matspec);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, Matshiny);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, Noemit);
glMatrixMode( GL_MODELVIEW ); // Current matrix affects objects positions
glLoadIdentity();
glTranslatef(0,0,-10);
glRotatef( RotateAngle, 0.0, 1.0, 0.0 );
glRotatef( Azimuth, 1.0, 0.0, 0.0 );
glPushMatrix(); // Save to use again next time.
glRotatef( RotX, 1.0, 0.0, 0.0);
glRotatef( RotY, 0.0, 1.0, 0.0);
// Draw the torus
glScalef( scale/X_RANGE, scale/Y_RANGE, scale/Z_RANGE );
glColor4f( 0.5, 1.0, 0.5, 1.0 );
glBegin( QuadMode==1 ? GL_QUAD_STRIP : GL_TRIANGLE_STRIP );
for (i=0; i<NumWraps; i++ ) {
for (j=0; j<NumPerWrap; j++) {
putVert3D(i,j);
putVert3D(i+1,j);
}
}
putVert3D(0,0);
putVert3D(1,0);
glEnd();
// Draw the reference pyramid
glTranslatef( -MajorRadius-MinorRadius-MajorRadius/10.0, 0.0, 0.0);
glScalef( scale/4, scale/4, scale/4 );
glColor4f( 1.0f, 1.0f, 0.0f, 1.0f );
glBegin(GL_TRIANGLE_STRIP);
glVertex3f( -0.5, 0.0, sqrt(3.0)*0.5 );
glVertex3f( -0.5, 0.0, -sqrt(3.0)*0.5 );
glVertex3f( 1.0, 0.0, 0.0);
glVertex3f( 0.0, sqrt(2.0), 0.0);
glVertex3f( -0.5, 0.0, sqrt(3.0)*0.5 );
glVertex3f( -0.5, 0.0, -sqrt(3.0)*0.5 );
glEnd();
glPopMatrix(); // Restore to original matrix as set in resizeWindow()
//Points material
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, PMatnonspec);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, PMatspec);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, PMatshiny);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, PNoemit);
glRotatef( RotX, 1.0, 0.0, 0.0);
glRotatef( RotY, 0.0, 1.0, 0.0);
glColor4f( 0.0, 0.0, 0.0, 1.0 );
glScalef( scale/X_RANGE, scale/Y_RANGE, scale/Z_RANGE );
for(int i =0;i<globalField->nSensors;i++)
{
Sensor *s=globalField->sensorPool+i;
if(s->notchDegree> globalField->edgeLandmarks.size()*0.1)
{
glPointSize(2);
glColor3f(1,0,0);
glBegin(GL_POINTS);
glVertex3f(s->location.x,s->location.y,s->location.z);
glEnd();
}
else
{
glPointSize(2);
glColor3f(0,0,0);
glBegin(GL_POINTS);
glVertex3f(s->location.x,s->location.y,s->location.z);
glEnd();
}
}
// Flush the pipeline, swap the buffers
glFlush();
glutSwapBuffers();
}
void showLocalizedOfTorus()
{
int i,j;
GLenum shadeModel = GL_SMOOTH;
GLenum polygonMode = GL_LINE;
GLenum LocalMode = GL_TRUE;
float scale1 = 8.0f;
float Noemit[4] = {0.0, 0.0, 0.0, 1.0};
float Matspec[4] = {1.0, 1.0, 1.0, 1.0};
float Matnonspec[4] = {0.8, 1.0, 1.0, 1.0};
float Matshiny = 16.0;
float RotX = 90.0f; // Rotational position around x-axis
float RotY = 0.0f;
int QuadMode = 1;
int NumWraps = 40;
int NumPerWrap = 32;
float MajorRadius = 70;
float MinorRadius = 30;
float PNoemit[4] = {0.0, 0.0, 0.0, 1.0};
float PMatspec[4] = {1.0, 1.0, 1.0, 1.0};
float PMatnonspec[4] = {1.0, 0.0, 0.0, 1.0};
float PMatshiny = 10.0;
// Clear the redering window
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode( GL_MODELVIEW ); // Current matrix affects objects positions
glLoadIdentity();
glTranslatef(0,0,-10); /*// scale,*/
glScalef(scale/X_RANGE,scale/Y_RANGE,scale/Z_RANGE);
glRotatef( RotateAngle, 0.0, 1.0, 0.0 );
glRotatef( Azimuth, 1.0, 0.0, 0.0 );
glPushMatrix(); // Save to use again next time.
glRotatef( RotX, 1.0, 0.0, 0.0);
glRotatef( RotY, 0.0, 1.0, 0.0);
// Draw the torus
glScalef( scale1/X_RANGE, scale1/Y_RANGE, scale1/Z_RANGE );
glColor4f( 0.5, 1.0, 0.5, 1.0 );
glPopMatrix(); // Restore to original matrix as set in resizeWindow()
// Set the orientation.
glRotatef( RotX, 1.0, 0.0, 0.0);
glRotatef( RotY, 0.0, 1.0, 0.0);
glColor4f( 0.0, 0.0, 0.0, 1.0 );
for(int i =0;i<globalField->nSensors;i++)
{
Sensor *s=globalField->sensorPool+i;
if(s->notchDegree> globalField->initLandmarks.size()*0.1)
{
glPointSize(2);
glColor3f(1,0,0);
glBegin(GL_POINTS);
glVertex3f(s->localizedPosition.x+xoffset,s->localizedPosition.y+yoffset,s->localizedPosition.z);
glEnd();
}
else
{
glPointSize(2);
glColor3f(0,0,0);
glBegin(GL_POINTS);
glVertex3f(s->localizedPosition.x+xoffset,s->localizedPosition.y+yoffset,s->localizedPosition.z);
glEnd();
}
}
// Flush the pipeline, swap the buffers
glFlush();
glutSwapBuffers();
}
void showTrasferedOfTorus()
{
int i,j;
GLenum shadeModel = GL_SMOOTH;
GLenum polygonMode = GL_LINE;
GLenum LocalMode = GL_TRUE;
float scale = 8.0f;
float Noemit[4] = {0.0, 0.0, 0.0, 1.0};
float Matspec[4] = {1.0, 1.0, 1.0, 1.0};
float Matnonspec[4] = {0.8, 1.0, 1.0, 1.0};
float Matshiny = 16.0;
float RotX = 90.0f; // Rotational position around x-axis
float RotY = 0.0f;
int QuadMode = 1;
int NumWraps = 40;
int NumPerWrap = 32;
float MajorRadius = 70;
float MinorRadius = 30;
float PNoemit[4] = {0.0, 0.0, 0.0, 1.0};
float PMatspec[4] = {1.0, 1.0, 1.0, 1.0};
float PMatnonspec[4] = {1.0, 0.0, 0.0, 1.0};
float PMatshiny = 10.0;
// Clear the redering window
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glShadeModel( shadeModel ); // Set the shading to flat or smooth.
glPolygonMode(GL_FRONT_AND_BACK, polygonMode); // Set to be "wire" or "solid"
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, LocalMode);
// Torus Materials
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, Matnonspec);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, Matspec);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, Matshiny);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, Noemit);
glMatrixMode( GL_MODELVIEW ); // Current matrix affects objects positions
glLoadIdentity();
glTranslatef(0,0,-10);
glRotatef( RotateAngle, 0.0, 1.0, 0.0 );
glRotatef( Azimuth, 1.0, 0.0, 0.0 );
glPushMatrix(); // Save to use again next time.
glRotatef( RotX, 1.0, 0.0, 0.0);
glRotatef( RotY, 0.0, 1.0, 0.0);
// Draw the torus
glScalef( scale/X_RANGE, scale/Y_RANGE, scale/Z_RANGE );
glColor4f( 0.5, 1.0, 0.5, 1.0 );
// Draw the reference pyramid
glTranslatef( -MajorRadius-MinorRadius-MajorRadius/10.0, 0.0, 0.0);
glScalef( scale/4, scale/4, scale/4 );
glColor4f( 1.0f, 1.0f, 0.0f, 1.0f );
glBegin(GL_TRIANGLE_STRIP);
glVertex3f( -0.5, 0.0, sqrt(3.0)*0.5 );
glVertex3f( -0.5, 0.0, -sqrt(3.0)*0.5 );
glVertex3f( 1.0, 0.0, 0.0);
glVertex3f( 0.0, sqrt(2.0), 0.0);
glVertex3f( -0.5, 0.0, sqrt(3.0)*0.5 );
glVertex3f( -0.5, 0.0, -sqrt(3.0)*0.5 );
glEnd();
glPopMatrix(); // Restore to original matrix as set in resizeWindow()
//Points material
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, PMatnonspec);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, PMatspec);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, PMatshiny);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, PNoemit);
glRotatef( RotX, 1.0, 0.0, 0.0);
glRotatef( RotY, 0.0, 1.0, 0.0);
glColor4f( 0.0, 0.0, 0.0, 1.0 );
glScalef( scale/X_RANGE, scale/Y_RANGE, scale/Z_RANGE );
for(int i =0;i<globalField->nSensors;i++)
{
Sensor *s=globalField->sensorPool+i;
if(s->notchDegree>globalField->initLandmarks.size()*0.1)
{
glPointSize(2);
glColor3f(1,0,0);
glBegin(GL_POINTS);
glVertex3f(s->finalLocalization.x,s->finalLocalization.y,s->finalLocalization.z);
glEnd();
}
else
{
glPointSize(2);
glColor3f(0,0,0);
glBegin(GL_POINTS);
glVertex3f(s->finalLocalization.x,s->finalLocalization.y,s->finalLocalization.z);
glEnd();
}
}
// Flush the pipeline, swap the buffers
glFlush();
glutSwapBuffers();
}
void showOriginalOfHourglass()
{
glClear(GL_COLOR_BUFFER_BIT);
glClear(GL_DEPTH_BUFFER_BIT);
// Rotate the image
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
glTranslatef( 0, 0, -25);
glScalef(scale/X_RANGE,scale/Y_RANGE,scale/Z_RANGE);// scale,
glRotatef( RotateAngle, 0.0, 1.0, 0.0 ); // Rotate around y-axis
glRotatef( Azimuth, 1.0, 0.0, 0.0 ); // Set Azimuth angle
glPushMatrix();
glColor3f( 1.0, 1.0, 1.0 );
glTranslatef( -xrange/2, -yrange/2, -zrange/2 );
for(int i = 0; i < globalField->nSensors; i++)
{
Sensor *s =globalField->sensorPool+i;
if(s->notchDegree>globalField->edgeLandmarks.size() *0.1)
{
glColor3f( 1.0, 0.0, 0.0 );
glPointSize(2);
glBegin( GL_POINTS );
glVertex3f(s->location.x+xoffset,s->location.y+yoffset,s->location.z);
glEnd();
}
else
{
glColor3f( 0.0,0.0, 0.0 );
glPointSize(2);
glBegin( GL_POINTS );
glVertex3f(s->location.x+xoffset,s->location.y+yoffset,s->location.z);
glEnd();
}
}
glPopMatrix();
glPushMatrix();
GLUquadricObj *obj=gluNewQuadric();
glRotatef(90,1,0,0);
glColor4f(0,0,1,0.5);
glTranslatef(-60,-26,0);
gluCylinder(obj,80,30,50,20,9);
glPopMatrix();
glPushMatrix();
GLUquadricObj *obj1=gluNewQuadric();
glRotatef(-90,1,0,0);
glColor4f(0,0,1,0.5);
glTranslatef(-60,26,-100);
gluCylinder(obj1,80,30,50,20,9);
glPopMatrix();
glFlush();
glutSwapBuffers();
}
void showlocalizedOfHourglass()
{
glClear(GL_COLOR_BUFFER_BIT);
glClear(GL_DEPTH_BUFFER_BIT);
// Rotate the image
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
glTranslatef( 0, 0, -15);
glScalef(scale/X_RANGE,scale/Y_RANGE,scale/Z_RANGE);// scale,
glRotatef( RotateAngle, 0.0, 1.0, 0.0 ); // Rotate around y-axis
glRotatef( Azimuth, 1.0, 0.0, 0.0 ); // Set Azimuth angle
glPushMatrix();
glColor3f( 1.0, 1.0, 1.0 );
glTranslatef( -xrange/2, -yrange/2, -zrange/2 );
for(int i = 0; i < globalField->nSensors; i++)
{
Sensor *s =globalField->sensorPool+i;
if(s->notchDegree>globalField->edgeLandmarks.size() *0.1)
{
glColor3f( 1.0, 0.0, 0.0 );
glPointSize(2);
glBegin( GL_POINTS );
glVertex3f(s->localizedPosition.x+xoffset,s->localizedPosition.y+yoffset,s->localizedPosition.z);
glEnd();
}
else
{
glColor3f( 0.0,0.0, 0.0 );
glPointSize(2);
glBegin( GL_POINTS );
glVertex3f(s->localizedPosition.x+xoffset,s->localizedPosition.y+yoffset,s->localizedPosition.z);
glEnd();
}
}
glPopMatrix();
glFlush();
glutSwapBuffers();
}
void showTrasferedOfHourglass()
{
glClear(GL_COLOR_BUFFER_BIT);
glClear(GL_DEPTH_BUFFER_BIT);
// Rotate the image
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
glTranslatef( 0, 0, -25);
glScalef(scale/X_RANGE,scale/Y_RANGE,scale/Z_RANGE);// scale,
glRotatef( RotateAngle, 0.0, 1.0, 0.0 ); // Rotate around y-axis
glRotatef( Azimuth, 1.0, 0.0, 0.0 ); // Set Azimuth angle
glPushMatrix();
glColor3f( 1.0, 1.0, 1.0 );
glTranslatef( -xrange/2, -yrange/2, -zrange/2 );
for(int i = 0; i < globalField->nSensors; i++)
{
Sensor *s =globalField->sensorPool+i;
if(s->notchDegree>globalField->edgeLandmarks.size() *0.1)
{
glColor3f( 1.0, 0.0, 0.0 );
glPointSize(2);
glBegin( GL_POINTS );
glVertex3f(s->finalLocalization.x+xoffset,s->finalLocalization.y+yoffset,s->finalLocalization.z);
glEnd();
}
else
{
glColor3f( 0.0,0.0, 0.0 );
glPointSize(2);
glBegin( GL_POINTS );
glVertex3f(s->finalLocalization.x+xoffset,s->finalLocalization.y+yoffset,s->finalLocalization.z);
glEnd();
}
}
glPopMatrix();
glFlush();
glutSwapBuffers();
}
void drawPointOfcrossRing()
{
{
if(displayMode==0)
showOriginalOfcrossRing();
if (displayMode==1)
showlocalizedOfcrossRing();
if(displayMode==2)
showTrasferedOfcrossRing();
}
}
void showOriginalOfcrossRing()
{
GLenum shadeModel = GL_SMOOTH;
GLenum polygonMode = GL_LINE;
GLenum LocalMode = GL_TRUE;
float scale1 = 4.0f;;
float Noemit[4] = {0.0, 0.0, 0.0, 1.0};
float Matspec[4] = {1.0, 1.0, 1.0, 1.0};
float Matnonspec[4] = {0.8, 1.0, 1.0, 1.0};
float Matshiny = 16.0;
float RotX = 90.0f; // Rotational position around x-axis
float RotY = 0.0f;
int QuadMode = 1;
int NumWraps = 40;
int NumPerWrap = 32;
float MajorRadius = 70;
float MinorRadius = 30;
float PNoemit[4] = {0.0, 0.0, 0.0, 1.0};
float PMatspec[4] = {1.0, 1.0, 1.0, 1.0};
float PMatnonspec[4] = {1.0, 0.0, 0.0, 1.0};
float PMatshiny = 10.0;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glShadeModel( shadeModel ); // Set the shading to flat or smooth.
glPolygonMode(GL_FRONT_AND_BACK, polygonMode); // Set to be "wire" or "solid"
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, LocalMode);
// Torus Materials
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, Matnonspec);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, Matspec);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, Matshiny);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, Noemit);
glMatrixMode( GL_MODELVIEW ); // Current matrix affects objects positions
glLoadIdentity();
glTranslatef(0,0,-10);
glRotatef( RotateAngle, 0.0, 1.0, 0.0 );
glRotatef( Azimuth, 1.0, 0.0, 0.0 );
glRotatef( RotX, 1.0, 0.0, 0.0);
glRotatef( RotY, 0.0, 1.0, 0.0);
glColor4f( 0.0, 0.0, 0.0, 1.0 );
glScalef( scale/X_RANGE, scale/Y_RANGE, scale/Z_RANGE );
glColor4f( 0.5, 1.0, 0.5, 1.0);
int i,j;
glBegin( QuadMode==1 ? GL_QUAD_STRIP : GL_TRIANGLE_STRIP );
for (i=0; i<NumWraps; i++ ) {
for (j=0; j<NumPerWrap; j++) {
putVert3D(i,j);
putVert3D(i+1,j);
}
}
putVert3D(0,0);
putVert3D(1,0);
glEnd();
glBegin( QuadMode==1 ? GL_QUAD_STRIP : GL_TRIANGLE_STRIP );
for (i=0; i<NumWraps; i++ ) {
for (j=0; j<NumPerWrap; j++) {
putVert3D1(i,j);
putVert3D1(i+1,j);
}
}
putVert3D1(0,0);
putVert3D1(1,0);
glEnd();
for(int i =0;i<globalField->nSensors;i++)
{
Sensor *s=globalField->sensorPool+i;
if(s->notchDegree> globalField->edgeLandmarks.size()*0.1)
{
glPointSize(2);
glColor3f(1,0,0);
glBegin(GL_POINTS);
glVertex3f(s->location.x,s->location.y,s->location.z);
glEnd();
}
else
{
glPointSize(2);
glColor3f(0,0,0);
glBegin(GL_POINTS);
glVertex3f(s->location.x,s->location.y,s->location.z);
glEnd();
}
}
glFlush();
glutSwapBuffers();
}
void showlocalizedOfcrossRing()
{
GLenum shadeModel = GL_SMOOTH;
GLenum polygonMode = GL_LINE;
GLenum LocalMode = GL_TRUE;
float scale1 = 4.0f;;
float Noemit[4] = {0.0, 0.0, 0.0, 1.0};
float Matspec[4] = {1.0, 1.0, 1.0, 1.0};
float Matnonspec[4] = {0.8, 1.0, 1.0, 1.0};
float Matshiny = 16.0;
float RotX = 90.0f; // Rotational position around x-axis
float RotY = 0.0f;
int QuadMode = 1;
int NumWraps = 40;
int NumPerWrap = 32;
float MajorRadius = 70;
float MinorRadius = 30;
float PNoemit[4] = {0.0, 0.0, 0.0, 1.0};
float PMatspec[4] = {1.0, 1.0, 1.0, 1.0};
float PMatnonspec[4] = {1.0, 0.0, 0.0, 1.0};
float PMatshiny = 10.0;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glShadeModel( shadeModel ); // Set the shading to flat or smooth.
glPolygonMode(GL_FRONT_AND_BACK, polygonMode); // Set to be "wire" or "solid"
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, LocalMode);
// Torus Materials
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, Matnonspec);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, Matspec);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, Matshiny);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, Noemit);
glMatrixMode( GL_MODELVIEW ); // Current matrix affects objects positions
glLoadIdentity();
glTranslatef(0,0,-10);
glRotatef( RotateAngle, 0.0, 1.0, 0.0 );
glRotatef( Azimuth, 1.0, 0.0, 0.0 );
glRotatef( RotX, 1.0, 0.0, 0.0);
glRotatef( RotY, 0.0, 1.0, 0.0);
glColor4f( 0.0, 0.0, 0.0, 1.0 );
glScalef( scale/X_RANGE, scale/Y_RANGE, scale/Z_RANGE );
for(int i =0;i<globalField->nSensors;i++)
{
Sensor *s=globalField->sensorPool+i;
if(s->notchDegree> globalField->edgeLandmarks.size()*0.1)
{
glPointSize(2);
glColor3f(1,0,0);
glBegin(GL_POINTS);
glVertex3f(s->localizedPosition.x,s->localizedPosition.y,s->localizedPosition.z);
glEnd();
}
else
{
glPointSize(2);
glColor3f(0,0,0);
glBegin(GL_POINTS);
glVertex3f(s->localizedPosition.x,s->localizedPosition.y,s->localizedPosition.z);
glEnd();
}
}
glFlush();
glutSwapBuffers();
}
void showTrasferedOfcrossRing()
{
GLenum shadeModel = GL_SMOOTH;
GLenum polygonMode = GL_LINE;
GLenum LocalMode = GL_TRUE;
float scale1 = 4.0f;;
float Noemit[4] = {0.0, 0.0, 0.0, 1.0};
float Matspec[4] = {1.0, 1.0, 1.0, 1.0};
float Matnonspec[4] = {0.8, 1.0, 1.0, 1.0};
float Matshiny = 16.0;
float RotX = 90.0f; // Rotational position around x-axis
float RotY = 0.0f;
int QuadMode = 1;
int NumWraps = 40;
int NumPerWrap = 32;
float MajorRadius = 70;
float MinorRadius = 30;
float PNoemit[4] = {0.0, 0.0, 0.0, 1.0};
float PMatspec[4] = {1.0, 1.0, 1.0, 1.0};
float PMatnonspec[4] = {1.0, 0.0, 0.0, 1.0};
float PMatshiny = 10.0;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glShadeModel( shadeModel ); // Set the shading to flat or smooth.
glPolygonMode(GL_FRONT_AND_BACK, polygonMode); // Set to be "wire" or "solid"
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, LocalMode);
// Torus Materials
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, Matnonspec);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, Matspec);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, Matshiny);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, Noemit);
glMatrixMode( GL_MODELVIEW ); // Current matrix affects objects positions
glLoadIdentity();
glTranslatef(0,0,-10);
glRotatef( RotateAngle, 0.0, 1.0, 0.0 );
glRotatef( Azimuth, 1.0, 0.0, 0.0 );
glRotatef( RotX, 1.0, 0.0, 0.0);
glRotatef( RotY, 0.0, 1.0, 0.0);
glColor4f( 0.0, 0.0, 0.0, 1.0 );
glScalef( scale/X_RANGE, scale/Y_RANGE, scale/Z_RANGE );
for(int i =0;i<globalField->nSensors;i++)
{
Sensor *s=globalField->sensorPool+i;
if(s->notchDegree> globalField->edgeLandmarks.size()*0.1)
{
glPointSize(2);
glColor3f(1,0,0);
glBegin(GL_POINTS);
glVertex3f(s->finalLocalization.x,s->finalLocalization.y,s->finalLocalization.z);
glEnd();
}
else
{
glPointSize(2);
glColor3f(0,0,0);
glBegin(GL_POINTS);
glVertex3f(s->finalLocalization.x,s->finalLocalization.y,s->finalLocalization.z);
glEnd();
}
}
glFlush();
glutSwapBuffers();
} | [
"[email protected]"
]
| [
[
[
1,
1431
]
]
]
|
99b0f72c66810d669d1a0ac94669423b1b87d606 | 672d939ad74ccb32afe7ec11b6b99a89c64a6020 | /Graph/Graph3D/Matrix.cpp | 46f0800084df42ce9f4fe843abd6baca24f3f6c4 | []
| no_license | cloudlander/legacy | a073013c69e399744de09d649aaac012e17da325 | 89acf51531165a29b35e36f360220eeca3b0c1f6 | refs/heads/master | 2022-04-22T14:55:37.354762 | 2009-04-11T13:51:56 | 2009-04-11T13:51:56 | 256,939,313 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,003 | cpp | // Matrix.cpp: implementation of the CMatrix class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "Graph3D.h"
#include "Matrix.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CMatrix::CMatrix()
{
xDim=yDim=DIM;
type=MATRIX_INT;
matrixCol=NULL;
matrixLine=NULL;
InitMatrix(type);
}
CMatrix::CMatrix(int dimx,int dimy,int M_Type)
{
xDim=dimx;
yDim=dimy;
type=M_Type;
InitMatrix(type);
}
CMatrix::CMatrix(CMatrix& R_Matrix)
{
xDim=R_Matrix.GetLineDim();
yDim=R_Matrix.GetColDim();
type=R_Matrix.GetMatrixType();
InitMatrix(type);
*this=R_Matrix;
}
CMatrix::CMatrix(Point3D& point)
{
xDim=1;
yDim=4;
type=MATRIX_FLOAT;
InitMatrix(type);
matrixLine[0][0]=point.x;
matrixLine[0][1]=point.y;
matrixLine[0][2]=point.z;
matrixLine[0][3]=1;
}
CMatrix::~CMatrix()
{
if(matrixLine!=NULL){
for(int i=0;i<xDim;i++)
delete[] matrixLine[i];
delete[] matrixLine;
}
}
void CMatrix::InitMatrix(int M_Type)
{
int i,j;
switch(M_Type)
{
case MATRIX_FLOAT:
matrixLine=new float*[xDim];
for(j=0;j<xDim;j++)
matrixLine[j]=NULL;
for(i=0;i<xDim;i++)
{
matrixCol=new float[yDim];
for(j=0;j<yDim;j++)
matrixCol[j]=0;
// memset(matrixCol,0,yDim);
matrixLine[i]=matrixCol;
}
break;
case MATRIX_INT:
break;
}
}
void CMatrix::Clear()
{
for(int i=0;i<xDim;i++)
memset(matrixLine[i],0,yDim);
}
void CMatrix::ClearAt(int x,int y)
{
matrixLine[x][y]=0;
}
void CMatrix::SetAt(int x,int y,float elem)
{
switch(type)
{
case MATRIX_INT:
// matrixLine[x][y]=(int)(*elem);
break;
case MATRIX_FLOAT:
matrixLine[x][y]=(float)(elem);
break;
}
}
float CMatrix::GetAt(int x,int y)
{
return (float)matrixLine[x][y];
}
int CMatrix::GetLineDim()
{
return xDim;
}
int CMatrix::GetColDim()
{
return yDim;
}
int CMatrix::GetMatrixType()
{
return type;
}
CMatrix CMatrix::operator*(CMatrix& right)
{
int i,j,k;
float s=0;
CMatrix temp(xDim,yDim,type);
for(i=0;i<xDim;i++)
{
for(j=0;j<yDim;j++)
{
for(s=0,k=0;k<yDim;k++)
{
s+=matrixLine[i][k]*right.GetAt(k,j);
}
temp.SetAt(i,j,s);
}
}
return CMatrix(temp);
}
CMatrix& CMatrix::operator=(CMatrix& right)
{
int i,j;
for(i=0;i<xDim;i++)
for(j=0;j<yDim;j++)
matrixLine[i][j]=right.GetAt(i,j);
return *this;
}
CMatrix& CMatrix::operator=(Point3D& point)
{
ASSERT(xDim==1&&yDim==4);
matrixLine[0][0]=point.x;
matrixLine[0][1]=point.y;
matrixLine[0][2]=point.z;
matrixLine[0][3]=1;
return *this;
}
void CMatrix::SetIdentity()
{
if(xDim!=yDim) return;
for(int i=0;i<xDim;i++)
matrixLine[i][i]=1;
} | [
"xmzhang@5428276e-be0b-f542-9301-ee418ed919ad"
]
| [
[
[
1,
181
]
]
]
|
6170aed5fb32ab4e00accea572e8890b7f038ed2 | c6f4fe2766815616b37beccf07db82c0da27e6c1 | /PSCollidable.h | 387440f6182093626b833be74c9f999f138279e8 | []
| no_license | fragoulis/gpm-sem1-spacegame | c600f300046c054f7ab3cbf7193ccaad1503ca09 | 85bdfb5b62e2964588f41d03a295b2431ff9689f | refs/heads/master | 2023-06-09T03:43:53.175249 | 2007-12-13T03:03:30 | 2007-12-13T03:03:30 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,125 | h | #pragma once
#include "ParticleSystem.h"
class Tile3d;
class PSCollidable : public ParticleSystem
{
private:
// The tile the particle is currently in
Tile3d *m_CurTile;
// The tile in which the particle used to be
Tile3d *m_PrevTile;
// The tile size
int m_iTileSize;
// The halh number of tiles per side
int m_iHalfNumOfTiles;
// A list of object types to avoid detecting collision with
public:
/**
* Constructor
*/
PSCollidable();
/**
* Destructor
*/
virtual ~PSCollidable();
/**
*
*/
const Tile3d *getTile() const { return m_CurTile; }
const Tile3d *getPrevTile() const { return m_PrevTile; }
protected:
/**
*
*/
virtual void onCollisionWithTiles(
Particle *particle,
const Vector3f &vCollDir,
const Vector3f &vCollPoint ) = 0;
/**
*
*/
virtual void onCollisionWithObjects(
Particle *particle,
const Vector3f &vCollDir,
const Vector3f &vCollPoint,
Object *obj ) = 0;
/**
*
*/
void init();
/**
*
*/
void checkCollision( Particle *particle );
private:
/**
*
*/
bool checkCollisionWithTiles(
const Vector3f &vPos,
Vector3f &vCollDir,
Vector3f &vCollPoint );
/**
*
*/
bool checkCollisionWithObject(
Particle *particle,
Vector3f &vCollDir,
Vector3f &vCollPoint,
Object *oObj
);
/**
*
*/
bool readTile( Particle *particle );
bool readPrevTile( Particle *particle );
/**
*
*/
bool checkWithBox(
Particle *particle,
const Vector3f& vPos,
const Vector3f& vBBox,
Vector3f& vCollDir ) const;
/**
*
*/
bool checkWithSphere(
Particle *particle,
const Vector3f& vPos,
float fRadius,
Vector3f& vCollDir,
Vector3f& vCollPoint ) const;
}; | [
"john.fragkoulis@201bd241-053d-0410-948a-418211174e54"
]
| [
[
[
1,
111
]
]
]
|
f56241e96015c6dfa3ba926c0956db40db5b5906 | 21dd1ece27a68047f93bac2bdf9e6603827b1990 | /CppUTest/include/CppUTest/MemoryLeakDetector.h | 1e3d30df598706e626b444d09017a1403d40f242 | []
| no_license | LupusDei/8LU-DSP | c626ce817b6b178c226c437537426f25597958a5 | 65860326bb89a36ff71871b046642b7dd45d5607 | refs/heads/master | 2021-01-17T21:51:19.971505 | 2010-09-24T15:08:01 | 2010-09-24T15:08:01 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,672 | h |
#ifndef D_MemoryLeakDetector_h
#define D_MemoryLeakDetector_h
#define MEM_LEAK_NONE "No memory leaks were detected."
#define MEM_LEAK_HEADER "Memory leak(s) found.\n"
#define MEM_LEAK_LEAK "Leak size: %d Allocated at: %s and line: %d. Type: \"%s\" Content: \"%.15s\"\n"
#define MEM_LEAK_FOOTER "Total number of leaks: "
#define MEM_LEAK_ALLOC_DEALLOC_MISMATCH "Allocation/deallocation type mismatch\n"
#define MEM_LEAK_MEMORY_CORRUPTION "Memory corruption (written out of bounds?)\n"
#define MEM_LEAK_ALLOC_LOCATION " allocated at file: %s line: %d size: %d type: %s\n"
#define MEM_LEAK_DEALLOC_LOCATION " dealllocated at file: %s line: %d type: %s\n"
#define MEM_LEAK_DEALLOC_NON_ALLOCATED "Deallocating non-allocated memory\n"
enum MemLeakPeriod { mem_leak_period_all, mem_leak_period_disabled, mem_leak_period_enabled, mem_leak_period_checking };
enum MemLeakAllocType {mem_leak_alloc_new, mem_leak_alloc_new_array, mem_leak_alloc_malloc, mem_leak_alloc_unknown};
#include <stdlib.h>
class MemoryLeakFailure
{
public:
virtual ~MemoryLeakFailure() {};
virtual void fail(char* fail_string)=0;
};
struct SimpleBuffer
{
enum { SIMPLE_BUFFER_LEN = 4096};
SimpleBuffer();
void clear();
void add(const char* format, ...);
char* toString();
private:
char buffer[SIMPLE_BUFFER_LEN];
int positions_filled;
};
struct MemoryLeakDetectorNode
{
MemoryLeakDetectorNode() : size(0), next(0) {};
size_t size;
char* memory;
char* file;
int line;
MemLeakAllocType type;
MemLeakPeriod period;
private:
friend struct MemoryLeakDetectorList;
MemoryLeakDetectorNode* next;
};
struct MemoryLeakDetectorList
{
MemoryLeakDetectorList() : head(0) {};
static void initNode(MemoryLeakDetectorNode* node, size_t size, char* memory, MemLeakPeriod period, char* file, int line, MemLeakAllocType type);
void addNewNode(MemoryLeakDetectorNode* node);
MemoryLeakDetectorNode* removeNode(char* memory);
MemoryLeakDetectorNode* getFirstLeak(MemLeakPeriod period);
MemoryLeakDetectorNode* getNextLeak(MemoryLeakDetectorNode* node, MemLeakPeriod period);
MemoryLeakDetectorNode* getLeakFrom(MemoryLeakDetectorNode* node, MemLeakPeriod period);
int getTotalLeaks(MemLeakPeriod period);
bool hasLeaks(MemLeakPeriod period);
void clearAllAccounting(MemLeakPeriod period);
bool isInPeriod(MemoryLeakDetectorNode* node, MemLeakPeriod period);
private:
MemoryLeakDetectorNode* head;
};
struct MemoryLeakDetectorTable
{
void clearAllAccounting(MemLeakPeriod period);
void addNewNode(MemoryLeakDetectorNode* node);
MemoryLeakDetectorNode* removeNode(char* memory);
bool hasLeaks(MemLeakPeriod period);
int getTotalLeaks(MemLeakPeriod period);
MemoryLeakDetectorNode* getFirstLeak(MemLeakPeriod period);
MemoryLeakDetectorNode* getNextLeak(MemoryLeakDetectorNode* leak, MemLeakPeriod period);
private:
int hash(char* memory);
enum {hash_prime = MEMORY_LEAK_HASH_TABLE_SIZE};
MemoryLeakDetectorList table[hash_prime];
};
class MemoryLeakDetector
{
public:
MemoryLeakDetector();
~MemoryLeakDetector() {}
void init(MemoryLeakFailure* reporter);
void enable();
void disable();
void disableAllocationTypeChecking();
void enableAllocationTypeChecking();
void startChecking();
void stopChecking();
const char* report(MemLeakPeriod period);
void markCheckingPeriodLeaksAsNonCheckingPeriod();
int totalMemoryLeaks(MemLeakPeriod period);
void clearAllAccounting(MemLeakPeriod period);
char* allocOperatorNew(size_t size);
char* allocOperatorNew(size_t size, const char* file, int line);
char* allocOperatorNewArray(size_t size);
char* allocOperatorNewArray(size_t size, const char* file, int line);
char* allocMalloc(size_t size);
char* allocMalloc(size_t size, const char* file, int line);
char* allocRealloc(char* memory, size_t size, const char* file, int line);
void freeOperatorDelete(char* memory);
void freeOperatorDeleteArray(char* memory);
void freeFree(char* memory);
void freeFree(char* memory, const char* file, int line);
enum { memory_corruption_buffer_size = 3};
private:
MemoryLeakFailure* reporter;
MemLeakPeriod current_period;
SimpleBuffer output_buffer;
MemoryLeakDetectorTable memoryTable;
bool doAllocationTypeChecking;
void ConstructMemoryLeakReport(MemLeakPeriod period);
void reportFailure(const char* message, const char* allocFile, int allocLine, size_t allocSize, MemLeakAllocType allocType, const char* freeFile, int freeLine, MemLeakAllocType freeType);
char* alloc(size_t size, char* file, int line, MemLeakAllocType type);
char* reallocate(char* memory, size_t size, char* file, int line, MemLeakAllocType type);
const char* getTypeString(MemLeakAllocType type);
void dealloc(char* memory, const char* file, int line, MemLeakAllocType type);
char* reallocateMemoryAndExtraInfo(char* memory, size_t size);
char* allocateMemoryAndExtraInfo(size_t size);
void addMemoryCorruptionInformation(char* memory, size_t size);
void checkForAllocMismatchOrCorruption(MemoryLeakDetectorNode* node, const char* file, int line, MemLeakAllocType type);
void addMemoryLeakInfoAndCorruptionInfo(char* memory, size_t size, char* file, int line, MemLeakAllocType type);
bool removeMemoryLeakInfoAndCheckCorruption(char* memory, const char* file, int line, MemLeakAllocType type);
MemoryLeakDetectorNode* getNodeFromMemoryPointer(char* memory, size_t size);
};
#endif
| [
"[email protected]"
]
| [
[
[
1,
161
]
]
]
|
dc831df00606526f2419c01b0d625fba8b83e16c | f71e82b7ed19200280b7164a2e959310d9bfa210 | /ExampleAIModule/ExampleAIModule/strategy_manager.cpp | 8d186df5a2ae00c75e85a26e0fecf6f70885e4da | []
| no_license | albertouri/manolobot | 05cf4ee217e85f1332e0e063fcc209da4b71c7b5 | 44e7fee46abcf4f1efa6d292ea8ec7cdc57eb7c8 | refs/heads/master | 2021-01-02T08:32:48.281836 | 2011-02-03T23:28:08 | 2011-02-03T23:28:08 | 39,591,406 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 13,739 | cpp | #include "strategy_manager.h"
#include <BWAPI.h>
using namespace BWAPI;
int IdUnidades[34] = {112,123,111,12,125,106,107,115,117,11,122,113,32,1,3,120,0,34,124,14,108,118,110,7,116,9,30,5,114,109,58,2,13,8};
int estadoActual = 0;
strategy_manager::strategy_manager(void)
{
for (int x = 0; x < 34; x++){
this->cantUnidades[x] = 0;
this->GoalUnidades[x] = 0;
}
cantUnidades[Utilidades::INDEX_GOAL_SCV] = 4;
cantUnidades[Utilidades::INDEX_GOAL_COMMANDCENTER] = 1;
for (int x = 0; x < Utilidades::maxResearch; x++){
this->ResearchDone[x] = false;
this->GoalResearch[x] = 0;
}
estadoActual = 0;
}
strategy_manager::~strategy_manager(void)
{
}
void strategy_manager::checkGoals(void){
// Realiza un control para ver si es necesario construir un nuevo supply depot
if (Broodwar->getFrameCount() % 20 == 0){
if (Broodwar->self()->supplyUsed()+4 >= Broodwar->self()->supplyTotal()){
GoalUnidades[Utilidades::INDEX_GOAL_DEPOT]++;
}
}
if (estadoActual == 0){
if (cantUnidades[Utilidades::INDEX_GOAL_COMMANDCENTER] == 0){
GoalUnidades[Utilidades::INDEX_GOAL_COMMANDCENTER] = 1;
}
else if (cantUnidades[Utilidades::INDEX_GOAL_BARRACK] == 0){
estadoActual = 0;
GoalUnidades[Utilidades::INDEX_GOAL_BARRACK] = 1;
GoalUnidades[Utilidades::INDEX_GOAL_SCV] = 9;
GoalUnidades[Utilidades::INDEX_GOAL_MARINE] = 12;
}
else if ((cantUnidades[Utilidades::INDEX_GOAL_BARRACK] == 1)&&(cantUnidades[Utilidades::INDEX_GOAL_MARINE] < 4)){
GoalUnidades[Utilidades::INDEX_GOAL_BUNKER] = 3;
}
else if ((cantUnidades[Utilidades::INDEX_GOAL_BARRACK] == 1) && (cantUnidades[Utilidades::INDEX_GOAL_BUNKER] >= 1)&& (cantUnidades[Utilidades::INDEX_GOAL_MARINE] > 4)){
GoalUnidades[Utilidades::INDEX_GOAL_BARRACK] = 2;
}
else if((cantUnidades[Utilidades::INDEX_GOAL_BARRACK] >= 2) && (cantUnidades[Utilidades::INDEX_GOAL_MARINE] >= 8)){
Broodwar->printf("Pase al estado 1 en el strategy manager");
estadoActual = 1;
}
}
else if (estadoActual == 1){
if(cantUnidades[Utilidades::INDEX_GOAL_REFINERY] == 0){
GoalUnidades[Utilidades::INDEX_GOAL_REFINERY] = 1;
}
else if (cantUnidades[Utilidades::INDEX_GOAL_ACADEMY] == 0){
GoalUnidades[Utilidades::INDEX_GOAL_ACADEMY] = 1;
}
if ((Broodwar->self()->minerals() > 50) && (Broodwar->self()->gas() > 50) && (cantUnidades[Utilidades::INDEX_GOAL_ACADEMY] > 0)){
Broodwar->printf("Pase al estado 2 en el strategy manager");
estadoActual = 2;
}
}
else if (estadoActual == 2){
if ((cantUnidades[Utilidades::INDEX_GOAL_COMMANDCENTER] > 0) && (cantUnidades[Utilidades::INDEX_GOAL_COMSAT_STATION] == 0)){
GoalUnidades[Utilidades::INDEX_GOAL_COMSAT_STATION] = 1;
GoalUnidades[Utilidades::INDEX_GOAL_FACTORY] = 1;
}
if (cantUnidades[Utilidades::INDEX_GOAL_COMSAT_STATION] > 0){
GoalUnidades[Utilidades::INDEX_GOAL_SCV] = 15;
Broodwar->printf("Pase al estado 3 en el strategy manager");
estadoActual = 3;
}
}
else if (estadoActual == 3){
if ((cantUnidades[Utilidades::INDEX_GOAL_FACTORY] > 0) && (cantUnidades[Utilidades::INDEX_GOAL_MACHINESHOP] == 0)){
GoalUnidades[Utilidades::INDEX_GOAL_MACHINESHOP] = 1;
}
else if ((cantUnidades[Utilidades::INDEX_GOAL_MACHINESHOP] > 0) && (!ResearchDone[Utilidades::INDEX_GOAL_U238])){
GoalUnidades[Utilidades::INDEX_GOAL_TANKSIEGE] = 3;
GoalResearch[Utilidades::INDEX_GOAL_TANK_SIEGE_MODE] = 1;
GoalResearch[Utilidades::INDEX_GOAL_U238] = 1;
}
if ((cantUnidades[Utilidades::INDEX_GOAL_TANKSIEGE] == 3) && (ResearchDone[Utilidades::INDEX_GOAL_TANK_SIEGE_MODE])){
Broodwar->printf("Pase al estado 4 en el strategy manager");
estadoActual = 4;
}
}
else if (estadoActual == 4){
if (cantUnidades[Utilidades::INDEX_GOAL_ENGINEERING_BAY] == 0){
GoalUnidades[Utilidades::INDEX_GOAL_ENGINEERING_BAY] = 1;
GoalUnidades[Utilidades::INDEX_GOAL_VULTURE] = 1;
GoalUnidades[Utilidades::INDEX_GOAL_MARINE] = 27;
GoalResearch[Utilidades::INDEX_GOAL_STIMPACK] = 1;
}
else if (cantUnidades[Utilidades::INDEX_GOAL_ARMORY] == 0){
GoalUnidades[Utilidades::INDEX_GOAL_ARMORY] = 1;
}
else if (cantUnidades[Utilidades::INDEX_GOAL_STARPORT] == 0){
GoalUnidades[Utilidades::INDEX_GOAL_STARPORT] = 1;
}
else if ((cantUnidades[Utilidades::INDEX_GOAL_ARMORY] > 0) && (!ResearchDone[Utilidades::INDEX_GOAL_VEHICLE_WEAPONS_LVL1])){
GoalResearch[Utilidades::INDEX_GOAL_VEHICLE_WEAPONS_LVL1] = 1;
GoalResearch[Utilidades::INDEX_GOAL_OPTICAL_FLARE] = 1;
}
else if (!ResearchDone[Utilidades::INDEX_GOAL_INFANTRY_WEAPONS_LVL1]){
GoalResearch[Utilidades::INDEX_GOAL_INFANTRY_WEAPONS_LVL1] = 1;
GoalResearch[Utilidades::INDEX_GOAL_RESTORATION] = 1;
GoalResearch[Utilidades::INDEX_GOAL_CHARON_BOOSTERS] = 1;
GoalUnidades[Utilidades::INDEX_GOAL_MEDIC] = 7;
GoalUnidades[Utilidades::INDEX_GOAL_GOLIATH] = 4;
GoalUnidades[Utilidades::INDEX_GOAL_TANKSIEGE] = 12;
}
else if (!ResearchDone[Utilidades::INDEX_GOAL_INFANTRY_ARMOR_LVL1]){
GoalResearch[Utilidades::INDEX_GOAL_INFANTRY_ARMOR_LVL1] = 1;
}
else if ((cantUnidades[Utilidades::INDEX_GOAL_STARPORT] > 0) && (cantUnidades[Utilidades::INDEX_GOAL_CONTROL_TOWER] == 0)){
GoalUnidades[Utilidades::INDEX_GOAL_CONTROL_TOWER] = 1;
GoalUnidades[Utilidades::INDEX_GOAL_SCIENCE_FACILITY] = 1;
GoalUnidades[Utilidades::INDEX_GOAL_COVERT_OPS] = 1;
GoalResearch[Utilidades::INDEX_GOAL_LOCKDOWN] = 1;
}
if ((cantUnidades[Utilidades::INDEX_GOAL_SCIENCE_FACILITY] > 0)){
Broodwar->printf("Pase al estado 5 en el strategy manager");
estadoActual = 5;
}
}
else if (estadoActual == 5){
if ((cantUnidades[Utilidades::INDEX_GOAL_COMMANDCENTER] == 1) && (cantUnidades[Utilidades::INDEX_GOAL_BUNKER] < 6)){
GoalUnidades[Utilidades::INDEX_GOAL_COMMANDCENTER] = 2;
GoalUnidades[Utilidades::INDEX_GOAL_BUNKER] = 6;
GoalUnidades[Utilidades::INDEX_GOAL_REFINERY] = 2;
}
if (cantUnidades[Utilidades::INDEX_GOAL_COMMANDCENTER] > 1){
estadoActual = 6;
}
}
else if (estadoActual == 6){
if (cantUnidades[Utilidades::INDEX_GOAL_SCIENCE_VESSEL] == 0){
GoalUnidades[Utilidades::INDEX_GOAL_MARINE] = 45;
GoalUnidades[Utilidades::INDEX_GOAL_SCIENCE_VESSEL] = 1;
}
else if ((cantUnidades[Utilidades::INDEX_GOAL_BUNKER] == 6) && (cantUnidades[Utilidades::INDEX_GOAL_TANKSIEGE] == 3)){
GoalUnidades[Utilidades::INDEX_GOAL_TANKSIEGE] = 15;
}
else if (!ResearchDone[Utilidades::INDEX_GOAL_INFANTRY_WEAPONS_LVL2]){
GoalResearch[Utilidades::INDEX_GOAL_INFANTRY_WEAPONS_LVL2] = 1;
}
else if (!ResearchDone[Utilidades::INDEX_GOAL_INFANTRY_ARMOR_LVL2]){
GoalResearch[Utilidades::INDEX_GOAL_INFANTRY_ARMOR_LVL2] = 1;
}
else if (!ResearchDone[Utilidades::INDEX_GOAL_VEHICLE_WEAPONS_LVL2]){
GoalResearch[Utilidades::INDEX_GOAL_VEHICLE_WEAPONS_LVL2] = 1;
}
else if (!ResearchDone[Utilidades::INDEX_GOAL_VEHICLE_PLATING_LVL1]){
GoalResearch[Utilidades::INDEX_GOAL_VEHICLE_PLATING_LVL1] = 1;
}
else if (!ResearchDone[Utilidades::INDEX_GOAL_INFANTRY_WEAPONS_LVL3]){
GoalResearch[Utilidades::INDEX_GOAL_INFANTRY_WEAPONS_LVL3] = 1;
}
else if (!ResearchDone[Utilidades::INDEX_GOAL_INFANTRY_ARMOR_LVL3]){
GoalResearch[Utilidades::INDEX_GOAL_INFANTRY_ARMOR_LVL3] = 1;
}
}
}
int* strategy_manager::getGoals(){
return GoalUnidades;
}
int* strategy_manager::getResearchs(){
return GoalResearch;
}
void strategy_manager::setResearchsDone(bool *rd){
for (int x = 0; x < Utilidades::maxResearch; x++)
ResearchDone[x] = rd[x];
}
void strategy_manager::onUnitCreate(Unit* u){
if(Broodwar->self()== u->getPlayer()){
switch (u->getType().getID()){
case Utilidades::ID_ACADEMY:
cantUnidades[Utilidades::INDEX_GOAL_ACADEMY]++;
break;
case Utilidades::ID_BARRACK:
cantUnidades[Utilidades::INDEX_GOAL_BARRACK]++;
break;
case Utilidades::ID_BUNKER:
cantUnidades[Utilidades::INDEX_GOAL_BUNKER]++;
break;
case Utilidades::ID_DEPOT:
cantUnidades[Utilidades::INDEX_GOAL_DEPOT]++;
break;
case Utilidades::ID_FIREBAT:
cantUnidades[Utilidades::INDEX_GOAL_FIREBAT]++;
break;
case Utilidades::ID_MARINE:
cantUnidades[Utilidades::INDEX_GOAL_MARINE]++;
break;
case Utilidades::ID_MEDIC:
cantUnidades[Utilidades::INDEX_GOAL_MEDIC]++;
break;
case Utilidades::ID_REFINERY:
cantUnidades[Utilidades::INDEX_GOAL_REFINERY]++;
break;
case Utilidades::ID_SCV:
cantUnidades[Utilidades::INDEX_GOAL_SCV]++;
break;
case Utilidades::ID_FACTORY:
cantUnidades[Utilidades::INDEX_GOAL_FACTORY]++;
break;
case Utilidades::ID_MACHINESHOP:
cantUnidades[Utilidades::INDEX_GOAL_MACHINESHOP]++;
break;
case Utilidades::ID_TANKSIEGE:
cantUnidades[Utilidades::INDEX_GOAL_TANKSIEGE]++;
break;
case Utilidades::ID_TANKSIEGE_SIEGEMODE:
cantUnidades[Utilidades::INDEX_GOAL_TANKSIEGE]++;
break;
case Utilidades::ID_ENGINEERING_BAY:
cantUnidades[Utilidades::INDEX_GOAL_ENGINEERING_BAY]++;
break;
case Utilidades::ID_ARMORY:
cantUnidades[Utilidades::INDEX_GOAL_ARMORY]++;
break;
case Utilidades::ID_STARPORT:
cantUnidades[Utilidades::INDEX_GOAL_STARPORT]++;
break;
case Utilidades::ID_COMSAT_STATION:
cantUnidades[Utilidades::INDEX_GOAL_COMSAT_STATION]++;
break;
case Utilidades::ID_MISSILE_TURRET:
cantUnidades[Utilidades::INDEX_GOAL_MISSILE_TURRET]++;
break;
case Utilidades::ID_GOLIATH:
cantUnidades[Utilidades::INDEX_GOAL_GOLIATH]++;
break;
case Utilidades::ID_CONTROL_TOWER:
cantUnidades[Utilidades::INDEX_GOAL_CONTROL_TOWER]++;
break;
case Utilidades::ID_DROPSHIP:
cantUnidades[Utilidades::INDEX_GOAL_DROPSHIP]++;
break;
case Utilidades::ID_SCIENCE_FACILITY:
cantUnidades[Utilidades::INDEX_GOAL_SCIENCE_FACILITY]++;
break;
case Utilidades::ID_SCIENCE_VESSEL:
cantUnidades[Utilidades::INDEX_GOAL_SCIENCE_VESSEL]++;
break;
case Utilidades::ID_WRAITH:
cantUnidades[Utilidades::INDEX_GOAL_WRAITH]++;
break;
case Utilidades::ID_COVERT_OPS:
cantUnidades[Utilidades::INDEX_GOAL_COVERT_OPS]++;
break;
case Utilidades::ID_GHOST:
cantUnidades[Utilidades::INDEX_GOAL_GHOST]++;
break;
case Utilidades::ID_COMMANDCENTER:
cantUnidades[Utilidades::INDEX_GOAL_COMMANDCENTER]++;
break;
case Utilidades::ID_VULTURE:
cantUnidades[Utilidades::INDEX_GOAL_VULTURE]++;
break;
}
}
}
void strategy_manager::onUnitDestroy(Unit *u){
if(Broodwar->self()== u->getPlayer()){
switch (u->getType().getID()){
case Utilidades::ID_ACADEMY:
cantUnidades[Utilidades::INDEX_GOAL_ACADEMY]--;
break;
case Utilidades::ID_BARRACK:
cantUnidades[Utilidades::INDEX_GOAL_BARRACK]--;
break;
case Utilidades::ID_BUNKER:
cantUnidades[Utilidades::INDEX_GOAL_BUNKER]--;
break;
case Utilidades::ID_DEPOT:
cantUnidades[Utilidades::INDEX_GOAL_DEPOT]--;
break;
case Utilidades::ID_FIREBAT:
cantUnidades[Utilidades::INDEX_GOAL_FIREBAT]--;
break;
case Utilidades::ID_MARINE:
cantUnidades[Utilidades::INDEX_GOAL_MARINE]--;
break;
case Utilidades::ID_MEDIC:
cantUnidades[Utilidades::INDEX_GOAL_MEDIC]--;
break;
case Utilidades::ID_REFINERY:
cantUnidades[Utilidades::INDEX_GOAL_REFINERY]--;
break;
case Utilidades::ID_SCV:
cantUnidades[Utilidades::INDEX_GOAL_SCV]--;
break;
case Utilidades::ID_FACTORY:
cantUnidades[Utilidades::INDEX_GOAL_FACTORY]--;
break;
case Utilidades::ID_MACHINESHOP:
cantUnidades[Utilidades::INDEX_GOAL_MACHINESHOP]--;
break;
case Utilidades::ID_TANKSIEGE:
cantUnidades[Utilidades::INDEX_GOAL_TANKSIEGE]--;
break;
case Utilidades::ID_TANKSIEGE_SIEGEMODE:
cantUnidades[Utilidades::INDEX_GOAL_TANKSIEGE]--;
break;
case Utilidades::ID_ENGINEERING_BAY:
cantUnidades[Utilidades::INDEX_GOAL_ENGINEERING_BAY]--;
break;
case Utilidades::ID_ARMORY:
cantUnidades[Utilidades::INDEX_GOAL_ARMORY]--;
break;
case Utilidades::ID_STARPORT:
cantUnidades[Utilidades::INDEX_GOAL_STARPORT]--;
break;
case Utilidades::ID_COMSAT_STATION:
cantUnidades[Utilidades::INDEX_GOAL_COMSAT_STATION]--;
break;
case Utilidades::ID_MISSILE_TURRET:
cantUnidades[Utilidades::INDEX_GOAL_MISSILE_TURRET]--;
break;
case Utilidades::ID_GOLIATH:
cantUnidades[Utilidades::INDEX_GOAL_GOLIATH]--;
break;
case Utilidades::ID_CONTROL_TOWER:
cantUnidades[Utilidades::INDEX_GOAL_CONTROL_TOWER]--;
break;
case Utilidades::ID_DROPSHIP:
cantUnidades[Utilidades::INDEX_GOAL_DROPSHIP]--;
break;
case Utilidades::ID_SCIENCE_FACILITY:
cantUnidades[Utilidades::INDEX_GOAL_SCIENCE_FACILITY]--;
break;
case Utilidades::ID_SCIENCE_VESSEL:
cantUnidades[Utilidades::INDEX_GOAL_SCIENCE_VESSEL]--;
break;
case Utilidades::ID_WRAITH:
cantUnidades[Utilidades::INDEX_GOAL_WRAITH]--;
break;
case Utilidades::ID_COVERT_OPS:
cantUnidades[Utilidades::INDEX_GOAL_COVERT_OPS]--;
break;
case Utilidades::ID_GHOST:
cantUnidades[Utilidades::INDEX_GOAL_GHOST]--;
break;
case Utilidades::ID_COMMANDCENTER:
cantUnidades[Utilidades::INDEX_GOAL_COMMANDCENTER]--;
break;
case Utilidades::ID_VULTURE:
cantUnidades[Utilidades::INDEX_GOAL_VULTURE]--;
break;
}
}
}
int strategy_manager::getEstadoActual(){
return estadoActual;
} | [
"[email protected]",
"marianomoreno3@82b963ee-1e64-6eb5-a9c5-6632919fd137"
]
| [
[
[
1,
5
],
[
7,
7
],
[
9,
11
],
[
26,
33
],
[
37,
37
],
[
42,
42
],
[
49,
49
],
[
53,
53
],
[
57,
58
],
[
61,
62
],
[
64,
64
],
[
107,
107
],
[
123,
124
],
[
126,
127
],
[
163,
185
],
[
198,
240
],
[
256,
258
],
[
265,
268
],
[
273,
273
],
[
283,
286
],
[
292,
334
],
[
350,
352
],
[
359,
364
],
[
377,
380
]
],
[
[
6,
6
],
[
8,
8
],
[
12,
25
],
[
34,
36
],
[
38,
41
],
[
43,
48
],
[
50,
52
],
[
54,
56
],
[
59,
60
],
[
63,
63
],
[
65,
106
],
[
108,
122
],
[
125,
125
],
[
128,
162
],
[
186,
197
],
[
241,
255
],
[
259,
264
],
[
269,
272
],
[
274,
282
],
[
287,
291
],
[
335,
349
],
[
353,
358
],
[
365,
376
],
[
381,
388
]
]
]
|
b4cbbd587e23805b5d39a44294ba2e485b37e2c5 | 91b964984762870246a2a71cb32187eb9e85d74e | /SRC/OFFI SRC!/PatchClient/scanner.cpp | a3ee4661f28c0d32c418f93096430095c91add05 | []
| no_license | willrebuild/flyffsf | e5911fb412221e00a20a6867fd00c55afca593c7 | d38cc11790480d617b38bb5fc50729d676aef80d | refs/heads/master | 2021-01-19T20:27:35.200154 | 2011-02-10T12:34:43 | 2011-02-10T12:34:43 | 32,710,780 | 3 | 0 | null | null | null | null | UHC | C++ | false | false | 25,487 | cpp | //*************************************************************
//
// 정수만이 가능한 Recursive descent parser
// 변수의 사용이 가능하고 함수를 호출할 수 있으며,
// goto 명령 등 Little C에서 제공하지 않는 기능을 제공한다.
//
// by Travis nam
//
//*************************************************************
#include "stdafx.h"
#include <comdef.h>
#include "vutil.h"
#include "xutil.h"
inline int iswhite( wchar_t c )
{
if(c > 0 && c <= 0x20)
return 1;
return 0;
}
inline int isdelim( wchar_t c )
{
if(strchr(" !:;,+-<>'/*%^=()&|\"{}",c) || c == 9 || c == '\r' || c == 0 || c == '\n' )
return 1;
return 0;
}
//
// 토큰 스트림
//
WORD g_codePage = 0; // 949
namespace THAI
{
enum CLASS {
CTRL= 0,
NON= 1,
CONS= 2,
LV= 3,
FV1= 4,
FV2= 5,
FV3= 6,
BV1= 7,
BV2= 8,
BD= 9,
TONE=10,
AD1=11,
AD2=12,
AD3=13,
AV1=14,
AV2=15,
AV3=16,
};
CLASS CLASS_TABLE[256] = {
CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL,
CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL,
NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON,
NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON,
NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON,
NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON,
NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON,
NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, CTRL,
CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL,
CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL, CTRL,
NON, CONS, CONS, CONS, CONS, CONS, CONS, CONS, CONS, CONS, CONS, CONS, CONS, CONS, CONS, CONS,
CONS, CONS, CONS, CONS, CONS, CONS, CONS, CONS, CONS, CONS, CONS, CONS, CONS, CONS, CONS, CONS,
CONS, CONS, CONS, CONS, FV3, CONS, FV3, CONS, CONS, CONS, CONS, CONS, CONS, CONS, CONS, NON,
FV1, AV2, FV1, FV1, AV1, AV3, AV2, AV3, BV1, BV2, BD, NON, NON, NON, NON, NON,
LV, LV, LV, LV, LV, FV2, NON, AD2, TONE, TONE, TONE, TONE, AD1, AD1, AD3, NON,
NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, NON, CTRL,
};
namespace INPUT
{
enum TYPE { A, C, S, R, X };
bool COMPOSIBLE[3][5] = {
{ true, true, true, true, true },
{ true, true, true,false, true },
{ true, true,false,false, true },
};
TYPE STATE_CHECK[17][17] = {
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6
{ X,A,A,A,A,A,A,R,R,R,R,R,R,R,R,R,R }, // 0
{ X,A,A,A,S,S,A,R,R,R,R,R,R,R,R,R,R }, // 1
{ X,A,A,A,A,S,A,C,C,C,C,C,C,C,C,C,C }, // 2
{ X,S,A,S,S,S,S,R,R,R,R,R,R,R,R,R,R }, // 3
{ X,S,A,S,A,S,A,R,R,R,R,R,R,R,R,R,R }, // 4
{ X,A,A,A,A,S,A,R,R,R,R,R,R,R,R,R,R }, // 5
{ X,A,A,A,S,A,S,R,R,R,R,R,R,R,R,R,R }, // 6
{ X,A,A,A,A,S,A,R,R,R,C,C,R,R,R,R,R }, // 7
{ X,A,A,A,S,S,A,R,R,R,C,R,R,R,R,R,R }, // 8
{ X,A,A,A,S,S,A,R,R,R,R,R,R,R,R,R,R }, // 9
{ X,A,A,A,A,A,A,R,R,R,R,R,R,R,R,R,R }, // 0
{ X,A,A,A,S,S,A,R,R,R,R,R,R,R,R,R,R }, // 1
{ X,A,A,A,S,S,A,R,R,R,R,R,R,R,R,R,R }, // 2
{ X,A,A,A,S,S,A,R,R,R,R,R,R,R,R,R,R }, // 3
{ X,A,A,A,S,S,A,R,R,R,C,C,R,R,R,R,R }, // 4
{ X,A,A,A,S,S,A,R,R,R,C,R,R,R,R,R,R }, // 5
{ X,A,A,A,S,S,A,R,R,R,C,R,C,R,R,R,R }, // 6
};
}
namespace OUTPUT
{
enum TYPE { N, C, X };
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6
TYPE STATE_CHECK[17][17] = {
{ X,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N }, // 0
{ X,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N }, // 1
{ X,N,N,N,N,N,N,C,C,C,C,C,C,C,C,C,C }, // 2
{ X,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N }, // 3
{ X,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N }, // 4
{ X,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N }, // 5
{ X,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N }, // 6
{ X,N,N,N,N,N,N,N,N,N,C,C,N,N,N,N,N }, // 7
{ X,N,N,N,N,N,N,N,N,N,C,N,N,N,N,N,N }, // 8
{ X,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N }, // 9
{ X,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N }, // 0
{ X,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N }, // 1
{ X,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N }, // 2
{ X,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N,N }, // 3
{ X,N,N,N,N,N,N,N,N,N,C,C,N,N,N,N,N }, // 4
{ X,N,N,N,N,N,N,N,N,N,C,N,N,N,N,N,N }, // 5
{ X,N,N,N,N,N,N,N,N,N,C,N,C,N,N,N,N }, // 6
};
}
}
bool IsComposibleTh(BYTE prev, BYTE curr, int mode)
{
using namespace THAI;
using namespace INPUT;
if(mode > 2) {
return false;
} else {
return COMPOSIBLE[mode][STATE_CHECK[CLASS_TABLE[prev]][CLASS_TABLE[curr]]];
}
}
// Unicode of thai : 0x0E00~0x0E7F (Direct Mapping)
// Thai Character -> Unicode (char+0x0E00)-0xA0 = char+0x0D60
// Unicode -> Thai Character (wchar_t-0x0E00)+0xA0 = wchar_t-0x0D60
const char* CharNextTh(const char* lpsz)
{
using namespace THAI;
using namespace OUTPUT;
const BYTE* stream = (const BYTE*)(lpsz);
while(STATE_CHECK
[
CLASS_TABLE
[
stream[ 0 ]
]
]
[
CLASS_TABLE
[
stream[ 1 ]
]
] == C) ++stream;
return (const char*)(stream+1);
}
const char* CharNextVt(const char* lpsz)
{
const BYTE* stream = (const BYTE*)(lpsz);
// 두번째 값이 성조일 경우 체크
switch(stream[1])
{
case 0xcc:
case 0xec:
case 0xd2:
case 0xde:
case 0xf2:
{
++stream;
}
break;
}
return (const char*)(stream+1);
}
const char* CharNextEx(const char* strText, WORD codePage)
{
if(::GetLanguage() == LANG_THA)
{
return CharNextTh(strText);
}
else if(::GetLanguage() == LANG_VTN)
{
return CharNextVt(strText);
}
else
{
return CharNextExA(g_codePage, strText, 0);
}
}
// 베트남어 처리
// 유니코드에서 1258 : [완성형 유니코드] -> [조합형 유니코드] -> [CodePage 1258 ANSI 호환코드]
// 1258에서 유니코드 : [CodePage 1258 ANSI 호환코드] -> [조합형 유니코드] -> [완성형 유니코드]
namespace VTN
{
wchar_t wVTNToneChar[24][6] = {
/*--------Precomposed characters------------Various*/
{0x00c1, 0x00c0, 0x1ea2, 0x00c3, 0x1ea0, 0x0041},
{0x00e1, 0x00e0, 0x1ea3, 0x00e3, 0x1ea1, 0x0061},
{0x1eae, 0x1eb0, 0x1eb2, 0x1eb4, 0x1eb6, 0x0102},
{0x1eaf, 0x1eb1, 0x1eb3, 0x1eb5, 0x1eb7, 0x0103},
{0x1ea4, 0x1ea6, 0x1ea8, 0x1eaa, 0x1eac, 0x00c2},
{0x1ea5, 0x1ea7, 0x1ea9, 0x1eab, 0x1ead, 0x00e2},
{0x00c9, 0x00c8, 0x1eba, 0x1ebc, 0x1eb8, 0x0045},
{0x00e9, 0x00e8, 0x1ebb, 0x1ebd, 0x1eb9, 0x0065},
{0x1ebe, 0x1ec0, 0x1ec2, 0x1ec4, 0x1ec6, 0x00ca},
{0x1ebf, 0x1ec1, 0x1ec3, 0x1ec5, 0x1ec7, 0x00ea},
{0x00cd, 0x00cc, 0x1ec8, 0x0128, 0x1eca, 0x0049},
{0x00ed, 0x00ec, 0x1ec9, 0x0129, 0x1ecb, 0x0069},
{0x00d3, 0x00d2, 0x1ece, 0x00d5, 0x1ecc, 0x004f},
{0x00f3, 0x00f2, 0x1ecf, 0x00f5, 0x1ecd, 0x006f},
{0x1ed0, 0x1ed2, 0x1ed4, 0x1ed6, 0x1ed8, 0x00d4},
{0x1ed1, 0x1ed3, 0x1ed5, 0x1ed7, 0x1ed9, 0x00f4},
{0x1eda, 0x1edc, 0x1ede, 0x1ee0, 0x1ee2, 0x01a0},
{0x1edb, 0x1edd, 0x1edf, 0x1ee1, 0x1ee3, 0x01a1},
{0x00da, 0x00d9, 0x1ee6, 0x0168, 0x1ee4, 0x0055},
{0x00fa, 0x00f9, 0x1ee7, 0x0169, 0x1ee5, 0x0075},
{0x1ee8, 0x1eea, 0x1eec, 0x1eee, 0x1ef0, 0x01af},
{0x1ee9, 0x1eeb, 0x1eed, 0x1eef, 0x1ef1, 0x01b0},
{0x1ef2, 0x00dd, 0x1ef6, 0x1ef8, 0x1ef4, 0x0059},
{0x1ef3, 0x00fd, 0x1ef7, 0x1ef9, 0x1ef5, 0x0079}
};
wchar_t wVTNCombiningDia[5] = {0x0301, 0x0300, 0x0309, 0x0303, 0x0323};
}
int IsTone(wchar_t input)
{
using namespace VTN;
//U0300 U0301 U0309 U0303 U0323 일때 true
for(int i=0; i<5; i++)
{
if(input == wVTNCombiningDia[i])
return i;
}
return -1;
}
wchar_t ComposeTone(wchar_t letter, int nTone)
{
using namespace VTN;
for(int i=0; i<24; i++)
{
if(letter == wVTNToneChar[i][5])
return wVTNToneChar[i][nTone];
}
return NULL;
}
bool GetTone(wchar_t input, int* pnLetterLine, int* pnTone)
{
using namespace VTN;
for(int i=0; i<24; i++)
{
for(int j=0; j<5; j++)
{
if(wVTNToneChar[i][j] == input)
{
if(pnLetterLine != NULL && pnTone != NULL)
{
*pnLetterLine = i;
*pnTone = j;
return true;
}
}
}
}
return false;
}
// 조합형 유니코드 -> 완성형 유니코드
void ComposeString(wchar_t* pwSrc, wchar_t* pwDest, int nSize)
{
using namespace VTN;
if(pwSrc == NULL || pwDest == NULL || nSize <= 0)
return;
for(int i=0; i<nSize; i++)
{
*pwDest = *pwSrc;
pwSrc++;
if(*pwDest == NULL)
break;
int nTone = IsTone(*pwSrc);
if(nTone > -1)
{
*pwDest = ComposeTone(*pwDest, nTone);
pwSrc++;
}
pwDest++;
}
}
// 완성형 유니코드 -> 조합형 유니코드
void DecomposeString(wchar_t* pwSrc, wchar_t* pwDest, int nSize)
{
using namespace VTN;
if(pwSrc == NULL || pwDest == NULL || nSize <= 0)
return;
int nLetterLine;
int nTone;
for(int i=0; i<nSize; i++)
{
if(GetTone(*pwSrc, &nLetterLine, &nTone))
{
*pwDest = wVTNToneChar[nLetterLine][5];
++pwDest;
*pwDest = wVTNCombiningDia[nTone];
}
else
{
*pwDest = *pwSrc;
}
++pwSrc;
++pwDest;
}
}
// 러시아어 키릴문자
BOOL IsCyrillic( const char chSrc )
{
if( ::GetLanguage() != LANG_RUS )
return FALSE;
BYTE c = chSrc & 0x000000ff;
static BOOL bCyrill[256] =
{// 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f
FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, // 0x00
FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, // 0x10
FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, // 0x20
FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, // 0x30
FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, // 0x40
FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, // 0x50
FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, // 0x60
FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, // 0x70
FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, // 0x80
FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, // 0x90
FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, // 0xa0
FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, // 0xb0
TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, // 0xc0
TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, // 0xd0
TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, // 0xe0
TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE // 0xf0
};
return bCyrill[c];
}
int WideCharToMultiByteEx(
UINT CodePage,
DWORD dwFlags,
LPCWSTR lpWideCharStr,
int cchWideChar,
LPSTR lpMultiByteStr,
int cchMultiByte,
LPCSTR lpDefaultChar,
LPBOOL lpUsedDefaultChar)
{
int nLength;
if(::GetLanguage() == LANG_VTN && lpMultiByteStr != NULL && cchMultiByte > 0)
{
int nSize = wcslen((LPCWSTR)lpWideCharStr);
wchar_t* pwSrc = new wchar_t[nSize+1];
wchar_t* pwDest = new wchar_t[(nSize*2)+1];
memcpy(pwSrc, lpWideCharStr, sizeof(wchar_t)*(nSize+1));
DecomposeString(pwSrc, pwDest, nSize+1);
nLength = WideCharToMultiByte(CodePage, dwFlags, pwDest, cchWideChar, lpMultiByteStr, cchMultiByte, lpDefaultChar, lpUsedDefaultChar);
if(pwSrc)
{
safe_delete_array(pwSrc);
pwSrc = NULL;
}
if(pwDest)
{
safe_delete_array(pwDest);
pwDest = NULL;
}
}
else
nLength = WideCharToMultiByte(CodePage, dwFlags, lpWideCharStr, cchWideChar, lpMultiByteStr, cchMultiByte, lpDefaultChar, lpUsedDefaultChar);
return nLength;
}
int MultiByteToWideCharEx(
UINT CodePage,
DWORD dwFlags,
LPCSTR lpMultiByteStr,
int cchMultiByte,
LPWSTR lpWideCharStr,
int cchWideChar)
{
int nLength;
if(::GetLanguage() == LANG_VTN && lpWideCharStr != NULL && cchWideChar > 0)
{
int nSize = lstrlen(lpMultiByteStr);
wchar_t* pwSrc = new wchar_t[nSize+1];
nLength = MultiByteToWideChar(CodePage, dwFlags, lpMultiByteStr, cchMultiByte, pwSrc, nSize+1);
ComposeString(pwSrc, lpWideCharStr, nLength);
if(pwSrc)
{
safe_delete_array(pwSrc);
pwSrc = NULL;
}
}
else
nLength = MultiByteToWideChar(CodePage, dwFlags, lpMultiByteStr, cchMultiByte, lpWideCharStr, cchWideChar);
return nLength;
}
CScanner::CScanner( BOOL bComma )
{
m_bComma = bComma;
m_pProg = m_pBuf = NULL;
m_bMemFlag = 1;
dwValue = 0;
m_lpMark = NULL;
m_dwDef = 0;
token = m_mszToken;
m_bErrorCheck = TRUE;
}
CScanner::CScanner( LPVOID p, BOOL bComma )
{
m_bComma = bComma;
m_pProg = m_pBuf = (CHAR*)p;
m_bMemFlag = 1;
dwValue = 0;
m_dwDef = 0;
token = m_mszToken;
m_bErrorCheck = TRUE;
}
CScanner::~CScanner()
{
Free();
}
void CScanner::Free()
{
if(!m_bMemFlag && m_pBuf)
safe_delete_array( m_pBuf );
m_pProg = m_pBuf = 0;
}
BOOL CScanner::Read( CFileIO* pFile, BOOL )
{
m_bMemFlag = 0;
m_nProgSize = pFile->GetLength();
int nSize = m_nProgSize + 2;
char* pProg = new char[ nSize ];
if( !pProg )
return 0;
m_pProg = m_pBuf = pProg;
pFile->Read( m_pBuf, m_nProgSize );
// 0xfffe의 2바이트를 빼고 널(0x0000)을 2바이트를 추가해서 결국 m_nProgSize는 변화 없음.
*(pProg + m_nProgSize ) = '\0';
*(pProg + m_nProgSize + 1 ) = '\0';
if( (BYTE)*(pProg + 0 ) == 0xff && (BYTE)*(pProg + 1 ) == 0xfe ) // is unicode ?
{
// 텍스트가 유니코드일 경우 멀티바이트로 변경
char* lpMultiByte = new char[ nSize ];
int nResult = WideCharToMultiByteEx( g_codePage, 0,
(LPCWSTR)(pProg + 2), -1,
lpMultiByte, nSize,
NULL, NULL );
if( nResult > 0 )
{
lpMultiByte[nResult-1] = 0;
memcpy( pProg, lpMultiByte, nResult );
}
safe_delete_array( lpMultiByte );
}
return 1;
}
BOOL CScanner::Load( LPCTSTR lpszFileName, BOOL bMultiByte )
{
CResFile file;
CString fileName = lpszFileName;
fileName.MakeLower();
if( !file.Open(lpszFileName, "rb" ) )
return 0;
m_strFileName = lpszFileName;
return Read( &file, bMultiByte );
}
BOOL CScanner::Load_FileIO( LPCTSTR lpszFileName, BOOL bMultiByte )
{
CFileIO file;
CString fileName = lpszFileName;
fileName.MakeLower();
if( !file.Open(lpszFileName, "rb" ) )
return 0;
m_strFileName = lpszFileName;
return Read( &file, bMultiByte );
}
void CScanner::SetProg( LPVOID pProg )
{
m_bMemFlag = 1; m_pProg = m_pBuf = (CHAR*)pProg;
}
int CScanner::GetLineNum( LPVOID lpProg )
{
int nLine = 0;
if( lpProg == NULL )
lpProg = m_pProg;
CHAR* pCur = m_pBuf;
while( lpProg != pCur )
{
if( *pCur == '\r' )
nLine++;
pCur++;
}
return nLine;
}
void CScanner::GetLastFull() // 현재부터 끝까지 한번에 읽는다.
{
// 앞쪽 white space를 스킵
while( iswhite( *m_pProg ) && *m_pProg && *m_pProg != '\r' )
++m_pProg;
char* pCur = token;
while( *m_pProg && *m_pProg!='\r' )
{
int count = CopyChar( m_pProg, pCur );
m_pProg += count;
pCur += count;
}
// 뒤쪽 white space를 스킵
if( pCur != token )
{
--pCur;
while( iswhite( *pCur ) && *pCur )
--pCur;
++pCur;
}
*pCur = '\0';
Token = token;
}
int CScanner::GetToken( BOOL bComma )
{
char* pszCur = m_mszToken;
*pszCur = '\0';
tokenType = TEMP;
tok = NONE_;
m_nDoubleOps = 0;
BOOL bLoop;
do
{
bLoop = FALSE;
while( iswhite( *m_pProg ) && *m_pProg ) // white space를 스킵
++m_pProg;
while(*m_pProg == '/') // 주석문 처리
{
++m_pProg;
if(*m_pProg == '/')
{
++m_pProg;
while(*m_pProg != '\r' && *m_pProg != '\0')
++m_pProg;
if(*m_pProg == '\r')
m_pProg+=2;
}
else if(*m_pProg == '*')
{
++m_pProg;
do
{
while(*m_pProg != '*' && *m_pProg != '\0')
++m_pProg;
if(*m_pProg == '\0')
{
tok = FINISHED;
tokenType = DELIMITER;
return tokenType;
}
++m_pProg;
}
while(*m_pProg != '/');
++m_pProg;
while(iswhite(*m_pProg) && *m_pProg)
++m_pProg;
}
else
{
--m_pProg;
break;
}
bLoop = TRUE; // 주석 끝 다시 loop시작
}
}
while( bLoop ) ;
// 화일의 끝
if(*m_pProg=='\0')
{
tok = FINISHED;
tokenType = DELIMITER;
goto EXIT;
}
// Comma 형식의 구분자인가?
if( bComma || m_bComma )
{
// 콤마나 데이타의 끝, 또는 엔터 코드가 나올 때까지 읽는다.
// 콤마 구분일 경우는 그것은 pszCur와 NUMBER만을 구분한다.
if(*m_pProg=='"')
{
++m_pProg;
while(*m_pProg != '"' && *m_pProg != '\r' && *m_pProg != '\0')
*pszCur++ = *m_pProg++;
++m_pProg;
tokenType = STRING;
}
else
{
while(*m_pProg!=',' && *m_pProg != '\r' && *m_pProg != '\0')
*pszCur++ = *m_pProg++;
}
if( *m_pProg == ',' || *m_pProg == '\r')
++m_pProg; // skim comma
// white space를 스킵
if( pszCur != token )
{
--pszCur;
while( iswhite( *pszCur ) && *pszCur )
--pszCur;
++pszCur;
if( isdigit2( token[0] ) )
tokenType = NUMBER;
if(token[0]=='0' && token[1]=='x')
tokenType = HEX;
}
goto EXIT;
}
//relation operator?
switch(*m_pProg)
{
case '=':
if(*(m_pProg+1)=='=')
{
*pszCur++ = *m_pProg++;
*pszCur++ = *m_pProg++;
m_nDoubleOps = EQ;
}
if(*token) { tokenType = DELIMITER; goto EXIT; }
break;
case '!':
if(*(m_pProg+1)=='=')
{
*pszCur++ = *m_pProg++;
*pszCur++ = *m_pProg++;
m_nDoubleOps = NE;
}
else
{
*pszCur++ = *m_pProg++;
m_nDoubleOps = NT;
}
if(*token) { tokenType = DELIMITER; goto EXIT; }
break;
case '<':
if(*(m_pProg+1)=='=')
{
*pszCur++ = *m_pProg++;
*pszCur++ = *m_pProg++;
m_nDoubleOps = LE;
}
else
{
*pszCur++ = *m_pProg++;
m_nDoubleOps = LT;
}
if(*token) { tokenType = DELIMITER; goto EXIT; }
break;
case '>':
if(*(m_pProg+1)=='=')
{
*pszCur++ = *m_pProg++;
*pszCur++ = *m_pProg++;
m_nDoubleOps = GE;
}
else
{
*pszCur++ = *m_pProg++;
m_nDoubleOps = GT;
}
if(*token) { tokenType = DELIMITER; goto EXIT; }
break;
}
// delimiter
if(*m_pProg == '&' && *(m_pProg+1) == '&')
{
*pszCur = *(pszCur+1) = '&';
pszCur+=2;
m_pProg+=2;
tokenType = DELIMITER;
goto EXIT;
}
if(*m_pProg == '|' && *(m_pProg+1) == '|')
{
*pszCur = *(pszCur+1) = '|';
pszCur+=2;
m_pProg+=2;
tokenType = DELIMITER;
goto EXIT;
}
if( strchr( "+-*^/%=;(),':{}.", *m_pProg ) )
{
*pszCur = *m_pProg;
++m_pProg;
++pszCur;
tokenType = DELIMITER;
goto EXIT;
}
// 스트링
if(*m_pProg=='"')
{
++m_pProg;
while( *m_pProg != '"' && *m_pProg != '\r' && *m_pProg != '\0' && ( pszCur - token ) < MAX_TOKENSTR )
{
int count = CopyChar( m_pProg, pszCur );
m_pProg += count;
pszCur += count;
}
++m_pProg;
tokenType = STRING;
if( *(m_pProg-1) != '"' )
{
if( *(m_pProg-1) == '\0' )
--m_pProg;
if( m_bErrorCheck )
{
CString string;
if( ( pszCur - token ) >= MAX_TOKENSTR )
string.Format( "line(%d) 파일 %s에서 \"%s\" 스트링 길이가 %d바이트를 초과했음.", GetLineNum(), m_strFileName, token, MAX_TOKENSTR );
else
string.Format( "line(%d) 파일 %s에서 \"%s\" 스트링이 따옴표로 끝나지 않음.", GetLineNum(), m_strFileName, token );
Error( string );
}
}
goto EXIT;
}
// hex
if( *m_pProg=='0' && *(m_pProg + 1)=='x' )
{
m_pProg+=2;
while(!isdelim(*m_pProg))
*pszCur++ = *m_pProg++;
tokenType = HEX;
goto EXIT;
}
// 숫자
if( isdigit2( *m_pProg ) && !IsMultiByte( m_pProg ) ) //숫자 검사만으로 끝나는데 왜 한글이 아닐 경우도 체크하지?
{
while( !isdelim( *m_pProg ) )
{
int count = CopyChar( m_pProg, pszCur );
m_pProg += count;
pszCur += count;
}
// while( !isdelim( *m_pProg ) )
// *pszCur++ = *m_pProg++;
tokenType = NUMBER;
goto EXIT;
}
// 변수와 명령
#ifdef __VS2003
if( iswalpha( *m_pProg ) || IsMultiByte( m_pProg ) || IsCyrillic( *m_pProg )
|| *m_pProg == '#' || *m_pProg == '_' || *m_pProg == '@' || *m_pProg=='$' || *m_pProg == '?' )
#else //__VS2003
if( isalpha( *m_pProg ) || IsMultiByte( m_pProg ) || IsCyrillic( *m_pProg )
|| *m_pProg == '#' || *m_pProg == '_' || *m_pProg == '@' || *m_pProg=='$' || *m_pProg == '?' )
#endif //__VS2003
{
while( !isdelim( *m_pProg ) )
{
int count = CopyChar( m_pProg, pszCur );
m_pProg += count;
pszCur += count;
}
}
else
{
/*
while( !isdelim( *m_pProg ) )
{
int count = CopyChar( m_pProg, pszCur );
m_pProg += count;
pszCur += count;
}
*/
*pszCur++ = *m_pProg++;
}
tokenType = TEMP;
EXIT:
*pszCur = '\0';
Token = token;
return tokenType;
}
int CScanner::GetNumber( BOOL bComma )
{
m_dwDef = 1;
if( GetToken( bComma ) == HEX )
{
Token.MakeLower();
DWORDLONG dwlNumber = 0;
DWORD dwMulCnt = 0;
CHAR cVal;
for( int i = Token.GetLength() - 1; i >= 0; i--)
{
cVal = Token[ i ];
if( cVal >= 'a' )
cVal = ( cVal - 'a' ) + 10;
else cVal -= '0';
dwlNumber |= (DWORDLONG) cVal << dwMulCnt;
dwMulCnt += 4;
}
m_dwDef = 0;
return (DWORD)dwlNumber;
}
else
if(!Token.IsEmpty())
{
switch(Token[0])
{
case '=':
m_dwDef = 0;
return NULL_ID;
case '-':
if( bComma == FALSE )
{
GetToken();
m_dwDef = 0;
return -atoi(Token);
}
else
{
m_dwDef = 0;
return atoi(Token);
}
case '+':
if( bComma == FALSE )
GetToken();
}
m_dwDef = 0;
return atoi(Token);
}
m_dwDef = 0;
return 0;
}
__int64 CScanner::GetInt64( BOOL bComma )
{
m_dwDef = 1;
if( GetToken( bComma ) == HEX )
{
}
else if( !Token.IsEmpty() )
{
switch( Token[0] )
{
case '=':
m_dwDef = 0;
return NULL_ID;
case '-':
if( bComma == FALSE )
{
GetToken();
m_dwDef = 0;
return -_atoi64( Token );
}
else
{
m_dwDef = 0;
return _atoi64( Token );
}
case '+':
if( bComma == FALSE )
GetToken();
}
m_dwDef = 0;
return _atoi64( Token );
}
m_dwDef = 0;
return (__int64)0;
}
FLOAT CScanner::GetFloat( BOOL bComma )
{
m_dwDef = 1;
GetToken( bComma );
if( !Token.IsEmpty() )
{
switch( Token[0] )
{
case '=':
m_dwDef = 0;
return -1;
case '-':
GetToken(bComma);
m_dwDef = 0;
return (FLOAT)-atof(Token);
case '+':
GetToken(bComma);
}
m_dwDef = 0;
return (FLOAT)atof(Token);
}
m_dwDef = 0;
return 0.0f;
}
DWORD CScanner::GetHex( BOOL bComma )
{
m_dwDef = 1;
if( GetToken( bComma ) == HEX )
{
Token.MakeLower();
DWORDLONG dwlNumber = 0;
DWORD dwMulCnt = 0;
CHAR cVal;
for( int i = Token.GetLength() - 1; i >= 0; i--)
{
cVal = Token[ i ];
if( cVal >= 'a' )
cVal = ( cVal - 'a' ) + 10;
else cVal -= '0';
dwlNumber |= (DWORDLONG) cVal << dwMulCnt;
dwMulCnt += 4;
}
m_dwDef = 0;
return (DWORD)dwlNumber;
}
m_dwDef = 0;
return 0;
}
void CScanner::PutBack()
{
for( CHAR *t = m_mszToken; *t; t++ )
m_pProg--;
if( tokenType == STRING ) // 따옴표 처리
m_pProg-=2;
}
SERIALNUMBER CScanner::GetSerialNumber( BOOL bComma )
{
return GetNumber( bComma );
}
| [
"[email protected]@e2c90bd7-ee55-cca0-76d2-bbf4e3699278"
]
| [
[
[
1,
1012
]
]
]
|
bca2ced746f877d8632fdd1a6ccdbd023e57787e | 6712f8313dd77ae820aaf400a5836a36af003075 | /jsText.cpp | 94e623bfd59151a73c47142a7e60c4567768c082 | []
| no_license | AdamTT1/bdScript | d83c7c63c2c992e516dca118cfeb34af65955c14 | 5483f239935ec02ad082666021077cbc74d1790c | refs/heads/master | 2021-12-02T22:57:35.846198 | 2010-08-08T22:32:02 | 2010-08-08T22:32:02 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 16,364 | cpp | /*
* Module jsText.cpp
*
* This module defines the initialization routine and
* JavaScript interpreter support routines for rendering
* text to the frame buffer device as described in
* jsText.h
*
* Change History :
*
* $Log: jsText.cpp,v $
* Revision 1.19 2004-05-05 03:17:42 ericn
* -removed unused render()
*
* Revision 1.18 2004/03/17 04:56:19 ericn
* -updates for mini-board (no sound, video, touch screen)
*
* Revision 1.17 2003/02/10 01:16:49 ericn
* -modified to allow truncation of text
*
* Revision 1.16 2003/02/09 02:58:52 ericn
* -moved font dump to ftObjs
*
* Revision 1.15 2003/02/07 03:01:33 ericn
* -made freeTypeLibrary_t internal and persistent
*
* Revision 1.14 2003/01/31 13:29:07 ericn
* -added getLineGap(), getHeight(), getBaseline()
*
* Revision 1.13 2003/01/03 16:57:00 ericn
* -removed jsText function
*
* Revision 1.13 2003/01/03 16:56:41 ericn
* -removed jsText function
*
* Revision 1.12 2002/12/15 20:01:09 ericn
* -modified to use JS_NewObject instead of js_NewObject
*
* Revision 1.11 2002/12/03 13:36:13 ericn
* -collapsed code and objects for curl transfers
*
* Revision 1.10 2002/11/30 16:26:50 ericn
* -better error checking, new curl interface
*
* Revision 1.9 2002/11/30 05:30:16 ericn
* -modified to expect call from default curl hander to app-specific
*
* Revision 1.8 2002/11/30 00:31:29 ericn
* -implemented in terms of ccActiveURL module
*
* Revision 1.7 2002/11/05 05:40:55 ericn
* -pre-declare font::isLoaded()
*
* Revision 1.6 2002/11/03 17:55:51 ericn
* -modified to support synchronous gets and posts
*
* Revision 1.5 2002/11/02 18:57:03 ericn
* -removed debug stuff
*
* Revision 1.4 2002/11/02 18:38:02 ericn
* -added font.render()
*
* Revision 1.3 2002/11/02 04:11:43 ericn
* -added font class
*
* Revision 1.2 2002/10/20 16:31:06 ericn
* -added bg color support
*
* Revision 1.1 2002/10/18 01:18:25 ericn
* -Initial import
*
*
* Copyright Boundary Devices, Inc. 2002
*/
#include "jsText.h"
#include "ftObjs.h"
#include <stdio.h>
#include "fbDev.h"
#include <ctype.h>
#include "jsCurl.h"
#include "js/jscntxt.h"
#include "jsGlobals.h"
#include "jsCurl.h"
#include "jsAlphaMap.h"
/*
static FT_Library library ;
static void initFreeType( void )
{
static bool _init = false ;
if( !_init )
{
int error = FT_Init_FreeType( &library );
if( 0 == error )
{
_init = true ;
// printf( "Initialized FreeType!\n" );
}
else
{
fprintf( stderr, "Error %d initializing freeType library\n", error );
exit( 3 );
}
}
}
*/
static JSBool
jsFontDump( JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval )
{
jsval dataVal ;
JSString *fontString ;
if( JS_GetProperty( cx, obj, "data", &dataVal )
&&
JSVAL_IS_STRING( dataVal )
&&
( 0 != ( fontString = JSVAL_TO_STRING( dataVal ) ) ) )
{
freeTypeFont_t font( JS_GetStringBytes( fontString ),
JS_GetStringLength( fontString ) );
if( font.worked() )
{
font.dump();
}
else
JS_ReportError( cx, "parsing font\n" );
}
else
JS_ReportError( cx, "reading font data property" );
*rval = JSVAL_TRUE ;
return JS_TRUE ;
}
static bool addRange( JSContext *cx,
JSObject *arrObj,
FT_ULong rangeStart,
FT_ULong rangeEnd )
{
jsuint numRanges ;
if( JS_GetArrayLength(cx, arrObj, &numRanges ) )
{
jsval range[2];
range[0] = INT_TO_JSVAL( rangeStart );
range[1] = INT_TO_JSVAL( rangeEnd );
if( JS_SetArrayLength( cx, arrObj, numRanges+1 ) )
{
JSObject *rangeObj = JS_NewArrayObject( cx, 2, range );
if( rangeObj )
{
if( JS_DefineElement( cx, arrObj, numRanges,
OBJECT_TO_JSVAL( rangeObj ),
0, 0,
JSPROP_ENUMERATE
|JSPROP_PERMANENT
|JSPROP_READONLY ) )
{
return true ;
}
else
JS_ReportError( cx, "Error adding array element" );
}
else
JS_ReportError( cx, "Error allocating new range" );
}
else
JS_ReportError( cx, "Error changing array length" );
}
return false ;
}
#define BADCHARCODE 0xFFFFaaaa
static JSBool
jsFontCharCodes( JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval )
{
*rval = JSVAL_FALSE ;
jsval dataVal ;
JSString *fontString ;
if( JS_GetProperty( cx, obj, "data", &dataVal )
&&
JSVAL_IS_STRING( dataVal )
&&
( 0 != ( fontString = JSVAL_TO_STRING( dataVal ) ) ) )
{
freeTypeFont_t font( JS_GetStringBytes( fontString ),
JS_GetStringLength( fontString ) );
if( font.worked() )
{
JSObject *arrObj = JS_NewArrayObject( cx, 0, 0 );
if( arrObj )
{
*rval = OBJECT_TO_JSVAL( arrObj );
FT_ULong startCharCode = BADCHARCODE ;
FT_ULong prevCharCode = BADCHARCODE ;
FT_UInt gindex;
FT_ULong charcode = FT_Get_First_Char( font.face_, &gindex );
while( gindex != 0 )
{
if( charcode != prevCharCode + 1 )
{
if( BADCHARCODE != prevCharCode )
{
if( !addRange( cx, arrObj, startCharCode, prevCharCode ) )
break;
}
startCharCode = prevCharCode = charcode ;
}
else
prevCharCode = charcode ;
charcode = FT_Get_Next_Char( font.face_, charcode, &gindex );
}
if( BADCHARCODE != prevCharCode )
addRange( cx, arrObj, startCharCode, prevCharCode );
}
else
JS_ReportError( cx, "allocating array" );
}
else
JS_ReportError( cx, "parsing font\n" );
}
else
JS_ReportError( cx, "reading font data property" );
return JS_TRUE ;
}
static JSBool
jsFontGetBaseline( JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval )
{
*rval = JSVAL_FALSE ;
int pointSize ;
if( ( 1 == argc )
&&
( 0 < ( pointSize = JSVAL_TO_INT( argv[0] ) ) ) )
{
jsval dataVal ;
JSString *fontString ;
if( JS_GetProperty( cx, obj, "data", &dataVal )
&&
JSVAL_IS_STRING( dataVal )
&&
( 0 != ( fontString = JSVAL_TO_STRING( dataVal ) ) ) )
{
freeTypeFont_t font( JS_GetStringBytes( fontString ),
JS_GetStringLength( fontString ) );
if( font.worked() )
{
if( 0 != font.face_->units_per_EM )
*rval = INT_TO_JSVAL( (pointSize * font.face_->ascender)/font.face_->units_per_EM );
else
*rval = INT_TO_JSVAL( (pointSize * font.face_->ascender) );
}
else
JS_ReportError( cx, "invalid font data" );
}
else
JS_ReportError( cx, "no font data" );
}
else
JS_ReportError( cx, "usage: font.getBaseline( pointSize )" );
return JS_TRUE ;
}
static JSBool
jsFontGetHeight( JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval )
{
*rval = JSVAL_FALSE ;
int pointSize ;
if( ( 1 == argc )
&&
( 0 < ( pointSize = JSVAL_TO_INT( argv[0] ) ) ) )
{
jsval dataVal ;
JSString *fontString ;
if( JS_GetProperty( cx, obj, "data", &dataVal )
&&
JSVAL_IS_STRING( dataVal )
&&
( 0 != ( fontString = JSVAL_TO_STRING( dataVal ) ) ) )
{
freeTypeFont_t font( JS_GetStringBytes( fontString ),
JS_GetStringLength( fontString ) );
if( font.worked() )
{
if( 0 != font.face_->units_per_EM )
*rval = INT_TO_JSVAL( (pointSize * font.face_->height)/font.face_->units_per_EM );
else
*rval = INT_TO_JSVAL( (pointSize * font.face_->height) );
}
else
JS_ReportError( cx, "invalid font data" );
}
else
JS_ReportError( cx, "no font data" );
}
else
JS_ReportError( cx, "usage: font.getHeight( pointSize )" );
return JS_TRUE ;
}
static JSBool
jsFontGetLinegap( JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval )
{
*rval = JSVAL_FALSE ;
int pointSize ;
if( ( 1 == argc )
&&
( 0 < ( pointSize = JSVAL_TO_INT( argv[0] ) ) ) )
{
jsval dataVal ;
JSString *fontString ;
if( JS_GetProperty( cx, obj, "data", &dataVal )
&&
JSVAL_IS_STRING( dataVal )
&&
( 0 != ( fontString = JSVAL_TO_STRING( dataVal ) ) ) )
{
freeTypeFont_t font( JS_GetStringBytes( fontString ),
JS_GetStringLength( fontString ) );
if( font.worked() )
{
if( 0 != font.face_->units_per_EM )
*rval = INT_TO_JSVAL( (pointSize *
( font.face_->height
- font.face_->ascender
+ font.face_->descender ) ) / font.face_->units_per_EM );
else
*rval = INT_TO_JSVAL( (pointSize *
( font.face_->height
- font.face_->ascender
+ font.face_->descender ) ) );
}
else
JS_ReportError( cx, "invalid font data" );
}
else
JS_ReportError( cx, "no font data" );
}
else
JS_ReportError( cx, "usage: font.getLineGap( pointSize )" );
return JS_TRUE ;
}
static JSBool
jsFontRender( JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval )
{
*rval = JSVAL_FALSE ;
if( ( 2 <= argc )
&&
( 3 >= argc )
&&
JSVAL_IS_INT( argv[0] )
&&
JSVAL_IS_STRING( argv[1] )
&&
( ( 2 == argc )
||
( JSVAL_IS_INT( argv[2] ) ) ) )
{
jsval dataVal ;
JSString *fontString ;
if( JS_GetProperty( cx, obj, "data", &dataVal )
&&
JSVAL_IS_STRING( dataVal )
&&
( 0 != ( fontString = JSVAL_TO_STRING( dataVal ) ) ) )
{
freeTypeFont_t font( JS_GetStringBytes( fontString ),
JS_GetStringLength( fontString ) );
if( font.worked() )
{
unsigned pointSize = JSVAL_TO_INT( argv[0] );
JSString *sParam = JSVAL_TO_STRING( argv[1] );
char const *renderString = JS_GetStringBytes( sParam );
unsigned const renderLen = JS_GetStringLength( sParam );
unsigned maxWidth = ( 3 == argc ) ? JSVAL_TO_INT( argv[2] ) : 0xFFFFFFFF ;
freeTypeString_t ftString( font, pointSize, renderString, renderLen, maxWidth );
JSObject *returnObj = JS_NewObject( cx, &jsAlphaMapClass_, 0, 0 );
if( returnObj )
{
*rval = OBJECT_TO_JSVAL( returnObj );
JSString *sAlphaMap = JS_NewStringCopyN( cx, (char const *)ftString.getRow(0), ftString.getDataLength() );
if( sAlphaMap )
{
JS_DefineProperty( cx, returnObj, "pixBuf", STRING_TO_JSVAL( sAlphaMap ), 0, 0, JSPROP_READONLY|JSPROP_ENUMERATE );
}
else
JS_ReportError( cx, "Error building alpha map string" );
JS_DefineProperty( cx, returnObj, "width", INT_TO_JSVAL(ftString.getWidth()), 0, 0, JSPROP_ENUMERATE );
JS_DefineProperty( cx, returnObj, "height", INT_TO_JSVAL(ftString.getHeight()), 0, 0, JSPROP_READONLY|JSPROP_ENUMERATE );
JS_DefineProperty( cx, returnObj, "baseline", INT_TO_JSVAL(ftString.getBaseline()), 0, 0, JSPROP_READONLY|JSPROP_ENUMERATE );
JS_DefineProperty( cx, returnObj, "yAdvance", INT_TO_JSVAL(ftString.getFontHeight()), 0, 0, JSPROP_READONLY|JSPROP_ENUMERATE );
}
else
JS_ReportError( cx, "allocating array" );
}
else
JS_ReportError( cx, "parsing font\n" );
}
else
JS_ReportError( cx, "reading font data property" );
}
else
JS_ReportError( cx, "Usage: font.render( pointSize, 'string' );" );
return JS_TRUE ;
}
static JSFunctionSpec fontMethods[] = {
{"dump", jsFontDump, 0 },
{"charCodes", jsFontCharCodes, 0 },
{"getBaseline", jsFontGetBaseline, 0 },
{"getHeight", jsFontGetHeight, 0 },
{"getLinegap", jsFontGetLinegap, 0 },
{"render", jsFontRender, 0 },
{0}
};
enum jsFont_tinyId {
FONT_ISLOADED,
FONT_DATA
};
extern JSClass jsFontClass_ ;
JSClass jsFontClass_ = {
"font",
JSCLASS_HAS_PRIVATE,
JS_PropertyStub, JS_PropertyStub, JS_PropertyStub, JS_PropertyStub,
JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub, JS_FinalizeStub,
JSCLASS_NO_OPTIONAL_MEMBERS
};
static JSPropertySpec fontProperties_[] = {
{0,0,0}
};
static void fontOnComplete( jsCurlRequest_t &req, void const *data, unsigned long size )
{
std::string sError ;
freeTypeFont_t font( data, size );
if( font.worked() )
{
JSString *fontString = JS_NewStringCopyN( req.cx_, (char const *)data, size );
if( fontString )
{
JS_DefineProperty( req.cx_, req.lhObj_, "data",
STRING_TO_JSVAL( fontString ),
0, 0,
JSPROP_ENUMERATE
|JSPROP_PERMANENT
|JSPROP_READONLY );
}
else
sError = "Error allocating font string" ;
}
else
sError = "Error loading font face" ;
if( 0 < sError.size() )
{
}
}
static JSBool font( JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval )
{
*rval = JSVAL_FALSE ;
if( ( 1 == argc )
&&
JSVAL_IS_OBJECT( argv[0] ) )
{
JSObject *thisObj = JS_NewObject( cx, &jsFontClass_, NULL, NULL );
if( thisObj )
{
*rval = OBJECT_TO_JSVAL( thisObj ); // root
if( queueCurlRequest( thisObj, argv[0], cx, fontOnComplete ) )
{
return JS_TRUE ;
}
else
{
JS_ReportError( cx, "Error queueing curlRequest" );
}
}
else
JS_ReportError( cx, "Error allocating curlFile" );
}
else
JS_ReportError( cx, "Usage : new font( { url:\"something\" [,useCache:true] [,onLoad=\"doSomething();\"][,onLoadError=\"somethingElse();\"] } );" );
return JS_TRUE ;
}
bool initJSText( JSContext *cx, JSObject *glob )
{
JSObject *rval = JS_InitClass( cx, glob, NULL, &jsFontClass_,
font, 1,
fontProperties_,
fontMethods,
0, 0 );
if( rval )
{
return true ;
}
return false ;
}
| [
"ericn",
"valli@valli-laptop.(none)"
]
| [
[
[
1,
414
],
[
416,
539
]
],
[
[
415,
415
]
]
]
|
7be1de227436d9e0278919e890fe7a8149cff94a | 7f6fe18cf018aafec8fa737dfe363d5d5a283805 | /ntk/interface/src/dc.cpp | 3a3e7ed57671b960bba05067c8aadefdcdd23b03 | []
| no_license | snori/ntk | 4db91d8a8fc836ca9a0dc2bc41b1ce767010d5ba | 86d1a32c4ad831e791ca29f5e7f9e055334e8fe7 | refs/heads/master | 2020-05-18T05:28:49.149912 | 2009-08-04T16:47:12 | 2009-08-04T16:47:12 | 268,861 | 2 | 0 | null | null | null | null | SHIFT_JIS | C++ | false | false | 32,552 | cpp | /******************************************************************************
The NTK Library
Copyright (C) 1998-2003 Noritaka Suzuki
$Id: dc.cpp,v 1.7 2003/11/17 09:59:30 nsuzuki Exp $
******************************************************************************/
#define NTK_BUILD
#include "ntk/interface/dc.h"
#include <assert.h>
#include <stack>
#include <boost/scoped_ptr.hpp>
#include <ntk/interface/Bitmap.h>
#include <ntk/support/status.h>
namespace ntk {
//########################################################
static const DDB&
default_bitmap_()
{
static boost::scoped_ptr<DDB> bitmap;
if(! bitmap)
bitmap.reset(new DDB(0, 0, 1, 8, NULL));
assert(bitmap->handle());
return *bitmap;
}
//########################################################
struct DCState {
//
// constants
//
enum Flag {
NON_STACKABLE,
FULL_STATE,
ONLY_ONE_OBJECT_BEGIN,
FONT_ONLY,
PEN_ONLY,
BRUSH_ONLY,
BITMAP_ONLY,
DRAWING_MODE_ONLY,
TEXT_COLOR_ONLY,
BACK_COLOR_ONLY,
BACK_MODE_ONLY,
TEXT_ALIGN_ONLY,
};
enum TextColor {TEXT_COLOR};
enum BackColor {BACK_COLOR};
enum BackMode {BACK_MODE};
enum TextAlign {TEXT_ALIGN};
Flag flag;
Font font;
Pen pen;
Brush brush;
DDB bitmap;
DC::DrawingMode drawing_mode;
RGBColor text_color, back_color;
int back_mode;
uint text_align;
DCState()
: flag(NON_STACKABLE)
, font(NULL, false)
, pen(NULL)
, brush(NULL)
, bitmap(NULL)
, drawing_mode(DC::OP_COPY)
, text_color(font_color())
, back_color(white_color())
, back_mode(0)
, text_align(0)// 最後の2つ、要再考
{}
DCState(
Font f,
Pen p,
Brush b,
DDB bmp,
DC::DrawingMode draw_mode,
const RGBColor& txt_col,
const RGBColor& bak_col,
int bk_mode,
uint txt_align)
: flag(FULL_STATE)
, font(f)
, pen(p)
, brush(b)
, bitmap(bmp)
, drawing_mode(draw_mode)
, text_color(txt_col)
, back_color(bak_col)
, back_mode(bk_mode)
, text_align(txt_align)
{}
DCState(Font f) : flag(FONT_ONLY), font(f), bitmap(default_bitmap_()) {}
DCState(Pen p) : flag(PEN_ONLY), pen(p), bitmap(default_bitmap_()) {}
DCState(Brush b) : flag(BRUSH_ONLY), brush(b), bitmap(default_bitmap_()) {}
DCState(GDIBitmap bmp) : flag(BITMAP_ONLY), bitmap(bmp) {}
DCState(DC::DrawingMode mode) : flag(DRAWING_MODE_ONLY), drawing_mode(mode), bitmap(default_bitmap_()) {}
DCState(const RGBColor& color, TextColor) : flag(TEXT_COLOR_ONLY), text_color(color), bitmap(default_bitmap_()) {}
DCState(const RGBColor& color, BackColor) : flag(BACK_COLOR_ONLY), back_color(color), bitmap(default_bitmap_()) {}
DCState(int mode, BackMode) : flag(BACK_MODE_ONLY), back_mode(mode), bitmap(default_bitmap_()) {}
DCState(uint align, TextAlign) : flag(TEXT_ALIGN_ONLY), text_align(align), bitmap(default_bitmap_()) {}
bool restore_state(DCBuffer* dc_buf) const;
};// class DCBuffer
//########################################################
class DCBuffer : public RefCountBuffer {
public:
//
// types
//
typedef std::stack<DCState*> StateStack;
//
// methods
//
DCBuffer(HWND hwnd_, DC::DestructionMethod method);
DCBuffer(HDC hdc_, DC::DestructionMethod method);
virtual ~DCBuffer();
void push_state();
bool pop_state();
void push_font() {state_stack()->push(new DCState(get_font()));}
bool pop_font();
void push_pen() {state_stack()->push(new DCState(get_pen()));}
bool pop_pen();
void push_brush() {state_stack()->push(new DCState(get_brush()));}
bool pop_brush();
void push_bitmap() {state_stack()->push(new DCState(get_bitmap()));}
bool pop_bitmap();
void push_drawing_mode() {state_stack()->push(new DCState(get_drawing_mode()));}
bool pop_drawing_mode();
void push_text_color() {state_stack()->push(new DCState(get_text_color(), DCState::TEXT_COLOR));}
bool pop_text_color();
void push_back_color() {state_stack()->push(new DCState(get_back_color(), DCState::BACK_COLOR));}
bool pop_back_color();
void push_back_mode() {state_stack()->push(new DCState(get_back_mode(), DCState::BACK_MODE));}
bool pop_back_mode();
void push_text_align() {state_stack()->push(new DCState(get_text_align(), DCState::TEXT_ALIGN));}
bool pop_text_align();
//
// accessors and manipulators
//
HWND hwnd() const {return m_hwnd;}
HDC hdc() const {return m_hdc;}
const Font& get_font() const;
Font set_font(const Font& font);
const Pen& get_pen() const;
Pen set_pen(const Pen& pen);
const Brush& get_brush() const;
Brush set_brush(const Brush& brush);
const DDB& get_bitmap() const;
DDB set_bitmap(const DDB& bitmap);
DC::DrawingMode get_drawing_mode() const {return m_current_state->drawing_mode;}
DC::DrawingMode set_drawing_mode(DC::DrawingMode mode)
{
if(mode == m_current_state->drawing_mode)
return m_current_state->drawing_mode;
DC::DrawingMode prev_mode = get_drawing_mode();
m_current_state->drawing_mode = mode;
uint op_code = 0;
switch(m_current_state->drawing_mode)
{
case DC::OP_COPY:
op_code = R2_COPYPEN;
break;
case DC::OP_INVERT:
op_code = R2_XORPEN;
break;
}
SetROP2(m_hdc, op_code);
return prev_mode;
}
const RGBColor& get_text_color() const {return m_current_state->text_color;}
RGBColor set_text_color(const RGBColor& color)
{
if(color == m_current_state->text_color)
return m_current_state->text_color;
RGBColor prev_color = get_text_color();
m_current_state->text_color = color;
SetTextColor(m_hdc, m_current_state->text_color.ref());
return prev_color;
}
const RGBColor& get_back_color() const {return m_current_state->text_color;}
RGBColor set_back_color(const RGBColor& color)
{
if(color == m_current_state->back_color)
return m_current_state->back_color;
RGBColor prev_color = get_back_color();
m_current_state->back_color = color;
SetBkColor(m_hdc, m_current_state->back_color.ref());
return prev_color;
}
int get_back_mode() const {return m_current_state->back_mode;}
int set_back_mode(int mode)
{
if(mode == m_current_state->back_mode)
return m_current_state->back_mode;
int prev_mode = get_back_mode();
m_current_state->back_mode = mode;
SetBkMode(m_hdc, m_current_state->back_mode);
return prev_mode;
}
uint get_text_align() const {return m_current_state->text_align;}
uint set_text_align(uint align)
{
if(align == m_current_state->text_align)
return m_current_state->text_align;
uint prev_align = get_text_align();
m_current_state->text_align = align;
SetTextAlign(m_hdc, m_current_state->text_align);
return prev_align;
}
StateStack* state_stack() {return state_stack_();}
const StateStack* state_stack() const {return m_state_stack;}
protected:
//
// methods
//
void finalize_gdi_objects();// all classes inherited from this class must call this method in thier destructor !!
//
// manipulators
//
void set_hdc(HDC hdc_)
{
m_hdc = hdc_;
if(m_hdc == NULL)
return;
set_font(plain_font());
set_text_color(font_color());
set_back_color(white_color());
set_back_mode(TRANSPARENT);
set_text_align(GetTextAlign(m_hdc));
}
private:
//
// data
//
HWND m_hwnd;
HDC m_hdc;
DC::DestructionMethod m_destruct_method;
DCState* m_current_state;
mutable StateStack* m_state_stack;
HFONT m_default_hfont;
HPEN m_default_hpen;
HBRUSH m_default_hbrush;
HBITMAP m_default_hbitmap;
//
// methods
//
HGDIOBJ select_object_(HGDIOBJ obj)
{
return SelectObject(m_hdc, obj);
}
StateStack* state_stack_() const
{
if(m_state_stack == NULL)
m_state_stack = new StateStack;
return m_state_stack;
}
};// class DCBuffer
class PaintDCBuffer : public DCBuffer {
public:
//
// methods
//
PaintDCBuffer(HWND hwnd_)
: DCBuffer((HDC)NULL, DC::DO_NOTHING),
m_hwnd(hwnd_)
{
BeginPaint(m_hwnd, &m_paint_struct);
set_hdc(m_paint_struct.hdc);
}
virtual ~PaintDCBuffer()
{
EndPaint(m_hwnd, &m_paint_struct);
}
const PAINTSTRUCT& paint_struct() const {return m_paint_struct;}
private:
//
// data
//
HWND m_hwnd;
PAINTSTRUCT m_paint_struct;
};// class PaintDCBuffer
//########################################################
// public methods
bool
DCState::restore_state(DCBuffer* dc_buf) const
{
assert(dc_buf);
assert(flag != NON_STACKABLE);
switch(flag)
{
case FULL_STATE:
dc_buf->set_font(font);
dc_buf->set_pen(pen);
dc_buf->set_brush(brush);
dc_buf->set_bitmap(bitmap);
dc_buf->set_drawing_mode(drawing_mode);
dc_buf->set_text_color(text_color);
dc_buf->set_back_color(back_color);
dc_buf->set_back_mode(back_mode);
dc_buf->set_text_align(text_align);
break;
case FONT_ONLY:
dc_buf->set_font(font);
break;
case PEN_ONLY:
dc_buf->set_pen(pen);
break;
case BRUSH_ONLY:
dc_buf->set_brush(brush);
break;
case BITMAP_ONLY:
dc_buf->set_bitmap(bitmap);
break;
case DRAWING_MODE_ONLY:
dc_buf->set_drawing_mode(drawing_mode);
break;
case TEXT_COLOR_ONLY:
dc_buf->set_text_color(text_color);
break;
case BACK_COLOR_ONLY:
dc_buf->set_back_color(back_color);
break;
case BACK_MODE_ONLY:
dc_buf->set_back_mode(back_mode);
break;
case TEXT_ALIGN_ONLY:
dc_buf->set_text_align(text_align);
break;
}
return true;
}
//########################################################
// public methods
inline
DCBuffer::DCBuffer(HWND hwnd_, DC::DestructionMethod method_)
: m_hwnd(hwnd_)
, m_hdc(NULL)
, m_destruct_method(method_)
, m_current_state(new DCState)
, m_state_stack(NULL)
, m_default_hfont(NULL)
, m_default_hpen(NULL)
, m_default_hbrush(NULL)
, m_default_hbitmap(NULL)
{
set_hdc(GetDC(hwnd_));
}
inline
DCBuffer::DCBuffer(HDC hdc_, DC::DestructionMethod method_)
: m_hwnd(NULL)
, m_hdc(NULL)
, m_destruct_method(method_)
, m_current_state(new DCState)
, m_state_stack(NULL)
, m_default_hfont(NULL)
, m_default_hpen(NULL)
, m_default_hbrush(NULL)
, m_default_hbitmap(NULL)
{
set_hdc(hdc_);
}
DCBuffer::~DCBuffer()
{
// 派生先のデストラクタでも呼ぼう！一度実行されたら二度目からは何もしないので安心していい。
finalize_gdi_objects();
// DESTRUCTION_METHOD によって DC の後処理の仕方を変える
// DO_NOTHING の時は何もしない
if(m_hdc)
{
if(m_destruct_method == DC::RELEASE_DC)
ReleaseDC(m_hwnd, m_hdc);
else if(m_destruct_method == DC::DELETE_DC)
DeleteDC(m_hdc);
m_hwnd = NULL;
m_hdc = NULL;
}
if(m_state_stack)
{
if(! m_state_stack->empty())
{
status_t(st::ERR,
"デバイスコンテキストのステートスタックが空ではありません。DC::pop_xxx() を忘れていませんか？\n"
).show_error();
while(! m_state_stack->empty())
{
delete m_state_stack->top();
m_state_stack->pop();
}
}
delete m_state_stack;
}
delete m_current_state;
}
inline void
DCBuffer::finalize_gdi_objects()
{
// 変更されていたら元に戻す
if(m_default_hfont)
{
select_object_(m_default_hfont);
m_default_hfont = NULL;
}
if(m_default_hpen)
{
select_object_(m_default_hpen);
m_default_hpen = NULL;
}
if(m_default_hbrush)
{
select_object_(m_default_hbrush);
m_default_hbrush = NULL;
}
if(m_default_hbitmap)
{
select_object_(m_default_hbitmap);
m_default_hbitmap = NULL;
}
}
inline void
DCBuffer::push_state()
{
state_stack()->push(
new DCState(
get_font(),
get_pen(),
get_brush(),
get_bitmap(),
get_drawing_mode(),
get_text_color(),
get_back_color(),
get_back_mode(),
get_text_align()));
}
inline bool
DCBuffer::pop_state()
{
if(m_state_stack == NULL || state_stack()->empty())
{
status_t(st::ERR, "DC::pop_state(): ステートスタックは空です。\n").show_error();
return false;
}
StateStack* stack = state_stack();
DCState* state;
do
{
state = stack->top();
stack->pop();
bool ret = state->restore_state(this);
delete state;
if(ret == false)
return false;
} while(stack->empty() == false && state->flag > DCState::ONLY_ONE_OBJECT_BEGIN);
return true;
}
inline bool
DCBuffer::pop_font()
{
DCState* state = state_stack()->top();
if(state->flag != DCState::FONT_ONLY)
return false;
state_stack()->pop();
bool ret = state->restore_state(this);
delete state;
return ret;
}
inline bool
DCBuffer::pop_pen()
{
DCState* state = state_stack()->top();
if(state->flag != DCState::PEN_ONLY)
return false;
state_stack()->pop();
bool ret = state->restore_state(this);
delete state;
return ret;
}
inline bool
DCBuffer::pop_brush()
{
DCState* state = state_stack()->top();
if(state->flag != DCState::BRUSH_ONLY)
return false;
state_stack()->pop();
bool ret = state->restore_state(this);
delete state;
return ret;
}
inline bool
DCBuffer::pop_bitmap()
{
DCState* state = state_stack()->top();
if(state->flag != DCState::BITMAP_ONLY)
return false;
state_stack()->pop();
bool ret = state->restore_state(this);
delete state;
return ret;
}
inline bool
DCBuffer::pop_drawing_mode()
{
DCState* state = state_stack()->top();
if(state->flag != DCState::DRAWING_MODE_ONLY)
return false;
state_stack()->pop();
bool ret = state->restore_state(this);
delete state;
return ret;
}
inline bool
DCBuffer::pop_text_color()
{
DCState* state = state_stack()->top();
if(state->flag != DCState::TEXT_COLOR_ONLY)
return false;
state_stack()->pop();
bool ret = state->restore_state(this);
delete state;
return ret;
}
inline bool
DCBuffer::pop_back_color()
{
DCState* state = state_stack()->top();
if(state->flag != DCState::BACK_COLOR_ONLY)
return false;
state_stack()->pop();
bool ret = state->restore_state(this);
delete state;
return ret;
}
inline bool
DCBuffer::pop_back_mode()
{
DCState* state = state_stack()->top();
if(state->flag != DCState::BACK_MODE_ONLY)
return false;
state_stack()->pop();
bool ret = state->restore_state(this);
delete state;
return ret;
}
inline bool
DCBuffer::pop_text_align()
{
DCState* state = state_stack()->top();
if(state->flag != DCState::TEXT_ALIGN_ONLY)
return false;
state_stack()->pop();
bool ret = state->restore_state(this);
delete state;
return ret;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// public accessors and manipulators
inline const Font&
DCBuffer::get_font() const
{
// 初めて呼ばれたとき
if(m_current_state->font.handle() == NULL)
{
DCBuffer* self = const_cast<DCBuffer*>(this);
// デフォルトハンドルを得る
HFONT default_handle = reinterpret_cast<HFONT>(
self->select_object_(plain_font().handle()));
// デフォルトハンドルを持った Font （ハンドルの所有権無し）を設定
self->m_current_state->font = Font(default_handle, false);
// HFONT を元に戻す
self->select_object_(default_handle);
}
return m_current_state->font;
}
inline Font
DCBuffer::set_font(const Font& font_)
{
if(font_.handle() == NULL)
return m_current_state->font;
if(font_ == m_current_state->font)
return m_current_state->font;
// m_current_state->font がユーザーによって設定されたオブジェクトなら
// 安全に削除できるようにデフォルトオブジェクトに戻しておく
if(m_default_hfont)
{
select_object_(m_default_hfont);
m_default_hfont = NULL;
}
Font prev_font = get_font();
// m_current_state->font に代入した時点で 元の m_current_state->font::handle()
// の所有者はいなくなり、ハンドルは削除される
if(font_.handle() == m_default_hfont)
{
m_current_state->font = Font(m_default_hfont, false);
}else{
m_current_state->font = font_;
m_default_hfont = reinterpret_cast<HFONT>(
select_object_(m_current_state->font.handle()));
}
return prev_font;
}
inline const Pen&
DCBuffer::get_pen() const
{
if(m_current_state->pen.handle() == NULL)
{
DCBuffer* self = const_cast<DCBuffer*>(this);
HPEN default_handle = reinterpret_cast<HPEN>(
self->select_object_(transparent_pen().handle()));
self->m_current_state->pen = Pen(default_handle, false);
self->select_object_(default_handle);
}
return m_current_state->pen;
}
inline Pen
DCBuffer::set_pen(const Pen& pen_)
{
if(pen_.handle() == NULL)
return m_current_state->pen;
if(pen_ == m_current_state->pen)
return m_current_state->pen;
if(m_default_hpen)
{
select_object_(m_default_hpen);
m_default_hpen = NULL;
}
Pen prev_pen = get_pen();
if(pen_.handle() == m_default_hpen)
{
m_current_state->pen = Pen(m_default_hpen, false);
}else{
m_current_state->pen = pen_;
m_default_hpen = reinterpret_cast<HPEN>(
select_object_(m_current_state->pen.handle()));
}
return prev_pen;
}
inline const Brush&
DCBuffer::get_brush() const
{
if(m_current_state->brush.handle() == NULL)
{
DCBuffer* self = const_cast<DCBuffer*>(this);
HBRUSH default_handle = reinterpret_cast<HBRUSH>(
self->select_object_(transparent_brush().handle()));
self->m_current_state->brush = Brush(default_handle, false);
self->select_object_(default_handle);
}
return m_current_state->brush;
}
inline Brush
DCBuffer::set_brush(const Brush& brush_)
{
if(brush_.handle() == NULL)
return m_current_state->brush;
if(brush_ == m_current_state->brush)
return m_current_state->brush;
if(m_default_hbrush)
{
select_object_(m_default_hbrush);
m_default_hbrush = NULL;
}
Brush prev_brush = get_brush();
if(brush_.handle() == m_default_hbrush)
{
m_current_state->brush = Brush(m_default_hbrush, false);
}else{
m_current_state->brush = brush_;
m_default_hbrush = reinterpret_cast<HBRUSH>(
select_object_(m_current_state->brush.handle()));
}
return prev_brush;
}
inline const DDB&
DCBuffer::get_bitmap() const
{
if(m_current_state->bitmap.handle() == NULL)
{
DCBuffer* self = const_cast<DCBuffer*>(this);
HBITMAP default_handle = reinterpret_cast<HBITMAP>(
self->select_object_(default_bitmap_().handle()));
self->m_current_state->bitmap = DDB(default_handle, false);
self->select_object_(default_handle);
}
return m_current_state->bitmap;
}
inline DDB
DCBuffer::set_bitmap(const DDB& bitmap_)
{
if(bitmap_.handle() == NULL)
return m_current_state->bitmap;
if(bitmap_ == m_current_state->bitmap)
return m_current_state->bitmap;
if(m_default_hbitmap)
{
select_object_(m_default_hbitmap);
m_default_hbitmap = NULL;
}
DDB prev_bitmap = get_bitmap();
if(bitmap_.handle() == m_default_hbitmap)
{
m_current_state->bitmap = DDB(m_default_hbitmap, false);
}else{
m_current_state->bitmap = bitmap_;
m_default_hbitmap = reinterpret_cast<HBITMAP>(
select_object_(m_current_state->bitmap.handle()));
}
return prev_bitmap;
}
//########################################################
// public methods
DC::DC(HWND hwnd_, DC::DestructionMethod method_)
: m_buffer(new DCBuffer(hwnd_, method_))
{
}
DC::DC(HDC hdc_, DC::DestructionMethod method_)
: m_buffer(new DCBuffer(hdc_, method_))
{
}
DC::DC(DCBuffer* buf)
: m_buffer(buf)
{
}
DC::~DC()
{
}
//--------------------------------------------------------
// state manipulators
void
DC::push_state()
{
m_buffer->push_state();
}
bool
DC::pop_state()
{
return m_buffer->pop_state();
}
const Font&
DC::font() const
{
return m_buffer->get_font();
}
Font
DC::set_font(const Font& font_)
{
return m_buffer->set_font(font_);
}
void
DC::push_font()
{
m_buffer->push_font();
}
void
DC::push_font(const Font& font_)
{
m_buffer->push_font();
m_buffer->set_font(font_);
}
bool
DC::pop_font()
{
return m_buffer->pop_font();
}
const Pen&
DC::pen() const
{
return m_buffer->get_pen();
}
Pen
DC::set_pen(const Pen& pen_)
{
return m_buffer->set_pen(pen_);
}
void
DC::push_pen()
{
m_buffer->push_pen();
}
void
DC::push_pen(const Pen& pen_)
{
m_buffer->push_pen();
m_buffer->set_pen(pen_);
}
bool
DC::pop_pen()
{
return m_buffer->pop_pen();
}
const Brush&
DC::brush() const
{
return m_buffer->get_brush();
}
Brush
DC::set_brush(const Brush& brush_)
{
return m_buffer->set_brush(brush_);
}
void
DC::push_brush()
{
m_buffer->push_brush();
}
void
DC::push_brush(const Brush& brush_)
{
m_buffer->push_brush();
m_buffer->set_brush(brush_);
}
bool
DC::pop_brush()
{
return m_buffer->pop_brush();
}
const DDB&
DC::bitmap() const
{
return m_buffer->get_bitmap();
}
DDB
DC::set_bitmap(const DDB& bitmap_)
{
return m_buffer->set_bitmap(bitmap_);
}
void
DC::push_bitmap()
{
m_buffer->push_bitmap();
}
void
DC::push_bitmap(const DDB& bitmap_)
{
m_buffer->push_bitmap();
m_buffer->set_bitmap(bitmap_);
}
bool
DC::pop_bitmap()
{
return m_buffer->pop_bitmap();
}
DC::DrawingMode
DC::drawing_mode() const
{
return m_buffer->get_drawing_mode();
}
DC::DrawingMode
DC::set_drawing_mode(DrawingMode mode)
{
return m_buffer->set_drawing_mode(mode);
}
void
DC::push_drawing_mode()
{
m_buffer->push_drawing_mode();
}
void
DC::push_drawing_mode(DC::DrawingMode mode_)
{
m_buffer->push_drawing_mode();
m_buffer->set_drawing_mode(mode_);
}
bool
DC::pop_drawing_mode()
{
return m_buffer->pop_drawing_mode();
}
const RGBColor&
DC::text_color() const
{
// assert(false);
return m_buffer->get_text_color();
}
RGBColor
DC::set_text_color(const RGBColor& color)
{
// assert(false);
return m_buffer->set_text_color(color);
}
void
DC::push_text_color()
{
m_buffer->push_text_color();
}
void
DC::push_text_color(const RGBColor& color_)
{
m_buffer->push_text_color();
m_buffer->set_text_color(color_);
}
bool
DC::pop_text_color()
{
return m_buffer->pop_text_color();
}
const RGBColor&
DC::back_color() const
{
return m_buffer->get_back_color();
}
RGBColor
DC::set_back_color(const RGBColor& color)
{
return m_buffer->set_back_color(color);
}
void
DC::push_back_color()
{
m_buffer->push_back_color();
}
void
DC::push_back_color(const RGBColor& color_)
{
m_buffer->push_back_color();
m_buffer->set_back_color(color_);
}
bool
DC::pop_back_color()
{
return m_buffer->pop_back_color();
}
int
DC::back_mode() const
{
return m_buffer->get_back_mode();
}
int
DC::set_back_mode(int mode)
{
return m_buffer->set_back_mode(mode);
}
void
DC::push_back_mode()
{
m_buffer->push_back_mode();
}
void
DC::push_back_mode(int mode_)
{
m_buffer->push_back_mode();
m_buffer->set_back_mode(mode_);
}
bool
DC::pop_back_mode()
{
return m_buffer->pop_back_mode();
}
uint
DC::text_align() const
{
return m_buffer->get_text_align();
}
uint
DC::set_text_align(uint val)
{
return m_buffer->set_text_align(val);
}
void
DC::push_text_align()
{
m_buffer->push_text_align();
}
void
DC::push_text_align(uint align_)
{
m_buffer->push_text_align();
m_buffer->set_text_align(align_);
}
bool
DC::pop_text_align()
{
return m_buffer->pop_text_align();
}
Region
DC::clipping_region() const
{
Region rgn;
GetClipRgn(hdc(), rgn.handle());
return rgn;
}
void
DC::constrain_clipping_region(const Region& region)
{
SelectClipRgn(hdc(), region.handle());
}
void
DC::clear_clipping_region()
{
SelectClipRgn(hdc(), NULL);
}
//--------------------------------------------------------
// drawing methods
Point
DC::move_to(coord x, coord y)
{
Point prev_point;
MoveToEx(hdc(), x, y, &prev_point);
return prev_point;
}
void
DC::draw_string(const String& str)
{
draw_string(str, current_point());
}
void
DC::draw_string(const String& str, uint length)
{
String tmp(str.c_str(), length);
draw_string(tmp, current_point());
}
void
DC::draw_string(const String& str, const Point& point)
{
#if 1
text_out(point, str);
#else
coord str_height = string_height();
String tmp(str.c_str());// c_str()で渡してコピーを作る。そうしないと参照カウンタが増えるだけ
Point current_pnt = point;
char_t *p, *begin = tmp.begin(), *end = tmp.end();// char
p = begin;
for(; p != end; ++p)
if(*p == '\n')
{
*p = '\0';// いったん文字列を切る
text_out(current_pnt, begin);
*p = '\n';// 元に戻す
begin = p +1;// 次の行の最初
current_pnt.y += str_height;
}
// 改行文字はなかった
if(begin == tmp.begin())
text_out(current_pnt, tmp);
#endif
}
void
DC::draw_string(const String& str, uint length, const Point& point)
{
String tmp(str.c_str(), length);
draw_string(tmp, point);
}
void
DC::stroke_line(coord x1, coord y1, coord x2, coord y2)
{
move_to(x1, y1);
line_to(x2, y2);
}
void
DC::stroke_rect(coord l, coord t, coord r, coord b)
{
Brush prev_brush = set_brush(transparent_brush());
Rectangle(hdc(), l, t, r, b);
set_brush(prev_brush);
}
void
DC::stroke_round_rect(coord l, coord t, coord r, coord b, coord width, coord height)
{
Brush prev_brush = set_brush(transparent_brush());
RoundRect(hdc(), l, t, r, b, width, height);
set_brush(prev_brush);
}
void
DC::fill_rect(coord l, coord t, coord r, coord b)
{
Pen prev_pen = set_pen(transparent_pen());
Rectangle(hdc(), l, t, r +1, b +1);
set_pen(prev_pen);
}
void
DC::fill_round_rect(coord l, coord t, coord r, coord b, coord width, coord height)
{
Pen prev_pen = set_pen(transparent_pen());
RoundRect(hdc(), l, t, r +1, b +1, width, height);
set_pen(prev_pen);
}
void
DC::stroke_ellipse(const Point& center, coord h_radius, coord v_radius)
{
Brush prev_brush = set_brush(transparent_brush());
Ellipse(
hdc(),
center.x - h_radius,
center.y - v_radius,
center.x + h_radius,
center.y + v_radius);
set_brush(prev_brush);
}
void
DC::stroke_ellipse(coord l, coord t, coord r, coord b)
{
Brush prev_brush = set_brush(transparent_brush());
Ellipse(hdc(), l, t, r, b);
set_brush(prev_brush);
}
void
DC::fill_ellipse(const Point& center, coord h_radius, coord v_radius)
{
Pen prev_pen = set_pen(transparent_pen());
Ellipse(
hdc(),
center.x - h_radius,
center.y - v_radius,
center.x + h_radius,
center.y + v_radius);
set_pen(prev_pen);
}
void
DC::fill_ellipse(coord l, coord t, coord r, coord b)
{
Pen prev_pen = set_pen(transparent_pen());
Ellipse(hdc(), l, t, r, b);
set_pen(prev_pen);
}
void
DC::stroke_polygon(const Point* point_list, uint num_of_points)
{
// Brush prev_brush = set_brush(transparent_brush());
Polyline(hdc(), point_list, num_of_points);
// set_brush(prev_brush);
}
void
DC::fill_polygon(const Point* point_list, uint num_of_points)
{
Pen prev_pen = set_pen(transparent_pen());
Polygon(hdc(), point_list, num_of_points);
set_pen(prev_pen);
}
void
DC::draw_bitmap(const Bitmap& bitmap)
{
Point point = current_point();
BitBlt(
hdc(),
point.x,
point.y,
bitmap.width(),
bitmap.height(),
bitmap.dc(),
0,
0,
SRCCOPY);
}
void
DC::draw_bitmap(const Bitmap& bitmap, const Point& point)
{
BitBlt(
hdc(),
point.x,
point.y,
bitmap.width(),
bitmap.height(),
bitmap.dc(),
0,
0,
SRCCOPY);
}
void
DC::draw_bitmap(const Bitmap& bitmap, const Rect& rect)
{
if(rect.width() == bitmap.width() && rect.height() == bitmap.height())
BitBlt(
hdc(),
rect.left,
rect.top,
rect.width(),
rect.height(),
bitmap.dc(),
0,
0,
SRCCOPY);
else
StretchBlt(
hdc(),
rect.left,
rect.top,
rect.width(),
rect.height(),
bitmap.dc(),
0,
0,
bitmap.width(),
bitmap.height(),
SRCCOPY);
}
void
DC::draw_bitmap(const Bitmap& bitmap, const Rect& dest, const Rect& src)
{
if(dest.width() == src.width() && dest.height() == src.height())
BitBlt(
hdc(),
dest.left,
dest.top,
dest.width(),
dest.height(),
bitmap.dc(),
src.left,
src.top,
SRCCOPY);
else
StretchBlt(
hdc(),
dest.left,
dest.top,
dest.right,
dest.bottom,
bitmap.dc(),
src.left,
src.top,
src.width(),
src.height(),
SRCCOPY);
}
//--------------------------------------------------------
// win32 drawing methods
void
DC::text_out(coord x, coord y, const String& text)
{
TextOut(
hdc(),
x,
y,
text.c_str(),
text.length());
}
void
DC::draw_text(const Rect& rect, const String& text, uint format)
{
DrawText(
hdc(),
text.c_str(),
text.length(),
static_cast<RECT*>(const_cast<Rect*>(&rect)),// これはどうなんだろ、普通に (RECT*)&rect, とやったほうがよいかも…
format);
}
Rect
DC::calculate_rect(const String& text)
{
Rect rect;
DrawText(
hdc(),
text.c_str(),
text.length(),
&rect,
DT_CALCRECT);
return rect;
}
void
DC::line_to(coord x, coord y)
{
LineTo(hdc(), x, y);
}
void
DC::bit_blt(coord dest_x, coord dest_y, coord dest_width, coord dest_height, DC& src_dc, coord src_x, coord src_y, uint op_code)
{
BitBlt(
hdc(),
dest_x,
dest_y,
dest_width,
dest_height,
src_dc,
src_x,
src_y,
op_code);
}
void
DC::bit_blt(const Rect& dest_rect, DC& src_dc, const Point& src_point, uint op_code)
{
BitBlt(
hdc(),
dest_rect.left,
dest_rect.top,
dest_rect.width(),
dest_rect.height(),
src_dc,
src_point.x,
src_point.y,
op_code);
}
void
DC::pat_blt(coord dest_x, coord dest_y, coord dest_width, coord dest_height, uint op_code)
{
PatBlt(
hdc(),
dest_x,
dest_y,
dest_width,
dest_height,
op_code);
}
void
DC::pat_blt(const Rect& dest_rect, uint op_code)
{
PatBlt(
hdc(),
dest_rect.left,
dest_rect.top,
dest_rect.width(),
dest_rect.height(),
op_code);
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// public aacessors
HWND
DC::hwnd() const
{
return m_buffer->hwnd();
}
HDC
DC::hdc() const
{
return m_buffer->hdc();
}
Point
DC::current_point() const
{
Point point;
MoveToEx(hdc(), 0, 0, &point);
MoveToEx(hdc(), point.x, point.y, NULL);
return point;
}
coord
DC::string_width(const String& str, int length) const
{
if(length < 0)
length = str.length();
SIZE size;
GetTextExtentPoint32(hdc(), str.c_str(), length, &size);
return size.cx;
}
coord
DC::string_height() const
{
#if 1
SIZE size;
GetTextExtentPoint32(hdc(), "lj", 2, &size);
return size.cy;
#else
TEXTMETRIC tm;
GetTextMetrics(hdc(), &tm);
return tm.tmAscent;
#endif
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// public operators
DC::operator HDC() const
{
return hdc();
}
//########################################################
// public methods
PaintDC::PaintDC(HWND hwnd)
: DC(new PaintDCBuffer(hwnd))
{
}
PaintDC::~PaintDC()
{
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// public accessors
Rect
PaintDC::update_rect() const
{
return static_cast<const PaintDCBuffer*>(buffer())->paint_struct().rcPaint;
}
bool
PaintDC::erase() const
{
return to_bool(static_cast<const PaintDCBuffer*>(buffer())->paint_struct().fErase);
}
//########################################################
// public methods
MemoryDC::MemoryDC(HDC hdc)
: DC(CreateCompatibleDC(hdc), DC::DELETE_DC)
{
}
MemoryDC::~MemoryDC()
{
}
//########################################################
// public methods
ScreenDC::ScreenDC()
: DC(CreateDC("DISPLAY", NULL, NULL, NULL), DC::DELETE_DC)
{
}
ScreenDC::~ScreenDC()
{
}
//########################################################
}// namespace ntk
| [
"[email protected]"
]
| [
[
[
1,
1736
]
]
]
|
14b05a3dff095fe773cab980c88717033d96c828 | d882fb01057dce320a56a978b9a3c0af6cc937ea | /surface_reconstruction/surface_reconstruction/GLee.cpp | 4c55628ac516461986946bb99cf7b29e7a53091f | []
| no_license | hksonngan/arraypointsprocessingproject | 6e63240e80ea027324be37a78a44213ec26ba558 | 5dbe48207672e97a3697e567d6fe89d136165183 | refs/heads/master | 2021-01-10T10:04:51.318928 | 2011-02-27T11:50:08 | 2011-02-27T11:50:08 | 46,898,830 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,105,266 | cpp | /***************************************************************************
*
* GLee.c
* GLee (OpenGL Easy Extension library)
* Version : 5.4
*
* Copyright (c)2009 Ben Woodhouse All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer as
* the first lines of this file unmodified.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY BEN WOODHOUSE ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL BEN WOODHOUSE BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
* Web: http://elf-stone.com/glee.php
*
* [This file was automatically generated by GLeeGen 7.0
*
***************************************************************************/
#include "stdafx.h"
#ifdef _MSC_VER
#pragma optimize( "g", off )
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "GLee.h"
#if defined(__APPLE__) || defined(__APPLE_CC__)
#include <Carbon/Carbon.h>
#endif
typedef GLuint(*GLEE_LINK_FUNCTION)(void);
GLboolean __GLeeInited=GL_FALSE;
#ifndef _WIN32
#define __stdcall /* nothing */
#endif
void * __GLeeGetProcAddress(const char *extname)
{
#ifdef WIN32
return (void*)wglGetProcAddress(extname);
#elif defined(__APPLE__) || defined(__APPLE_CC__)
CFBundleRef bundle;
CFURLRef bundleURL = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, CFSTR("/System/Library/Frameworks/OpenGL.framework"), kCFURLPOSIXPathStyle, true);
CFStringRef functionName = CFStringCreateWithCString(kCFAllocatorDefault, extname, kCFStringEncodingASCII);
void *function;
bundle = CFBundleCreate(kCFAllocatorDefault, bundleURL);
assert(bundle != NULL);
function = CFBundleGetFunctionPointerForName(bundle, functionName);
CFRelease(bundleURL);
CFRelease(functionName);
CFRelease(bundle);
return function;
#else
return (void*)glXGetProcAddressARB((const GLubyte *)extname);
#endif
}
/* Extension querying variables */
GLboolean _GLEE_VERSION_1_2 = GL_FALSE;
GLboolean _GLEE_ARB_imaging = GL_FALSE;
GLboolean _GLEE_VERSION_1_3 = GL_FALSE;
GLboolean _GLEE_VERSION_1_4 = GL_FALSE;
GLboolean _GLEE_VERSION_1_5 = GL_FALSE;
GLboolean _GLEE_VERSION_2_0 = GL_FALSE;
GLboolean _GLEE_VERSION_2_1 = GL_FALSE;
GLboolean _GLEE_VERSION_3_0 = GL_FALSE;
GLboolean _GLEE_ARB_multitexture = GL_FALSE;
GLboolean _GLEE_ARB_transpose_matrix = GL_FALSE;
GLboolean _GLEE_ARB_multisample = GL_FALSE;
GLboolean _GLEE_ARB_texture_env_add = GL_FALSE;
GLboolean _GLEE_ARB_texture_cube_map = GL_FALSE;
GLboolean _GLEE_ARB_texture_compression = GL_FALSE;
GLboolean _GLEE_ARB_texture_border_clamp = GL_FALSE;
GLboolean _GLEE_ARB_point_parameters = GL_FALSE;
GLboolean _GLEE_ARB_vertex_blend = GL_FALSE;
GLboolean _GLEE_ARB_matrix_palette = GL_FALSE;
GLboolean _GLEE_ARB_texture_env_combine = GL_FALSE;
GLboolean _GLEE_ARB_texture_env_crossbar = GL_FALSE;
GLboolean _GLEE_ARB_texture_env_dot3 = GL_FALSE;
GLboolean _GLEE_ARB_texture_mirrored_repeat = GL_FALSE;
GLboolean _GLEE_ARB_depth_texture = GL_FALSE;
GLboolean _GLEE_ARB_shadow = GL_FALSE;
GLboolean _GLEE_ARB_shadow_ambient = GL_FALSE;
GLboolean _GLEE_ARB_window_pos = GL_FALSE;
GLboolean _GLEE_ARB_vertex_program = GL_FALSE;
GLboolean _GLEE_ARB_fragment_program = GL_FALSE;
GLboolean _GLEE_ARB_vertex_buffer_object = GL_FALSE;
GLboolean _GLEE_ARB_occlusion_query = GL_FALSE;
GLboolean _GLEE_ARB_shader_objects = GL_FALSE;
GLboolean _GLEE_ARB_vertex_shader = GL_FALSE;
GLboolean _GLEE_ARB_fragment_shader = GL_FALSE;
GLboolean _GLEE_ARB_shading_language_100 = GL_FALSE;
GLboolean _GLEE_ARB_texture_non_power_of_two = GL_FALSE;
GLboolean _GLEE_ARB_point_sprite = GL_FALSE;
GLboolean _GLEE_ARB_fragment_program_shadow = GL_FALSE;
GLboolean _GLEE_ARB_draw_buffers = GL_FALSE;
GLboolean _GLEE_ARB_texture_rectangle = GL_FALSE;
GLboolean _GLEE_ARB_color_buffer_float = GL_FALSE;
GLboolean _GLEE_ARB_half_float_pixel = GL_FALSE;
GLboolean _GLEE_ARB_texture_float = GL_FALSE;
GLboolean _GLEE_ARB_pixel_buffer_object = GL_FALSE;
GLboolean _GLEE_ARB_depth_buffer_float = GL_FALSE;
GLboolean _GLEE_ARB_draw_instanced = GL_FALSE;
GLboolean _GLEE_ARB_framebuffer_object = GL_FALSE;
GLboolean _GLEE_ARB_framebuffer_sRGB = GL_FALSE;
GLboolean _GLEE_ARB_geometry_shader4 = GL_FALSE;
GLboolean _GLEE_ARB_half_float_vertex = GL_FALSE;
GLboolean _GLEE_ARB_instanced_arrays = GL_FALSE;
GLboolean _GLEE_ARB_map_buffer_range = GL_FALSE;
GLboolean _GLEE_ARB_texture_buffer_object = GL_FALSE;
GLboolean _GLEE_ARB_texture_compression_rgtc = GL_FALSE;
GLboolean _GLEE_ARB_texture_rg = GL_FALSE;
GLboolean _GLEE_ARB_vertex_array_object = GL_FALSE;
GLboolean _GLEE_EXT_abgr = GL_FALSE;
GLboolean _GLEE_EXT_blend_color = GL_FALSE;
GLboolean _GLEE_EXT_polygon_offset = GL_FALSE;
GLboolean _GLEE_EXT_texture = GL_FALSE;
GLboolean _GLEE_EXT_texture3D = GL_FALSE;
GLboolean _GLEE_SGIS_texture_filter4 = GL_FALSE;
GLboolean _GLEE_EXT_subtexture = GL_FALSE;
GLboolean _GLEE_EXT_copy_texture = GL_FALSE;
GLboolean _GLEE_EXT_histogram = GL_FALSE;
GLboolean _GLEE_EXT_convolution = GL_FALSE;
GLboolean _GLEE_SGI_color_matrix = GL_FALSE;
GLboolean _GLEE_SGI_color_table = GL_FALSE;
GLboolean _GLEE_SGIS_pixel_texture = GL_FALSE;
GLboolean _GLEE_SGIX_pixel_texture = GL_FALSE;
GLboolean _GLEE_SGIS_texture4D = GL_FALSE;
GLboolean _GLEE_SGI_texture_color_table = GL_FALSE;
GLboolean _GLEE_EXT_cmyka = GL_FALSE;
GLboolean _GLEE_EXT_texture_object = GL_FALSE;
GLboolean _GLEE_SGIS_detail_texture = GL_FALSE;
GLboolean _GLEE_SGIS_sharpen_texture = GL_FALSE;
GLboolean _GLEE_EXT_packed_pixels = GL_FALSE;
GLboolean _GLEE_SGIS_texture_lod = GL_FALSE;
GLboolean _GLEE_SGIS_multisample = GL_FALSE;
GLboolean _GLEE_EXT_rescale_normal = GL_FALSE;
GLboolean _GLEE_EXT_vertex_array = GL_FALSE;
GLboolean _GLEE_EXT_misc_attribute = GL_FALSE;
GLboolean _GLEE_SGIS_generate_mipmap = GL_FALSE;
GLboolean _GLEE_SGIX_clipmap = GL_FALSE;
GLboolean _GLEE_SGIX_shadow = GL_FALSE;
GLboolean _GLEE_SGIS_texture_edge_clamp = GL_FALSE;
GLboolean _GLEE_SGIS_texture_border_clamp = GL_FALSE;
GLboolean _GLEE_EXT_blend_minmax = GL_FALSE;
GLboolean _GLEE_EXT_blend_subtract = GL_FALSE;
GLboolean _GLEE_EXT_blend_logic_op = GL_FALSE;
GLboolean _GLEE_SGIX_interlace = GL_FALSE;
GLboolean _GLEE_SGIX_pixel_tiles = GL_FALSE;
GLboolean _GLEE_SGIS_texture_select = GL_FALSE;
GLboolean _GLEE_SGIX_sprite = GL_FALSE;
GLboolean _GLEE_SGIX_texture_multi_buffer = GL_FALSE;
GLboolean _GLEE_EXT_point_parameters = GL_FALSE;
GLboolean _GLEE_SGIS_point_parameters = GL_FALSE;
GLboolean _GLEE_SGIX_instruments = GL_FALSE;
GLboolean _GLEE_SGIX_texture_scale_bias = GL_FALSE;
GLboolean _GLEE_SGIX_framezoom = GL_FALSE;
GLboolean _GLEE_SGIX_tag_sample_buffer = GL_FALSE;
GLboolean _GLEE_FfdMaskSGIX = GL_FALSE;
GLboolean _GLEE_SGIX_polynomial_ffd = GL_FALSE;
GLboolean _GLEE_SGIX_reference_plane = GL_FALSE;
GLboolean _GLEE_SGIX_flush_raster = GL_FALSE;
GLboolean _GLEE_SGIX_depth_texture = GL_FALSE;
GLboolean _GLEE_SGIS_fog_function = GL_FALSE;
GLboolean _GLEE_SGIX_fog_offset = GL_FALSE;
GLboolean _GLEE_HP_image_transform = GL_FALSE;
GLboolean _GLEE_HP_convolution_border_modes = GL_FALSE;
GLboolean _GLEE_INGR_palette_buffer = GL_FALSE;
GLboolean _GLEE_SGIX_texture_add_env = GL_FALSE;
GLboolean _GLEE_EXT_color_subtable = GL_FALSE;
GLboolean _GLEE_PGI_vertex_hints = GL_FALSE;
GLboolean _GLEE_PGI_misc_hints = GL_FALSE;
GLboolean _GLEE_EXT_paletted_texture = GL_FALSE;
GLboolean _GLEE_EXT_clip_volume_hint = GL_FALSE;
GLboolean _GLEE_SGIX_list_priority = GL_FALSE;
GLboolean _GLEE_SGIX_ir_instrument1 = GL_FALSE;
GLboolean _GLEE_SGIX_calligraphic_fragment = GL_FALSE;
GLboolean _GLEE_SGIX_texture_lod_bias = GL_FALSE;
GLboolean _GLEE_SGIX_shadow_ambient = GL_FALSE;
GLboolean _GLEE_EXT_index_texture = GL_FALSE;
GLboolean _GLEE_EXT_index_material = GL_FALSE;
GLboolean _GLEE_EXT_index_func = GL_FALSE;
GLboolean _GLEE_EXT_index_array_formats = GL_FALSE;
GLboolean _GLEE_EXT_compiled_vertex_array = GL_FALSE;
GLboolean _GLEE_EXT_cull_vertex = GL_FALSE;
GLboolean _GLEE_SGIX_ycrcb = GL_FALSE;
GLboolean _GLEE_SGIX_fragment_lighting = GL_FALSE;
GLboolean _GLEE_IBM_rasterpos_clip = GL_FALSE;
GLboolean _GLEE_HP_texture_lighting = GL_FALSE;
GLboolean _GLEE_EXT_draw_range_elements = GL_FALSE;
GLboolean _GLEE_WIN_phong_shading = GL_FALSE;
GLboolean _GLEE_WIN_specular_fog = GL_FALSE;
GLboolean _GLEE_EXT_light_texture = GL_FALSE;
GLboolean _GLEE_SGIX_blend_alpha_minmax = GL_FALSE;
GLboolean _GLEE_SGIX_impact_pixel_texture = GL_FALSE;
GLboolean _GLEE_EXT_bgra = GL_FALSE;
GLboolean _GLEE_SGIX_async = GL_FALSE;
GLboolean _GLEE_SGIX_async_pixel = GL_FALSE;
GLboolean _GLEE_SGIX_async_histogram = GL_FALSE;
GLboolean _GLEE_INTEL_texture_scissor = GL_FALSE;
GLboolean _GLEE_INTEL_parallel_arrays = GL_FALSE;
GLboolean _GLEE_HP_occlusion_test = GL_FALSE;
GLboolean _GLEE_EXT_pixel_transform = GL_FALSE;
GLboolean _GLEE_EXT_pixel_transform_color_table = GL_FALSE;
GLboolean _GLEE_EXT_shared_texture_palette = GL_FALSE;
GLboolean _GLEE_EXT_separate_specular_color = GL_FALSE;
GLboolean _GLEE_EXT_secondary_color = GL_FALSE;
GLboolean _GLEE_EXT_texture_perturb_normal = GL_FALSE;
GLboolean _GLEE_EXT_multi_draw_arrays = GL_FALSE;
GLboolean _GLEE_EXT_fog_coord = GL_FALSE;
GLboolean _GLEE_REND_screen_coordinates = GL_FALSE;
GLboolean _GLEE_EXT_coordinate_frame = GL_FALSE;
GLboolean _GLEE_EXT_texture_env_combine = GL_FALSE;
GLboolean _GLEE_APPLE_specular_vector = GL_FALSE;
GLboolean _GLEE_APPLE_transform_hint = GL_FALSE;
GLboolean _GLEE_SGIX_fog_scale = GL_FALSE;
GLboolean _GLEE_SUNX_constant_data = GL_FALSE;
GLboolean _GLEE_SUN_global_alpha = GL_FALSE;
GLboolean _GLEE_SUN_triangle_list = GL_FALSE;
GLboolean _GLEE_SUN_vertex = GL_FALSE;
GLboolean _GLEE_EXT_blend_func_separate = GL_FALSE;
GLboolean _GLEE_INGR_color_clamp = GL_FALSE;
GLboolean _GLEE_INGR_interlace_read = GL_FALSE;
GLboolean _GLEE_EXT_stencil_wrap = GL_FALSE;
GLboolean _GLEE_EXT_422_pixels = GL_FALSE;
GLboolean _GLEE_NV_texgen_reflection = GL_FALSE;
GLboolean _GLEE_EXT_texture_cube_map = GL_FALSE;
GLboolean _GLEE_SUN_convolution_border_modes = GL_FALSE;
GLboolean _GLEE_EXT_texture_env_add = GL_FALSE;
GLboolean _GLEE_EXT_texture_lod_bias = GL_FALSE;
GLboolean _GLEE_EXT_texture_filter_anisotropic = GL_FALSE;
GLboolean _GLEE_EXT_vertex_weighting = GL_FALSE;
GLboolean _GLEE_NV_light_max_exponent = GL_FALSE;
GLboolean _GLEE_NV_vertex_array_range = GL_FALSE;
GLboolean _GLEE_NV_register_combiners = GL_FALSE;
GLboolean _GLEE_NV_fog_distance = GL_FALSE;
GLboolean _GLEE_NV_texgen_emboss = GL_FALSE;
GLboolean _GLEE_NV_blend_square = GL_FALSE;
GLboolean _GLEE_NV_texture_env_combine4 = GL_FALSE;
GLboolean _GLEE_MESA_resize_buffers = GL_FALSE;
GLboolean _GLEE_MESA_window_pos = GL_FALSE;
GLboolean _GLEE_EXT_texture_compression_s3tc = GL_FALSE;
GLboolean _GLEE_IBM_cull_vertex = GL_FALSE;
GLboolean _GLEE_IBM_multimode_draw_arrays = GL_FALSE;
GLboolean _GLEE_IBM_vertex_array_lists = GL_FALSE;
GLboolean _GLEE_SGIX_subsample = GL_FALSE;
GLboolean _GLEE_SGIX_ycrcb_subsample = GL_FALSE;
GLboolean _GLEE_SGIX_ycrcba = GL_FALSE;
GLboolean _GLEE_SGI_depth_pass_instrument = GL_FALSE;
GLboolean _GLEE_3DFX_texture_compression_FXT1 = GL_FALSE;
GLboolean _GLEE_3DFX_multisample = GL_FALSE;
GLboolean _GLEE_3DFX_tbuffer = GL_FALSE;
GLboolean _GLEE_EXT_multisample = GL_FALSE;
GLboolean _GLEE_SGIX_vertex_preclip = GL_FALSE;
GLboolean _GLEE_SGIX_convolution_accuracy = GL_FALSE;
GLboolean _GLEE_SGIX_resample = GL_FALSE;
GLboolean _GLEE_SGIS_point_line_texgen = GL_FALSE;
GLboolean _GLEE_SGIS_texture_color_mask = GL_FALSE;
GLboolean _GLEE_EXT_texture_env_dot3 = GL_FALSE;
GLboolean _GLEE_ATI_texture_mirror_once = GL_FALSE;
GLboolean _GLEE_NV_fence = GL_FALSE;
GLboolean _GLEE_IBM_texture_mirrored_repeat = GL_FALSE;
GLboolean _GLEE_NV_evaluators = GL_FALSE;
GLboolean _GLEE_NV_packed_depth_stencil = GL_FALSE;
GLboolean _GLEE_NV_register_combiners2 = GL_FALSE;
GLboolean _GLEE_NV_texture_compression_vtc = GL_FALSE;
GLboolean _GLEE_NV_texture_rectangle = GL_FALSE;
GLboolean _GLEE_NV_texture_shader = GL_FALSE;
GLboolean _GLEE_NV_texture_shader2 = GL_FALSE;
GLboolean _GLEE_NV_vertex_array_range2 = GL_FALSE;
GLboolean _GLEE_NV_vertex_program = GL_FALSE;
GLboolean _GLEE_SGIX_texture_coordinate_clamp = GL_FALSE;
GLboolean _GLEE_SGIX_scalebias_hint = GL_FALSE;
GLboolean _GLEE_OML_interlace = GL_FALSE;
GLboolean _GLEE_OML_subsample = GL_FALSE;
GLboolean _GLEE_OML_resample = GL_FALSE;
GLboolean _GLEE_NV_copy_depth_to_color = GL_FALSE;
GLboolean _GLEE_ATI_envmap_bumpmap = GL_FALSE;
GLboolean _GLEE_ATI_fragment_shader = GL_FALSE;
GLboolean _GLEE_ATI_pn_triangles = GL_FALSE;
GLboolean _GLEE_ATI_vertex_array_object = GL_FALSE;
GLboolean _GLEE_EXT_vertex_shader = GL_FALSE;
GLboolean _GLEE_ATI_vertex_streams = GL_FALSE;
GLboolean _GLEE_ATI_element_array = GL_FALSE;
GLboolean _GLEE_SUN_mesh_array = GL_FALSE;
GLboolean _GLEE_SUN_slice_accum = GL_FALSE;
GLboolean _GLEE_NV_multisample_filter_hint = GL_FALSE;
GLboolean _GLEE_NV_depth_clamp = GL_FALSE;
GLboolean _GLEE_NV_occlusion_query = GL_FALSE;
GLboolean _GLEE_NV_point_sprite = GL_FALSE;
GLboolean _GLEE_NV_texture_shader3 = GL_FALSE;
GLboolean _GLEE_NV_vertex_program1_1 = GL_FALSE;
GLboolean _GLEE_EXT_shadow_funcs = GL_FALSE;
GLboolean _GLEE_EXT_stencil_two_side = GL_FALSE;
GLboolean _GLEE_ATI_text_fragment_shader = GL_FALSE;
GLboolean _GLEE_APPLE_client_storage = GL_FALSE;
GLboolean _GLEE_APPLE_element_array = GL_FALSE;
GLboolean _GLEE_APPLE_fence = GL_FALSE;
GLboolean _GLEE_APPLE_vertex_array_object = GL_FALSE;
GLboolean _GLEE_APPLE_vertex_array_range = GL_FALSE;
GLboolean _GLEE_APPLE_ycbcr_422 = GL_FALSE;
GLboolean _GLEE_S3_s3tc = GL_FALSE;
GLboolean _GLEE_ATI_draw_buffers = GL_FALSE;
GLboolean _GLEE_ATI_pixel_format_float = GL_FALSE;
GLboolean _GLEE_ATI_texture_env_combine3 = GL_FALSE;
GLboolean _GLEE_ATI_texture_float = GL_FALSE;
GLboolean _GLEE_NV_float_buffer = GL_FALSE;
GLboolean _GLEE_NV_fragment_program = GL_FALSE;
GLboolean _GLEE_NV_half_float = GL_FALSE;
GLboolean _GLEE_NV_pixel_data_range = GL_FALSE;
GLboolean _GLEE_NV_primitive_restart = GL_FALSE;
GLboolean _GLEE_NV_texture_expand_normal = GL_FALSE;
GLboolean _GLEE_NV_vertex_program2 = GL_FALSE;
GLboolean _GLEE_ATI_map_object_buffer = GL_FALSE;
GLboolean _GLEE_ATI_separate_stencil = GL_FALSE;
GLboolean _GLEE_ATI_vertex_attrib_array_object = GL_FALSE;
GLboolean _GLEE_OES_read_format = GL_FALSE;
GLboolean _GLEE_EXT_depth_bounds_test = GL_FALSE;
GLboolean _GLEE_EXT_texture_mirror_clamp = GL_FALSE;
GLboolean _GLEE_EXT_blend_equation_separate = GL_FALSE;
GLboolean _GLEE_MESA_pack_invert = GL_FALSE;
GLboolean _GLEE_MESA_ycbcr_texture = GL_FALSE;
GLboolean _GLEE_EXT_pixel_buffer_object = GL_FALSE;
GLboolean _GLEE_NV_fragment_program_option = GL_FALSE;
GLboolean _GLEE_NV_fragment_program2 = GL_FALSE;
GLboolean _GLEE_NV_vertex_program2_option = GL_FALSE;
GLboolean _GLEE_NV_vertex_program3 = GL_FALSE;
GLboolean _GLEE_EXT_framebuffer_object = GL_FALSE;
GLboolean _GLEE_GREMEDY_string_marker = GL_FALSE;
GLboolean _GLEE_EXT_packed_depth_stencil = GL_FALSE;
GLboolean _GLEE_EXT_stencil_clear_tag = GL_FALSE;
GLboolean _GLEE_EXT_texture_sRGB = GL_FALSE;
GLboolean _GLEE_EXT_framebuffer_blit = GL_FALSE;
GLboolean _GLEE_EXT_framebuffer_multisample = GL_FALSE;
GLboolean _GLEE_MESAX_texture_stack = GL_FALSE;
GLboolean _GLEE_EXT_timer_query = GL_FALSE;
GLboolean _GLEE_EXT_gpu_program_parameters = GL_FALSE;
GLboolean _GLEE_APPLE_flush_buffer_range = GL_FALSE;
GLboolean _GLEE_EXT_gpu_shader4 = GL_FALSE;
GLboolean _GLEE_EXT_draw_instanced = GL_FALSE;
GLboolean _GLEE_EXT_packed_float = GL_FALSE;
GLboolean _GLEE_EXT_texture_array = GL_FALSE;
GLboolean _GLEE_EXT_texture_buffer_object = GL_FALSE;
GLboolean _GLEE_EXT_texture_compression_latc = GL_FALSE;
GLboolean _GLEE_EXT_texture_compression_rgtc = GL_FALSE;
GLboolean _GLEE_EXT_texture_shared_exponent = GL_FALSE;
GLboolean _GLEE_NV_depth_buffer_float = GL_FALSE;
GLboolean _GLEE_NV_framebuffer_multisample_coverage = GL_FALSE;
GLboolean _GLEE_EXT_framebuffer_sRGB = GL_FALSE;
GLboolean _GLEE_NV_geometry_shader4 = GL_FALSE;
GLboolean _GLEE_NV_parameter_buffer_object = GL_FALSE;
GLboolean _GLEE_EXT_draw_buffers2 = GL_FALSE;
GLboolean _GLEE_NV_transform_feedback = GL_FALSE;
GLboolean _GLEE_EXT_bindable_uniform = GL_FALSE;
GLboolean _GLEE_EXT_texture_integer = GL_FALSE;
GLboolean _GLEE_GREMEDY_frame_terminator = GL_FALSE;
GLboolean _GLEE_NV_conditional_render = GL_FALSE;
GLboolean _GLEE_NV_present_video = GL_FALSE;
GLboolean _GLEE_EXT_transform_feedback = GL_FALSE;
GLboolean _GLEE_EXT_direct_state_access = GL_FALSE;
GLboolean _GLEE_EXT_vertex_array_bgra = GL_FALSE;
GLboolean _GLEE_EXT_texture_swizzle = GL_FALSE;
GLboolean _GLEE_NV_explicit_multisample = GL_FALSE;
GLboolean _GLEE_NV_transform_feedback2 = GL_FALSE;
GLboolean _GLEE_SGIX_texture_select = GL_FALSE;
GLboolean _GLEE_INGR_blend_func_separate = GL_FALSE;
GLboolean _GLEE_SGIX_depth_pass_instrument = GL_FALSE;
GLboolean _GLEE_SGIX_igloo_interface = GL_FALSE;
GLboolean _GLEE_EXT_fragment_lighting = GL_FALSE;
GLboolean _GLEE_EXT_geometry_shader4 = GL_FALSE;
GLboolean _GLEE_EXT_scene_marker = GL_FALSE;
GLboolean _GLEE_EXT_texture_compression_dxt1 = GL_FALSE;
GLboolean _GLEE_EXT_texture_env = GL_FALSE;
GLboolean _GLEE_IBM_static_data = GL_FALSE;
GLboolean _GLEE_NV_gpu_program4 = GL_FALSE;
GLboolean _GLEE_OES_byte_coordinates = GL_FALSE;
GLboolean _GLEE_OES_compressed_paletted_texture = GL_FALSE;
GLboolean _GLEE_OES_single_precision = GL_FALSE;
GLboolean _GLEE_SGIX_pixel_texture_bits = GL_FALSE;
GLboolean _GLEE_SGIX_texture_range = GL_FALSE;
/* GL Extension names */
char __GLeeGLExtensionNames[322][39]={
"GL_VERSION_1_2",
"GL_ARB_imaging",
"GL_VERSION_1_3",
"GL_VERSION_1_4",
"GL_VERSION_1_5",
"GL_VERSION_2_0",
"GL_VERSION_2_1",
"GL_VERSION_3_0",
"GL_ARB_multitexture",
"GL_ARB_transpose_matrix",
"GL_ARB_multisample",
"GL_ARB_texture_env_add",
"GL_ARB_texture_cube_map",
"GL_ARB_texture_compression",
"GL_ARB_texture_border_clamp",
"GL_ARB_point_parameters",
"GL_ARB_vertex_blend",
"GL_ARB_matrix_palette",
"GL_ARB_texture_env_combine",
"GL_ARB_texture_env_crossbar",
"GL_ARB_texture_env_dot3",
"GL_ARB_texture_mirrored_repeat",
"GL_ARB_depth_texture",
"GL_ARB_shadow",
"GL_ARB_shadow_ambient",
"GL_ARB_window_pos",
"GL_ARB_vertex_program",
"GL_ARB_fragment_program",
"GL_ARB_vertex_buffer_object",
"GL_ARB_occlusion_query",
"GL_ARB_shader_objects",
"GL_ARB_vertex_shader",
"GL_ARB_fragment_shader",
"GL_ARB_shading_language_100",
"GL_ARB_texture_non_power_of_two",
"GL_ARB_point_sprite",
"GL_ARB_fragment_program_shadow",
"GL_ARB_draw_buffers",
"GL_ARB_texture_rectangle",
"GL_ARB_color_buffer_float",
"GL_ARB_half_float_pixel",
"GL_ARB_texture_float",
"GL_ARB_pixel_buffer_object",
"GL_ARB_depth_buffer_float",
"GL_ARB_draw_instanced",
"GL_ARB_framebuffer_object",
"GL_ARB_framebuffer_sRGB",
"GL_ARB_geometry_shader4",
"GL_ARB_half_float_vertex",
"GL_ARB_instanced_arrays",
"GL_ARB_map_buffer_range",
"GL_ARB_texture_buffer_object",
"GL_ARB_texture_compression_rgtc",
"GL_ARB_texture_rg",
"GL_ARB_vertex_array_object",
"GL_EXT_abgr",
"GL_EXT_blend_color",
"GL_EXT_polygon_offset",
"GL_EXT_texture",
"GL_EXT_texture3D",
"GL_SGIS_texture_filter4",
"GL_EXT_subtexture",
"GL_EXT_copy_texture",
"GL_EXT_histogram",
"GL_EXT_convolution",
"GL_SGI_color_matrix",
"GL_SGI_color_table",
"GL_SGIS_pixel_texture",
"GL_SGIX_pixel_texture",
"GL_SGIS_texture4D",
"GL_SGI_texture_color_table",
"GL_EXT_cmyka",
"GL_EXT_texture_object",
"GL_SGIS_detail_texture",
"GL_SGIS_sharpen_texture",
"GL_EXT_packed_pixels",
"GL_SGIS_texture_lod",
"GL_SGIS_multisample",
"GL_EXT_rescale_normal",
"GL_EXT_vertex_array",
"GL_EXT_misc_attribute",
"GL_SGIS_generate_mipmap",
"GL_SGIX_clipmap",
"GL_SGIX_shadow",
"GL_SGIS_texture_edge_clamp",
"GL_SGIS_texture_border_clamp",
"GL_EXT_blend_minmax",
"GL_EXT_blend_subtract",
"GL_EXT_blend_logic_op",
"GL_SGIX_interlace",
"GL_SGIX_pixel_tiles",
"GL_SGIS_texture_select",
"GL_SGIX_sprite",
"GL_SGIX_texture_multi_buffer",
"GL_EXT_point_parameters",
"GL_SGIS_point_parameters",
"GL_SGIX_instruments",
"GL_SGIX_texture_scale_bias",
"GL_SGIX_framezoom",
"GL_SGIX_tag_sample_buffer",
"GL_FfdMaskSGIX",
"GL_SGIX_polynomial_ffd",
"GL_SGIX_reference_plane",
"GL_SGIX_flush_raster",
"GL_SGIX_depth_texture",
"GL_SGIS_fog_function",
"GL_SGIX_fog_offset",
"GL_HP_image_transform",
"GL_HP_convolution_border_modes",
"GL_INGR_palette_buffer",
"GL_SGIX_texture_add_env",
"GL_EXT_color_subtable",
"GL_PGI_vertex_hints",
"GL_PGI_misc_hints",
"GL_EXT_paletted_texture",
"GL_EXT_clip_volume_hint",
"GL_SGIX_list_priority",
"GL_SGIX_ir_instrument1",
"GL_SGIX_calligraphic_fragment",
"GL_SGIX_texture_lod_bias",
"GL_SGIX_shadow_ambient",
"GL_EXT_index_texture",
"GL_EXT_index_material",
"GL_EXT_index_func",
"GL_EXT_index_array_formats",
"GL_EXT_compiled_vertex_array",
"GL_EXT_cull_vertex",
"GL_SGIX_ycrcb",
"GL_SGIX_fragment_lighting",
"GL_IBM_rasterpos_clip",
"GL_HP_texture_lighting",
"GL_EXT_draw_range_elements",
"GL_WIN_phong_shading",
"GL_WIN_specular_fog",
"GL_EXT_light_texture",
"GL_SGIX_blend_alpha_minmax",
"GL_SGIX_impact_pixel_texture",
"GL_EXT_bgra",
"GL_SGIX_async",
"GL_SGIX_async_pixel",
"GL_SGIX_async_histogram",
"GL_INTEL_texture_scissor",
"GL_INTEL_parallel_arrays",
"GL_HP_occlusion_test",
"GL_EXT_pixel_transform",
"GL_EXT_pixel_transform_color_table",
"GL_EXT_shared_texture_palette",
"GL_EXT_separate_specular_color",
"GL_EXT_secondary_color",
"GL_EXT_texture_perturb_normal",
"GL_EXT_multi_draw_arrays",
"GL_EXT_fog_coord",
"GL_REND_screen_coordinates",
"GL_EXT_coordinate_frame",
"GL_EXT_texture_env_combine",
"GL_APPLE_specular_vector",
"GL_APPLE_transform_hint",
"GL_SGIX_fog_scale",
"GL_SUNX_constant_data",
"GL_SUN_global_alpha",
"GL_SUN_triangle_list",
"GL_SUN_vertex",
"GL_EXT_blend_func_separate",
"GL_INGR_color_clamp",
"GL_INGR_interlace_read",
"GL_EXT_stencil_wrap",
"GL_EXT_422_pixels",
"GL_NV_texgen_reflection",
"GL_EXT_texture_cube_map",
"GL_SUN_convolution_border_modes",
"GL_EXT_texture_env_add",
"GL_EXT_texture_lod_bias",
"GL_EXT_texture_filter_anisotropic",
"GL_EXT_vertex_weighting",
"GL_NV_light_max_exponent",
"GL_NV_vertex_array_range",
"GL_NV_register_combiners",
"GL_NV_fog_distance",
"GL_NV_texgen_emboss",
"GL_NV_blend_square",
"GL_NV_texture_env_combine4",
"GL_MESA_resize_buffers",
"GL_MESA_window_pos",
"GL_EXT_texture_compression_s3tc",
"GL_IBM_cull_vertex",
"GL_IBM_multimode_draw_arrays",
"GL_IBM_vertex_array_lists",
"GL_SGIX_subsample",
"GL_SGIX_ycrcb_subsample",
"GL_SGIX_ycrcba",
"GL_SGI_depth_pass_instrument",
"GL_3DFX_texture_compression_FXT1",
"GL_3DFX_multisample",
"GL_3DFX_tbuffer",
"GL_EXT_multisample",
"GL_SGIX_vertex_preclip",
"GL_SGIX_convolution_accuracy",
"GL_SGIX_resample",
"GL_SGIS_point_line_texgen",
"GL_SGIS_texture_color_mask",
"GL_EXT_texture_env_dot3",
"GL_ATI_texture_mirror_once",
"GL_NV_fence",
"GL_IBM_texture_mirrored_repeat",
"GL_NV_evaluators",
"GL_NV_packed_depth_stencil",
"GL_NV_register_combiners2",
"GL_NV_texture_compression_vtc",
"GL_NV_texture_rectangle",
"GL_NV_texture_shader",
"GL_NV_texture_shader2",
"GL_NV_vertex_array_range2",
"GL_NV_vertex_program",
"GL_SGIX_texture_coordinate_clamp",
"GL_SGIX_scalebias_hint",
"GL_OML_interlace",
"GL_OML_subsample",
"GL_OML_resample",
"GL_NV_copy_depth_to_color",
"GL_ATI_envmap_bumpmap",
"GL_ATI_fragment_shader",
"GL_ATI_pn_triangles",
"GL_ATI_vertex_array_object",
"GL_EXT_vertex_shader",
"GL_ATI_vertex_streams",
"GL_ATI_element_array",
"GL_SUN_mesh_array",
"GL_SUN_slice_accum",
"GL_NV_multisample_filter_hint",
"GL_NV_depth_clamp",
"GL_NV_occlusion_query",
"GL_NV_point_sprite",
"GL_NV_texture_shader3",
"GL_NV_vertex_program1_1",
"GL_EXT_shadow_funcs",
"GL_EXT_stencil_two_side",
"GL_ATI_text_fragment_shader",
"GL_APPLE_client_storage",
"GL_APPLE_element_array",
"GL_APPLE_fence",
"GL_APPLE_vertex_array_object",
"GL_APPLE_vertex_array_range",
"GL_APPLE_ycbcr_422",
"GL_S3_s3tc",
"GL_ATI_draw_buffers",
"GL_ATI_pixel_format_float",
"GL_ATI_texture_env_combine3",
"GL_ATI_texture_float",
"GL_NV_float_buffer",
"GL_NV_fragment_program",
"GL_NV_half_float",
"GL_NV_pixel_data_range",
"GL_NV_primitive_restart",
"GL_NV_texture_expand_normal",
"GL_NV_vertex_program2",
"GL_ATI_map_object_buffer",
"GL_ATI_separate_stencil",
"GL_ATI_vertex_attrib_array_object",
"GL_OES_read_format",
"GL_EXT_depth_bounds_test",
"GL_EXT_texture_mirror_clamp",
"GL_EXT_blend_equation_separate",
"GL_MESA_pack_invert",
"GL_MESA_ycbcr_texture",
"GL_EXT_pixel_buffer_object",
"GL_NV_fragment_program_option",
"GL_NV_fragment_program2",
"GL_NV_vertex_program2_option",
"GL_NV_vertex_program3",
"GL_EXT_framebuffer_object",
"GL_GREMEDY_string_marker",
"GL_EXT_packed_depth_stencil",
"GL_EXT_stencil_clear_tag",
"GL_EXT_texture_sRGB",
"GL_EXT_framebuffer_blit",
"GL_EXT_framebuffer_multisample",
"GL_MESAX_texture_stack",
"GL_EXT_timer_query",
"GL_EXT_gpu_program_parameters",
"GL_APPLE_flush_buffer_range",
"GL_EXT_gpu_shader4",
"GL_EXT_draw_instanced",
"GL_EXT_packed_float",
"GL_EXT_texture_array",
"GL_EXT_texture_buffer_object",
"GL_EXT_texture_compression_latc",
"GL_EXT_texture_compression_rgtc",
"GL_EXT_texture_shared_exponent",
"GL_NV_depth_buffer_float",
"GL_NV_framebuffer_multisample_coverage",
"GL_EXT_framebuffer_sRGB",
"GL_NV_geometry_shader4",
"GL_NV_parameter_buffer_object",
"GL_EXT_draw_buffers2",
"GL_NV_transform_feedback",
"GL_EXT_bindable_uniform",
"GL_EXT_texture_integer",
"GL_GREMEDY_frame_terminator",
"GL_NV_conditional_render",
"GL_NV_present_video",
"GL_EXT_transform_feedback",
"GL_EXT_direct_state_access",
"GL_EXT_vertex_array_bgra",
"GL_EXT_texture_swizzle",
"GL_NV_explicit_multisample",
"GL_NV_transform_feedback2",
"GL_SGIX_texture_select",
"GL_INGR_blend_func_separate",
"GL_SGIX_depth_pass_instrument",
"GL_SGIX_igloo_interface",
"GL_EXT_fragment_lighting",
"GL_EXT_geometry_shader4",
"GL_EXT_scene_marker",
"GL_EXT_texture_compression_dxt1",
"GL_EXT_texture_env",
"GL_IBM_static_data",
"GL_NV_gpu_program4",
"GL_OES_byte_coordinates",
"GL_OES_compressed_paletted_texture",
"GL_OES_single_precision",
"GL_SGIX_pixel_texture_bits",
"GL_SGIX_texture_range"
};
int __GLeeGLNumExtensions=322;
/* GL_VERSION_1_2 */
#ifdef __GLEE_GL_VERSION_1_2
#ifndef GLEE_C_DEFINED_glBlendColor
#define GLEE_C_DEFINED_glBlendColor
void __stdcall GLee_Lazy_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {if (GLeeInit()) glBlendColor(red, green, blue, alpha);}
GLEEPFNGLBLENDCOLORPROC GLeeFuncPtr_glBlendColor=GLee_Lazy_glBlendColor;
#endif
#ifndef GLEE_C_DEFINED_glBlendEquation
#define GLEE_C_DEFINED_glBlendEquation
void __stdcall GLee_Lazy_glBlendEquation(GLenum mode) {if (GLeeInit()) glBlendEquation(mode);}
GLEEPFNGLBLENDEQUATIONPROC GLeeFuncPtr_glBlendEquation=GLee_Lazy_glBlendEquation;
#endif
#ifndef GLEE_C_DEFINED_glDrawRangeElements
#define GLEE_C_DEFINED_glDrawRangeElements
void __stdcall GLee_Lazy_glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices) {if (GLeeInit()) glDrawRangeElements(mode, start, end, count, type, indices);}
GLEEPFNGLDRAWRANGEELEMENTSPROC GLeeFuncPtr_glDrawRangeElements=GLee_Lazy_glDrawRangeElements;
#endif
#ifndef GLEE_C_DEFINED_glColorTable
#define GLEE_C_DEFINED_glColorTable
void __stdcall GLee_Lazy_glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table) {if (GLeeInit()) glColorTable(target, internalformat, width, format, type, table);}
GLEEPFNGLCOLORTABLEPROC GLeeFuncPtr_glColorTable=GLee_Lazy_glColorTable;
#endif
#ifndef GLEE_C_DEFINED_glColorTableParameterfv
#define GLEE_C_DEFINED_glColorTableParameterfv
void __stdcall GLee_Lazy_glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat * params) {if (GLeeInit()) glColorTableParameterfv(target, pname, params);}
GLEEPFNGLCOLORTABLEPARAMETERFVPROC GLeeFuncPtr_glColorTableParameterfv=GLee_Lazy_glColorTableParameterfv;
#endif
#ifndef GLEE_C_DEFINED_glColorTableParameteriv
#define GLEE_C_DEFINED_glColorTableParameteriv
void __stdcall GLee_Lazy_glColorTableParameteriv(GLenum target, GLenum pname, const GLint * params) {if (GLeeInit()) glColorTableParameteriv(target, pname, params);}
GLEEPFNGLCOLORTABLEPARAMETERIVPROC GLeeFuncPtr_glColorTableParameteriv=GLee_Lazy_glColorTableParameteriv;
#endif
#ifndef GLEE_C_DEFINED_glCopyColorTable
#define GLEE_C_DEFINED_glCopyColorTable
void __stdcall GLee_Lazy_glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) {if (GLeeInit()) glCopyColorTable(target, internalformat, x, y, width);}
GLEEPFNGLCOPYCOLORTABLEPROC GLeeFuncPtr_glCopyColorTable=GLee_Lazy_glCopyColorTable;
#endif
#ifndef GLEE_C_DEFINED_glGetColorTable
#define GLEE_C_DEFINED_glGetColorTable
void __stdcall GLee_Lazy_glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid * table) {if (GLeeInit()) glGetColorTable(target, format, type, table);}
GLEEPFNGLGETCOLORTABLEPROC GLeeFuncPtr_glGetColorTable=GLee_Lazy_glGetColorTable;
#endif
#ifndef GLEE_C_DEFINED_glGetColorTableParameterfv
#define GLEE_C_DEFINED_glGetColorTableParameterfv
void __stdcall GLee_Lazy_glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetColorTableParameterfv(target, pname, params);}
GLEEPFNGLGETCOLORTABLEPARAMETERFVPROC GLeeFuncPtr_glGetColorTableParameterfv=GLee_Lazy_glGetColorTableParameterfv;
#endif
#ifndef GLEE_C_DEFINED_glGetColorTableParameteriv
#define GLEE_C_DEFINED_glGetColorTableParameteriv
void __stdcall GLee_Lazy_glGetColorTableParameteriv(GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetColorTableParameteriv(target, pname, params);}
GLEEPFNGLGETCOLORTABLEPARAMETERIVPROC GLeeFuncPtr_glGetColorTableParameteriv=GLee_Lazy_glGetColorTableParameteriv;
#endif
#ifndef GLEE_C_DEFINED_glColorSubTable
#define GLEE_C_DEFINED_glColorSubTable
void __stdcall GLee_Lazy_glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data) {if (GLeeInit()) glColorSubTable(target, start, count, format, type, data);}
GLEEPFNGLCOLORSUBTABLEPROC GLeeFuncPtr_glColorSubTable=GLee_Lazy_glColorSubTable;
#endif
#ifndef GLEE_C_DEFINED_glCopyColorSubTable
#define GLEE_C_DEFINED_glCopyColorSubTable
void __stdcall GLee_Lazy_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) {if (GLeeInit()) glCopyColorSubTable(target, start, x, y, width);}
GLEEPFNGLCOPYCOLORSUBTABLEPROC GLeeFuncPtr_glCopyColorSubTable=GLee_Lazy_glCopyColorSubTable;
#endif
#ifndef GLEE_C_DEFINED_glConvolutionFilter1D
#define GLEE_C_DEFINED_glConvolutionFilter1D
void __stdcall GLee_Lazy_glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image) {if (GLeeInit()) glConvolutionFilter1D(target, internalformat, width, format, type, image);}
GLEEPFNGLCONVOLUTIONFILTER1DPROC GLeeFuncPtr_glConvolutionFilter1D=GLee_Lazy_glConvolutionFilter1D;
#endif
#ifndef GLEE_C_DEFINED_glConvolutionFilter2D
#define GLEE_C_DEFINED_glConvolutionFilter2D
void __stdcall GLee_Lazy_glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image) {if (GLeeInit()) glConvolutionFilter2D(target, internalformat, width, height, format, type, image);}
GLEEPFNGLCONVOLUTIONFILTER2DPROC GLeeFuncPtr_glConvolutionFilter2D=GLee_Lazy_glConvolutionFilter2D;
#endif
#ifndef GLEE_C_DEFINED_glConvolutionParameterf
#define GLEE_C_DEFINED_glConvolutionParameterf
void __stdcall GLee_Lazy_glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params) {if (GLeeInit()) glConvolutionParameterf(target, pname, params);}
GLEEPFNGLCONVOLUTIONPARAMETERFPROC GLeeFuncPtr_glConvolutionParameterf=GLee_Lazy_glConvolutionParameterf;
#endif
#ifndef GLEE_C_DEFINED_glConvolutionParameterfv
#define GLEE_C_DEFINED_glConvolutionParameterfv
void __stdcall GLee_Lazy_glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat * params) {if (GLeeInit()) glConvolutionParameterfv(target, pname, params);}
GLEEPFNGLCONVOLUTIONPARAMETERFVPROC GLeeFuncPtr_glConvolutionParameterfv=GLee_Lazy_glConvolutionParameterfv;
#endif
#ifndef GLEE_C_DEFINED_glConvolutionParameteri
#define GLEE_C_DEFINED_glConvolutionParameteri
void __stdcall GLee_Lazy_glConvolutionParameteri(GLenum target, GLenum pname, GLint params) {if (GLeeInit()) glConvolutionParameteri(target, pname, params);}
GLEEPFNGLCONVOLUTIONPARAMETERIPROC GLeeFuncPtr_glConvolutionParameteri=GLee_Lazy_glConvolutionParameteri;
#endif
#ifndef GLEE_C_DEFINED_glConvolutionParameteriv
#define GLEE_C_DEFINED_glConvolutionParameteriv
void __stdcall GLee_Lazy_glConvolutionParameteriv(GLenum target, GLenum pname, const GLint * params) {if (GLeeInit()) glConvolutionParameteriv(target, pname, params);}
GLEEPFNGLCONVOLUTIONPARAMETERIVPROC GLeeFuncPtr_glConvolutionParameteriv=GLee_Lazy_glConvolutionParameteriv;
#endif
#ifndef GLEE_C_DEFINED_glCopyConvolutionFilter1D
#define GLEE_C_DEFINED_glCopyConvolutionFilter1D
void __stdcall GLee_Lazy_glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) {if (GLeeInit()) glCopyConvolutionFilter1D(target, internalformat, x, y, width);}
GLEEPFNGLCOPYCONVOLUTIONFILTER1DPROC GLeeFuncPtr_glCopyConvolutionFilter1D=GLee_Lazy_glCopyConvolutionFilter1D;
#endif
#ifndef GLEE_C_DEFINED_glCopyConvolutionFilter2D
#define GLEE_C_DEFINED_glCopyConvolutionFilter2D
void __stdcall GLee_Lazy_glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height) {if (GLeeInit()) glCopyConvolutionFilter2D(target, internalformat, x, y, width, height);}
GLEEPFNGLCOPYCONVOLUTIONFILTER2DPROC GLeeFuncPtr_glCopyConvolutionFilter2D=GLee_Lazy_glCopyConvolutionFilter2D;
#endif
#ifndef GLEE_C_DEFINED_glGetConvolutionFilter
#define GLEE_C_DEFINED_glGetConvolutionFilter
void __stdcall GLee_Lazy_glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid * image) {if (GLeeInit()) glGetConvolutionFilter(target, format, type, image);}
GLEEPFNGLGETCONVOLUTIONFILTERPROC GLeeFuncPtr_glGetConvolutionFilter=GLee_Lazy_glGetConvolutionFilter;
#endif
#ifndef GLEE_C_DEFINED_glGetConvolutionParameterfv
#define GLEE_C_DEFINED_glGetConvolutionParameterfv
void __stdcall GLee_Lazy_glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetConvolutionParameterfv(target, pname, params);}
GLEEPFNGLGETCONVOLUTIONPARAMETERFVPROC GLeeFuncPtr_glGetConvolutionParameterfv=GLee_Lazy_glGetConvolutionParameterfv;
#endif
#ifndef GLEE_C_DEFINED_glGetConvolutionParameteriv
#define GLEE_C_DEFINED_glGetConvolutionParameteriv
void __stdcall GLee_Lazy_glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetConvolutionParameteriv(target, pname, params);}
GLEEPFNGLGETCONVOLUTIONPARAMETERIVPROC GLeeFuncPtr_glGetConvolutionParameteriv=GLee_Lazy_glGetConvolutionParameteriv;
#endif
#ifndef GLEE_C_DEFINED_glGetSeparableFilter
#define GLEE_C_DEFINED_glGetSeparableFilter
void __stdcall GLee_Lazy_glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span) {if (GLeeInit()) glGetSeparableFilter(target, format, type, row, column, span);}
GLEEPFNGLGETSEPARABLEFILTERPROC GLeeFuncPtr_glGetSeparableFilter=GLee_Lazy_glGetSeparableFilter;
#endif
#ifndef GLEE_C_DEFINED_glSeparableFilter2D
#define GLEE_C_DEFINED_glSeparableFilter2D
void __stdcall GLee_Lazy_glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * row, const GLvoid * column) {if (GLeeInit()) glSeparableFilter2D(target, internalformat, width, height, format, type, row, column);}
GLEEPFNGLSEPARABLEFILTER2DPROC GLeeFuncPtr_glSeparableFilter2D=GLee_Lazy_glSeparableFilter2D;
#endif
#ifndef GLEE_C_DEFINED_glGetHistogram
#define GLEE_C_DEFINED_glGetHistogram
void __stdcall GLee_Lazy_glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values) {if (GLeeInit()) glGetHistogram(target, reset, format, type, values);}
GLEEPFNGLGETHISTOGRAMPROC GLeeFuncPtr_glGetHistogram=GLee_Lazy_glGetHistogram;
#endif
#ifndef GLEE_C_DEFINED_glGetHistogramParameterfv
#define GLEE_C_DEFINED_glGetHistogramParameterfv
void __stdcall GLee_Lazy_glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetHistogramParameterfv(target, pname, params);}
GLEEPFNGLGETHISTOGRAMPARAMETERFVPROC GLeeFuncPtr_glGetHistogramParameterfv=GLee_Lazy_glGetHistogramParameterfv;
#endif
#ifndef GLEE_C_DEFINED_glGetHistogramParameteriv
#define GLEE_C_DEFINED_glGetHistogramParameteriv
void __stdcall GLee_Lazy_glGetHistogramParameteriv(GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetHistogramParameteriv(target, pname, params);}
GLEEPFNGLGETHISTOGRAMPARAMETERIVPROC GLeeFuncPtr_glGetHistogramParameteriv=GLee_Lazy_glGetHistogramParameteriv;
#endif
#ifndef GLEE_C_DEFINED_glGetMinmax
#define GLEE_C_DEFINED_glGetMinmax
void __stdcall GLee_Lazy_glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values) {if (GLeeInit()) glGetMinmax(target, reset, format, type, values);}
GLEEPFNGLGETMINMAXPROC GLeeFuncPtr_glGetMinmax=GLee_Lazy_glGetMinmax;
#endif
#ifndef GLEE_C_DEFINED_glGetMinmaxParameterfv
#define GLEE_C_DEFINED_glGetMinmaxParameterfv
void __stdcall GLee_Lazy_glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetMinmaxParameterfv(target, pname, params);}
GLEEPFNGLGETMINMAXPARAMETERFVPROC GLeeFuncPtr_glGetMinmaxParameterfv=GLee_Lazy_glGetMinmaxParameterfv;
#endif
#ifndef GLEE_C_DEFINED_glGetMinmaxParameteriv
#define GLEE_C_DEFINED_glGetMinmaxParameteriv
void __stdcall GLee_Lazy_glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetMinmaxParameteriv(target, pname, params);}
GLEEPFNGLGETMINMAXPARAMETERIVPROC GLeeFuncPtr_glGetMinmaxParameteriv=GLee_Lazy_glGetMinmaxParameteriv;
#endif
#ifndef GLEE_C_DEFINED_glHistogram
#define GLEE_C_DEFINED_glHistogram
void __stdcall GLee_Lazy_glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink) {if (GLeeInit()) glHistogram(target, width, internalformat, sink);}
GLEEPFNGLHISTOGRAMPROC GLeeFuncPtr_glHistogram=GLee_Lazy_glHistogram;
#endif
#ifndef GLEE_C_DEFINED_glMinmax
#define GLEE_C_DEFINED_glMinmax
void __stdcall GLee_Lazy_glMinmax(GLenum target, GLenum internalformat, GLboolean sink) {if (GLeeInit()) glMinmax(target, internalformat, sink);}
GLEEPFNGLMINMAXPROC GLeeFuncPtr_glMinmax=GLee_Lazy_glMinmax;
#endif
#ifndef GLEE_C_DEFINED_glResetHistogram
#define GLEE_C_DEFINED_glResetHistogram
void __stdcall GLee_Lazy_glResetHistogram(GLenum target) {if (GLeeInit()) glResetHistogram(target);}
GLEEPFNGLRESETHISTOGRAMPROC GLeeFuncPtr_glResetHistogram=GLee_Lazy_glResetHistogram;
#endif
#ifndef GLEE_C_DEFINED_glResetMinmax
#define GLEE_C_DEFINED_glResetMinmax
void __stdcall GLee_Lazy_glResetMinmax(GLenum target) {if (GLeeInit()) glResetMinmax(target);}
GLEEPFNGLRESETMINMAXPROC GLeeFuncPtr_glResetMinmax=GLee_Lazy_glResetMinmax;
#endif
#ifndef GLEE_C_DEFINED_glTexImage3D
#define GLEE_C_DEFINED_glTexImage3D
void __stdcall GLee_Lazy_glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);}
GLEEPFNGLTEXIMAGE3DPROC GLeeFuncPtr_glTexImage3D=GLee_Lazy_glTexImage3D;
#endif
#ifndef GLEE_C_DEFINED_glTexSubImage3D
#define GLEE_C_DEFINED_glTexSubImage3D
void __stdcall GLee_Lazy_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);}
GLEEPFNGLTEXSUBIMAGE3DPROC GLeeFuncPtr_glTexSubImage3D=GLee_Lazy_glTexSubImage3D;
#endif
#ifndef GLEE_C_DEFINED_glCopyTexSubImage3D
#define GLEE_C_DEFINED_glCopyTexSubImage3D
void __stdcall GLee_Lazy_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) {if (GLeeInit()) glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);}
GLEEPFNGLCOPYTEXSUBIMAGE3DPROC GLeeFuncPtr_glCopyTexSubImage3D=GLee_Lazy_glCopyTexSubImage3D;
#endif
#endif
/* GL_ARB_imaging */
#ifdef __GLEE_GL_ARB_imaging
#endif
/* GL_VERSION_1_3 */
#ifdef __GLEE_GL_VERSION_1_3
#ifndef GLEE_C_DEFINED_glActiveTexture
#define GLEE_C_DEFINED_glActiveTexture
void __stdcall GLee_Lazy_glActiveTexture(GLenum texture) {if (GLeeInit()) glActiveTexture(texture);}
GLEEPFNGLACTIVETEXTUREPROC GLeeFuncPtr_glActiveTexture=GLee_Lazy_glActiveTexture;
#endif
#ifndef GLEE_C_DEFINED_glClientActiveTexture
#define GLEE_C_DEFINED_glClientActiveTexture
void __stdcall GLee_Lazy_glClientActiveTexture(GLenum texture) {if (GLeeInit()) glClientActiveTexture(texture);}
GLEEPFNGLCLIENTACTIVETEXTUREPROC GLeeFuncPtr_glClientActiveTexture=GLee_Lazy_glClientActiveTexture;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1d
#define GLEE_C_DEFINED_glMultiTexCoord1d
void __stdcall GLee_Lazy_glMultiTexCoord1d(GLenum target, GLdouble s) {if (GLeeInit()) glMultiTexCoord1d(target, s);}
GLEEPFNGLMULTITEXCOORD1DPROC GLeeFuncPtr_glMultiTexCoord1d=GLee_Lazy_glMultiTexCoord1d;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1dv
#define GLEE_C_DEFINED_glMultiTexCoord1dv
void __stdcall GLee_Lazy_glMultiTexCoord1dv(GLenum target, const GLdouble * v) {if (GLeeInit()) glMultiTexCoord1dv(target, v);}
GLEEPFNGLMULTITEXCOORD1DVPROC GLeeFuncPtr_glMultiTexCoord1dv=GLee_Lazy_glMultiTexCoord1dv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1f
#define GLEE_C_DEFINED_glMultiTexCoord1f
void __stdcall GLee_Lazy_glMultiTexCoord1f(GLenum target, GLfloat s) {if (GLeeInit()) glMultiTexCoord1f(target, s);}
GLEEPFNGLMULTITEXCOORD1FPROC GLeeFuncPtr_glMultiTexCoord1f=GLee_Lazy_glMultiTexCoord1f;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1fv
#define GLEE_C_DEFINED_glMultiTexCoord1fv
void __stdcall GLee_Lazy_glMultiTexCoord1fv(GLenum target, const GLfloat * v) {if (GLeeInit()) glMultiTexCoord1fv(target, v);}
GLEEPFNGLMULTITEXCOORD1FVPROC GLeeFuncPtr_glMultiTexCoord1fv=GLee_Lazy_glMultiTexCoord1fv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1i
#define GLEE_C_DEFINED_glMultiTexCoord1i
void __stdcall GLee_Lazy_glMultiTexCoord1i(GLenum target, GLint s) {if (GLeeInit()) glMultiTexCoord1i(target, s);}
GLEEPFNGLMULTITEXCOORD1IPROC GLeeFuncPtr_glMultiTexCoord1i=GLee_Lazy_glMultiTexCoord1i;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1iv
#define GLEE_C_DEFINED_glMultiTexCoord1iv
void __stdcall GLee_Lazy_glMultiTexCoord1iv(GLenum target, const GLint * v) {if (GLeeInit()) glMultiTexCoord1iv(target, v);}
GLEEPFNGLMULTITEXCOORD1IVPROC GLeeFuncPtr_glMultiTexCoord1iv=GLee_Lazy_glMultiTexCoord1iv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1s
#define GLEE_C_DEFINED_glMultiTexCoord1s
void __stdcall GLee_Lazy_glMultiTexCoord1s(GLenum target, GLshort s) {if (GLeeInit()) glMultiTexCoord1s(target, s);}
GLEEPFNGLMULTITEXCOORD1SPROC GLeeFuncPtr_glMultiTexCoord1s=GLee_Lazy_glMultiTexCoord1s;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1sv
#define GLEE_C_DEFINED_glMultiTexCoord1sv
void __stdcall GLee_Lazy_glMultiTexCoord1sv(GLenum target, const GLshort * v) {if (GLeeInit()) glMultiTexCoord1sv(target, v);}
GLEEPFNGLMULTITEXCOORD1SVPROC GLeeFuncPtr_glMultiTexCoord1sv=GLee_Lazy_glMultiTexCoord1sv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2d
#define GLEE_C_DEFINED_glMultiTexCoord2d
void __stdcall GLee_Lazy_glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t) {if (GLeeInit()) glMultiTexCoord2d(target, s, t);}
GLEEPFNGLMULTITEXCOORD2DPROC GLeeFuncPtr_glMultiTexCoord2d=GLee_Lazy_glMultiTexCoord2d;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2dv
#define GLEE_C_DEFINED_glMultiTexCoord2dv
void __stdcall GLee_Lazy_glMultiTexCoord2dv(GLenum target, const GLdouble * v) {if (GLeeInit()) glMultiTexCoord2dv(target, v);}
GLEEPFNGLMULTITEXCOORD2DVPROC GLeeFuncPtr_glMultiTexCoord2dv=GLee_Lazy_glMultiTexCoord2dv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2f
#define GLEE_C_DEFINED_glMultiTexCoord2f
void __stdcall GLee_Lazy_glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t) {if (GLeeInit()) glMultiTexCoord2f(target, s, t);}
GLEEPFNGLMULTITEXCOORD2FPROC GLeeFuncPtr_glMultiTexCoord2f=GLee_Lazy_glMultiTexCoord2f;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2fv
#define GLEE_C_DEFINED_glMultiTexCoord2fv
void __stdcall GLee_Lazy_glMultiTexCoord2fv(GLenum target, const GLfloat * v) {if (GLeeInit()) glMultiTexCoord2fv(target, v);}
GLEEPFNGLMULTITEXCOORD2FVPROC GLeeFuncPtr_glMultiTexCoord2fv=GLee_Lazy_glMultiTexCoord2fv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2i
#define GLEE_C_DEFINED_glMultiTexCoord2i
void __stdcall GLee_Lazy_glMultiTexCoord2i(GLenum target, GLint s, GLint t) {if (GLeeInit()) glMultiTexCoord2i(target, s, t);}
GLEEPFNGLMULTITEXCOORD2IPROC GLeeFuncPtr_glMultiTexCoord2i=GLee_Lazy_glMultiTexCoord2i;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2iv
#define GLEE_C_DEFINED_glMultiTexCoord2iv
void __stdcall GLee_Lazy_glMultiTexCoord2iv(GLenum target, const GLint * v) {if (GLeeInit()) glMultiTexCoord2iv(target, v);}
GLEEPFNGLMULTITEXCOORD2IVPROC GLeeFuncPtr_glMultiTexCoord2iv=GLee_Lazy_glMultiTexCoord2iv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2s
#define GLEE_C_DEFINED_glMultiTexCoord2s
void __stdcall GLee_Lazy_glMultiTexCoord2s(GLenum target, GLshort s, GLshort t) {if (GLeeInit()) glMultiTexCoord2s(target, s, t);}
GLEEPFNGLMULTITEXCOORD2SPROC GLeeFuncPtr_glMultiTexCoord2s=GLee_Lazy_glMultiTexCoord2s;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2sv
#define GLEE_C_DEFINED_glMultiTexCoord2sv
void __stdcall GLee_Lazy_glMultiTexCoord2sv(GLenum target, const GLshort * v) {if (GLeeInit()) glMultiTexCoord2sv(target, v);}
GLEEPFNGLMULTITEXCOORD2SVPROC GLeeFuncPtr_glMultiTexCoord2sv=GLee_Lazy_glMultiTexCoord2sv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3d
#define GLEE_C_DEFINED_glMultiTexCoord3d
void __stdcall GLee_Lazy_glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r) {if (GLeeInit()) glMultiTexCoord3d(target, s, t, r);}
GLEEPFNGLMULTITEXCOORD3DPROC GLeeFuncPtr_glMultiTexCoord3d=GLee_Lazy_glMultiTexCoord3d;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3dv
#define GLEE_C_DEFINED_glMultiTexCoord3dv
void __stdcall GLee_Lazy_glMultiTexCoord3dv(GLenum target, const GLdouble * v) {if (GLeeInit()) glMultiTexCoord3dv(target, v);}
GLEEPFNGLMULTITEXCOORD3DVPROC GLeeFuncPtr_glMultiTexCoord3dv=GLee_Lazy_glMultiTexCoord3dv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3f
#define GLEE_C_DEFINED_glMultiTexCoord3f
void __stdcall GLee_Lazy_glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r) {if (GLeeInit()) glMultiTexCoord3f(target, s, t, r);}
GLEEPFNGLMULTITEXCOORD3FPROC GLeeFuncPtr_glMultiTexCoord3f=GLee_Lazy_glMultiTexCoord3f;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3fv
#define GLEE_C_DEFINED_glMultiTexCoord3fv
void __stdcall GLee_Lazy_glMultiTexCoord3fv(GLenum target, const GLfloat * v) {if (GLeeInit()) glMultiTexCoord3fv(target, v);}
GLEEPFNGLMULTITEXCOORD3FVPROC GLeeFuncPtr_glMultiTexCoord3fv=GLee_Lazy_glMultiTexCoord3fv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3i
#define GLEE_C_DEFINED_glMultiTexCoord3i
void __stdcall GLee_Lazy_glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r) {if (GLeeInit()) glMultiTexCoord3i(target, s, t, r);}
GLEEPFNGLMULTITEXCOORD3IPROC GLeeFuncPtr_glMultiTexCoord3i=GLee_Lazy_glMultiTexCoord3i;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3iv
#define GLEE_C_DEFINED_glMultiTexCoord3iv
void __stdcall GLee_Lazy_glMultiTexCoord3iv(GLenum target, const GLint * v) {if (GLeeInit()) glMultiTexCoord3iv(target, v);}
GLEEPFNGLMULTITEXCOORD3IVPROC GLeeFuncPtr_glMultiTexCoord3iv=GLee_Lazy_glMultiTexCoord3iv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3s
#define GLEE_C_DEFINED_glMultiTexCoord3s
void __stdcall GLee_Lazy_glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r) {if (GLeeInit()) glMultiTexCoord3s(target, s, t, r);}
GLEEPFNGLMULTITEXCOORD3SPROC GLeeFuncPtr_glMultiTexCoord3s=GLee_Lazy_glMultiTexCoord3s;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3sv
#define GLEE_C_DEFINED_glMultiTexCoord3sv
void __stdcall GLee_Lazy_glMultiTexCoord3sv(GLenum target, const GLshort * v) {if (GLeeInit()) glMultiTexCoord3sv(target, v);}
GLEEPFNGLMULTITEXCOORD3SVPROC GLeeFuncPtr_glMultiTexCoord3sv=GLee_Lazy_glMultiTexCoord3sv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4d
#define GLEE_C_DEFINED_glMultiTexCoord4d
void __stdcall GLee_Lazy_glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) {if (GLeeInit()) glMultiTexCoord4d(target, s, t, r, q);}
GLEEPFNGLMULTITEXCOORD4DPROC GLeeFuncPtr_glMultiTexCoord4d=GLee_Lazy_glMultiTexCoord4d;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4dv
#define GLEE_C_DEFINED_glMultiTexCoord4dv
void __stdcall GLee_Lazy_glMultiTexCoord4dv(GLenum target, const GLdouble * v) {if (GLeeInit()) glMultiTexCoord4dv(target, v);}
GLEEPFNGLMULTITEXCOORD4DVPROC GLeeFuncPtr_glMultiTexCoord4dv=GLee_Lazy_glMultiTexCoord4dv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4f
#define GLEE_C_DEFINED_glMultiTexCoord4f
void __stdcall GLee_Lazy_glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) {if (GLeeInit()) glMultiTexCoord4f(target, s, t, r, q);}
GLEEPFNGLMULTITEXCOORD4FPROC GLeeFuncPtr_glMultiTexCoord4f=GLee_Lazy_glMultiTexCoord4f;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4fv
#define GLEE_C_DEFINED_glMultiTexCoord4fv
void __stdcall GLee_Lazy_glMultiTexCoord4fv(GLenum target, const GLfloat * v) {if (GLeeInit()) glMultiTexCoord4fv(target, v);}
GLEEPFNGLMULTITEXCOORD4FVPROC GLeeFuncPtr_glMultiTexCoord4fv=GLee_Lazy_glMultiTexCoord4fv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4i
#define GLEE_C_DEFINED_glMultiTexCoord4i
void __stdcall GLee_Lazy_glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q) {if (GLeeInit()) glMultiTexCoord4i(target, s, t, r, q);}
GLEEPFNGLMULTITEXCOORD4IPROC GLeeFuncPtr_glMultiTexCoord4i=GLee_Lazy_glMultiTexCoord4i;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4iv
#define GLEE_C_DEFINED_glMultiTexCoord4iv
void __stdcall GLee_Lazy_glMultiTexCoord4iv(GLenum target, const GLint * v) {if (GLeeInit()) glMultiTexCoord4iv(target, v);}
GLEEPFNGLMULTITEXCOORD4IVPROC GLeeFuncPtr_glMultiTexCoord4iv=GLee_Lazy_glMultiTexCoord4iv;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4s
#define GLEE_C_DEFINED_glMultiTexCoord4s
void __stdcall GLee_Lazy_glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) {if (GLeeInit()) glMultiTexCoord4s(target, s, t, r, q);}
GLEEPFNGLMULTITEXCOORD4SPROC GLeeFuncPtr_glMultiTexCoord4s=GLee_Lazy_glMultiTexCoord4s;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4sv
#define GLEE_C_DEFINED_glMultiTexCoord4sv
void __stdcall GLee_Lazy_glMultiTexCoord4sv(GLenum target, const GLshort * v) {if (GLeeInit()) glMultiTexCoord4sv(target, v);}
GLEEPFNGLMULTITEXCOORD4SVPROC GLeeFuncPtr_glMultiTexCoord4sv=GLee_Lazy_glMultiTexCoord4sv;
#endif
#ifndef GLEE_C_DEFINED_glLoadTransposeMatrixf
#define GLEE_C_DEFINED_glLoadTransposeMatrixf
void __stdcall GLee_Lazy_glLoadTransposeMatrixf(const GLfloat * m) {if (GLeeInit()) glLoadTransposeMatrixf(m);}
GLEEPFNGLLOADTRANSPOSEMATRIXFPROC GLeeFuncPtr_glLoadTransposeMatrixf=GLee_Lazy_glLoadTransposeMatrixf;
#endif
#ifndef GLEE_C_DEFINED_glLoadTransposeMatrixd
#define GLEE_C_DEFINED_glLoadTransposeMatrixd
void __stdcall GLee_Lazy_glLoadTransposeMatrixd(const GLdouble * m) {if (GLeeInit()) glLoadTransposeMatrixd(m);}
GLEEPFNGLLOADTRANSPOSEMATRIXDPROC GLeeFuncPtr_glLoadTransposeMatrixd=GLee_Lazy_glLoadTransposeMatrixd;
#endif
#ifndef GLEE_C_DEFINED_glMultTransposeMatrixf
#define GLEE_C_DEFINED_glMultTransposeMatrixf
void __stdcall GLee_Lazy_glMultTransposeMatrixf(const GLfloat * m) {if (GLeeInit()) glMultTransposeMatrixf(m);}
GLEEPFNGLMULTTRANSPOSEMATRIXFPROC GLeeFuncPtr_glMultTransposeMatrixf=GLee_Lazy_glMultTransposeMatrixf;
#endif
#ifndef GLEE_C_DEFINED_glMultTransposeMatrixd
#define GLEE_C_DEFINED_glMultTransposeMatrixd
void __stdcall GLee_Lazy_glMultTransposeMatrixd(const GLdouble * m) {if (GLeeInit()) glMultTransposeMatrixd(m);}
GLEEPFNGLMULTTRANSPOSEMATRIXDPROC GLeeFuncPtr_glMultTransposeMatrixd=GLee_Lazy_glMultTransposeMatrixd;
#endif
#ifndef GLEE_C_DEFINED_glSampleCoverage
#define GLEE_C_DEFINED_glSampleCoverage
void __stdcall GLee_Lazy_glSampleCoverage(GLclampf value, GLboolean invert) {if (GLeeInit()) glSampleCoverage(value, invert);}
GLEEPFNGLSAMPLECOVERAGEPROC GLeeFuncPtr_glSampleCoverage=GLee_Lazy_glSampleCoverage;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexImage3D
#define GLEE_C_DEFINED_glCompressedTexImage3D
void __stdcall GLee_Lazy_glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data) {if (GLeeInit()) glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);}
GLEEPFNGLCOMPRESSEDTEXIMAGE3DPROC GLeeFuncPtr_glCompressedTexImage3D=GLee_Lazy_glCompressedTexImage3D;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexImage2D
#define GLEE_C_DEFINED_glCompressedTexImage2D
void __stdcall GLee_Lazy_glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * data) {if (GLeeInit()) glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);}
GLEEPFNGLCOMPRESSEDTEXIMAGE2DPROC GLeeFuncPtr_glCompressedTexImage2D=GLee_Lazy_glCompressedTexImage2D;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexImage1D
#define GLEE_C_DEFINED_glCompressedTexImage1D
void __stdcall GLee_Lazy_glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid * data) {if (GLeeInit()) glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);}
GLEEPFNGLCOMPRESSEDTEXIMAGE1DPROC GLeeFuncPtr_glCompressedTexImage1D=GLee_Lazy_glCompressedTexImage1D;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexSubImage3D
#define GLEE_C_DEFINED_glCompressedTexSubImage3D
void __stdcall GLee_Lazy_glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data) {if (GLeeInit()) glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);}
GLEEPFNGLCOMPRESSEDTEXSUBIMAGE3DPROC GLeeFuncPtr_glCompressedTexSubImage3D=GLee_Lazy_glCompressedTexSubImage3D;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexSubImage2D
#define GLEE_C_DEFINED_glCompressedTexSubImage2D
void __stdcall GLee_Lazy_glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data) {if (GLeeInit()) glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);}
GLEEPFNGLCOMPRESSEDTEXSUBIMAGE2DPROC GLeeFuncPtr_glCompressedTexSubImage2D=GLee_Lazy_glCompressedTexSubImage2D;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexSubImage1D
#define GLEE_C_DEFINED_glCompressedTexSubImage1D
void __stdcall GLee_Lazy_glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * data) {if (GLeeInit()) glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);}
GLEEPFNGLCOMPRESSEDTEXSUBIMAGE1DPROC GLeeFuncPtr_glCompressedTexSubImage1D=GLee_Lazy_glCompressedTexSubImage1D;
#endif
#ifndef GLEE_C_DEFINED_glGetCompressedTexImage
#define GLEE_C_DEFINED_glGetCompressedTexImage
void __stdcall GLee_Lazy_glGetCompressedTexImage(GLenum target, GLint level, GLvoid * img) {if (GLeeInit()) glGetCompressedTexImage(target, level, img);}
GLEEPFNGLGETCOMPRESSEDTEXIMAGEPROC GLeeFuncPtr_glGetCompressedTexImage=GLee_Lazy_glGetCompressedTexImage;
#endif
#endif
/* GL_VERSION_1_4 */
#ifdef __GLEE_GL_VERSION_1_4
#ifndef GLEE_C_DEFINED_glBlendFuncSeparate
#define GLEE_C_DEFINED_glBlendFuncSeparate
void __stdcall GLee_Lazy_glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) {if (GLeeInit()) glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);}
GLEEPFNGLBLENDFUNCSEPARATEPROC GLeeFuncPtr_glBlendFuncSeparate=GLee_Lazy_glBlendFuncSeparate;
#endif
#ifndef GLEE_C_DEFINED_glFogCoordf
#define GLEE_C_DEFINED_glFogCoordf
void __stdcall GLee_Lazy_glFogCoordf(GLfloat coord) {if (GLeeInit()) glFogCoordf(coord);}
GLEEPFNGLFOGCOORDFPROC GLeeFuncPtr_glFogCoordf=GLee_Lazy_glFogCoordf;
#endif
#ifndef GLEE_C_DEFINED_glFogCoordfv
#define GLEE_C_DEFINED_glFogCoordfv
void __stdcall GLee_Lazy_glFogCoordfv(const GLfloat * coord) {if (GLeeInit()) glFogCoordfv(coord);}
GLEEPFNGLFOGCOORDFVPROC GLeeFuncPtr_glFogCoordfv=GLee_Lazy_glFogCoordfv;
#endif
#ifndef GLEE_C_DEFINED_glFogCoordd
#define GLEE_C_DEFINED_glFogCoordd
void __stdcall GLee_Lazy_glFogCoordd(GLdouble coord) {if (GLeeInit()) glFogCoordd(coord);}
GLEEPFNGLFOGCOORDDPROC GLeeFuncPtr_glFogCoordd=GLee_Lazy_glFogCoordd;
#endif
#ifndef GLEE_C_DEFINED_glFogCoorddv
#define GLEE_C_DEFINED_glFogCoorddv
void __stdcall GLee_Lazy_glFogCoorddv(const GLdouble * coord) {if (GLeeInit()) glFogCoorddv(coord);}
GLEEPFNGLFOGCOORDDVPROC GLeeFuncPtr_glFogCoorddv=GLee_Lazy_glFogCoorddv;
#endif
#ifndef GLEE_C_DEFINED_glFogCoordPointer
#define GLEE_C_DEFINED_glFogCoordPointer
void __stdcall GLee_Lazy_glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid * pointer) {if (GLeeInit()) glFogCoordPointer(type, stride, pointer);}
GLEEPFNGLFOGCOORDPOINTERPROC GLeeFuncPtr_glFogCoordPointer=GLee_Lazy_glFogCoordPointer;
#endif
#ifndef GLEE_C_DEFINED_glMultiDrawArrays
#define GLEE_C_DEFINED_glMultiDrawArrays
void __stdcall GLee_Lazy_glMultiDrawArrays(GLenum mode, GLint * first, GLsizei * count, GLsizei primcount) {if (GLeeInit()) glMultiDrawArrays(mode, first, count, primcount);}
GLEEPFNGLMULTIDRAWARRAYSPROC GLeeFuncPtr_glMultiDrawArrays=GLee_Lazy_glMultiDrawArrays;
#endif
#ifndef GLEE_C_DEFINED_glMultiDrawElements
#define GLEE_C_DEFINED_glMultiDrawElements
void __stdcall GLee_Lazy_glMultiDrawElements(GLenum mode, const GLsizei * count, GLenum type, const GLvoid* * indices, GLsizei primcount) {if (GLeeInit()) glMultiDrawElements(mode, count, type, indices, primcount);}
GLEEPFNGLMULTIDRAWELEMENTSPROC GLeeFuncPtr_glMultiDrawElements=GLee_Lazy_glMultiDrawElements;
#endif
#ifndef GLEE_C_DEFINED_glPointParameterf
#define GLEE_C_DEFINED_glPointParameterf
void __stdcall GLee_Lazy_glPointParameterf(GLenum pname, GLfloat param) {if (GLeeInit()) glPointParameterf(pname, param);}
GLEEPFNGLPOINTPARAMETERFPROC GLeeFuncPtr_glPointParameterf=GLee_Lazy_glPointParameterf;
#endif
#ifndef GLEE_C_DEFINED_glPointParameterfv
#define GLEE_C_DEFINED_glPointParameterfv
void __stdcall GLee_Lazy_glPointParameterfv(GLenum pname, const GLfloat * params) {if (GLeeInit()) glPointParameterfv(pname, params);}
GLEEPFNGLPOINTPARAMETERFVPROC GLeeFuncPtr_glPointParameterfv=GLee_Lazy_glPointParameterfv;
#endif
#ifndef GLEE_C_DEFINED_glPointParameteri
#define GLEE_C_DEFINED_glPointParameteri
void __stdcall GLee_Lazy_glPointParameteri(GLenum pname, GLint param) {if (GLeeInit()) glPointParameteri(pname, param);}
GLEEPFNGLPOINTPARAMETERIPROC GLeeFuncPtr_glPointParameteri=GLee_Lazy_glPointParameteri;
#endif
#ifndef GLEE_C_DEFINED_glPointParameteriv
#define GLEE_C_DEFINED_glPointParameteriv
void __stdcall GLee_Lazy_glPointParameteriv(GLenum pname, const GLint * params) {if (GLeeInit()) glPointParameteriv(pname, params);}
GLEEPFNGLPOINTPARAMETERIVPROC GLeeFuncPtr_glPointParameteriv=GLee_Lazy_glPointParameteriv;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3b
#define GLEE_C_DEFINED_glSecondaryColor3b
void __stdcall GLee_Lazy_glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue) {if (GLeeInit()) glSecondaryColor3b(red, green, blue);}
GLEEPFNGLSECONDARYCOLOR3BPROC GLeeFuncPtr_glSecondaryColor3b=GLee_Lazy_glSecondaryColor3b;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3bv
#define GLEE_C_DEFINED_glSecondaryColor3bv
void __stdcall GLee_Lazy_glSecondaryColor3bv(const GLbyte * v) {if (GLeeInit()) glSecondaryColor3bv(v);}
GLEEPFNGLSECONDARYCOLOR3BVPROC GLeeFuncPtr_glSecondaryColor3bv=GLee_Lazy_glSecondaryColor3bv;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3d
#define GLEE_C_DEFINED_glSecondaryColor3d
void __stdcall GLee_Lazy_glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue) {if (GLeeInit()) glSecondaryColor3d(red, green, blue);}
GLEEPFNGLSECONDARYCOLOR3DPROC GLeeFuncPtr_glSecondaryColor3d=GLee_Lazy_glSecondaryColor3d;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3dv
#define GLEE_C_DEFINED_glSecondaryColor3dv
void __stdcall GLee_Lazy_glSecondaryColor3dv(const GLdouble * v) {if (GLeeInit()) glSecondaryColor3dv(v);}
GLEEPFNGLSECONDARYCOLOR3DVPROC GLeeFuncPtr_glSecondaryColor3dv=GLee_Lazy_glSecondaryColor3dv;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3f
#define GLEE_C_DEFINED_glSecondaryColor3f
void __stdcall GLee_Lazy_glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue) {if (GLeeInit()) glSecondaryColor3f(red, green, blue);}
GLEEPFNGLSECONDARYCOLOR3FPROC GLeeFuncPtr_glSecondaryColor3f=GLee_Lazy_glSecondaryColor3f;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3fv
#define GLEE_C_DEFINED_glSecondaryColor3fv
void __stdcall GLee_Lazy_glSecondaryColor3fv(const GLfloat * v) {if (GLeeInit()) glSecondaryColor3fv(v);}
GLEEPFNGLSECONDARYCOLOR3FVPROC GLeeFuncPtr_glSecondaryColor3fv=GLee_Lazy_glSecondaryColor3fv;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3i
#define GLEE_C_DEFINED_glSecondaryColor3i
void __stdcall GLee_Lazy_glSecondaryColor3i(GLint red, GLint green, GLint blue) {if (GLeeInit()) glSecondaryColor3i(red, green, blue);}
GLEEPFNGLSECONDARYCOLOR3IPROC GLeeFuncPtr_glSecondaryColor3i=GLee_Lazy_glSecondaryColor3i;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3iv
#define GLEE_C_DEFINED_glSecondaryColor3iv
void __stdcall GLee_Lazy_glSecondaryColor3iv(const GLint * v) {if (GLeeInit()) glSecondaryColor3iv(v);}
GLEEPFNGLSECONDARYCOLOR3IVPROC GLeeFuncPtr_glSecondaryColor3iv=GLee_Lazy_glSecondaryColor3iv;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3s
#define GLEE_C_DEFINED_glSecondaryColor3s
void __stdcall GLee_Lazy_glSecondaryColor3s(GLshort red, GLshort green, GLshort blue) {if (GLeeInit()) glSecondaryColor3s(red, green, blue);}
GLEEPFNGLSECONDARYCOLOR3SPROC GLeeFuncPtr_glSecondaryColor3s=GLee_Lazy_glSecondaryColor3s;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3sv
#define GLEE_C_DEFINED_glSecondaryColor3sv
void __stdcall GLee_Lazy_glSecondaryColor3sv(const GLshort * v) {if (GLeeInit()) glSecondaryColor3sv(v);}
GLEEPFNGLSECONDARYCOLOR3SVPROC GLeeFuncPtr_glSecondaryColor3sv=GLee_Lazy_glSecondaryColor3sv;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3ub
#define GLEE_C_DEFINED_glSecondaryColor3ub
void __stdcall GLee_Lazy_glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue) {if (GLeeInit()) glSecondaryColor3ub(red, green, blue);}
GLEEPFNGLSECONDARYCOLOR3UBPROC GLeeFuncPtr_glSecondaryColor3ub=GLee_Lazy_glSecondaryColor3ub;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3ubv
#define GLEE_C_DEFINED_glSecondaryColor3ubv
void __stdcall GLee_Lazy_glSecondaryColor3ubv(const GLubyte * v) {if (GLeeInit()) glSecondaryColor3ubv(v);}
GLEEPFNGLSECONDARYCOLOR3UBVPROC GLeeFuncPtr_glSecondaryColor3ubv=GLee_Lazy_glSecondaryColor3ubv;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3ui
#define GLEE_C_DEFINED_glSecondaryColor3ui
void __stdcall GLee_Lazy_glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue) {if (GLeeInit()) glSecondaryColor3ui(red, green, blue);}
GLEEPFNGLSECONDARYCOLOR3UIPROC GLeeFuncPtr_glSecondaryColor3ui=GLee_Lazy_glSecondaryColor3ui;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3uiv
#define GLEE_C_DEFINED_glSecondaryColor3uiv
void __stdcall GLee_Lazy_glSecondaryColor3uiv(const GLuint * v) {if (GLeeInit()) glSecondaryColor3uiv(v);}
GLEEPFNGLSECONDARYCOLOR3UIVPROC GLeeFuncPtr_glSecondaryColor3uiv=GLee_Lazy_glSecondaryColor3uiv;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3us
#define GLEE_C_DEFINED_glSecondaryColor3us
void __stdcall GLee_Lazy_glSecondaryColor3us(GLushort red, GLushort green, GLushort blue) {if (GLeeInit()) glSecondaryColor3us(red, green, blue);}
GLEEPFNGLSECONDARYCOLOR3USPROC GLeeFuncPtr_glSecondaryColor3us=GLee_Lazy_glSecondaryColor3us;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3usv
#define GLEE_C_DEFINED_glSecondaryColor3usv
void __stdcall GLee_Lazy_glSecondaryColor3usv(const GLushort * v) {if (GLeeInit()) glSecondaryColor3usv(v);}
GLEEPFNGLSECONDARYCOLOR3USVPROC GLeeFuncPtr_glSecondaryColor3usv=GLee_Lazy_glSecondaryColor3usv;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColorPointer
#define GLEE_C_DEFINED_glSecondaryColorPointer
void __stdcall GLee_Lazy_glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer) {if (GLeeInit()) glSecondaryColorPointer(size, type, stride, pointer);}
GLEEPFNGLSECONDARYCOLORPOINTERPROC GLeeFuncPtr_glSecondaryColorPointer=GLee_Lazy_glSecondaryColorPointer;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2d
#define GLEE_C_DEFINED_glWindowPos2d
void __stdcall GLee_Lazy_glWindowPos2d(GLdouble x, GLdouble y) {if (GLeeInit()) glWindowPos2d(x, y);}
GLEEPFNGLWINDOWPOS2DPROC GLeeFuncPtr_glWindowPos2d=GLee_Lazy_glWindowPos2d;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2dv
#define GLEE_C_DEFINED_glWindowPos2dv
void __stdcall GLee_Lazy_glWindowPos2dv(const GLdouble * v) {if (GLeeInit()) glWindowPos2dv(v);}
GLEEPFNGLWINDOWPOS2DVPROC GLeeFuncPtr_glWindowPos2dv=GLee_Lazy_glWindowPos2dv;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2f
#define GLEE_C_DEFINED_glWindowPos2f
void __stdcall GLee_Lazy_glWindowPos2f(GLfloat x, GLfloat y) {if (GLeeInit()) glWindowPos2f(x, y);}
GLEEPFNGLWINDOWPOS2FPROC GLeeFuncPtr_glWindowPos2f=GLee_Lazy_glWindowPos2f;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2fv
#define GLEE_C_DEFINED_glWindowPos2fv
void __stdcall GLee_Lazy_glWindowPos2fv(const GLfloat * v) {if (GLeeInit()) glWindowPos2fv(v);}
GLEEPFNGLWINDOWPOS2FVPROC GLeeFuncPtr_glWindowPos2fv=GLee_Lazy_glWindowPos2fv;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2i
#define GLEE_C_DEFINED_glWindowPos2i
void __stdcall GLee_Lazy_glWindowPos2i(GLint x, GLint y) {if (GLeeInit()) glWindowPos2i(x, y);}
GLEEPFNGLWINDOWPOS2IPROC GLeeFuncPtr_glWindowPos2i=GLee_Lazy_glWindowPos2i;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2iv
#define GLEE_C_DEFINED_glWindowPos2iv
void __stdcall GLee_Lazy_glWindowPos2iv(const GLint * v) {if (GLeeInit()) glWindowPos2iv(v);}
GLEEPFNGLWINDOWPOS2IVPROC GLeeFuncPtr_glWindowPos2iv=GLee_Lazy_glWindowPos2iv;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2s
#define GLEE_C_DEFINED_glWindowPos2s
void __stdcall GLee_Lazy_glWindowPos2s(GLshort x, GLshort y) {if (GLeeInit()) glWindowPos2s(x, y);}
GLEEPFNGLWINDOWPOS2SPROC GLeeFuncPtr_glWindowPos2s=GLee_Lazy_glWindowPos2s;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2sv
#define GLEE_C_DEFINED_glWindowPos2sv
void __stdcall GLee_Lazy_glWindowPos2sv(const GLshort * v) {if (GLeeInit()) glWindowPos2sv(v);}
GLEEPFNGLWINDOWPOS2SVPROC GLeeFuncPtr_glWindowPos2sv=GLee_Lazy_glWindowPos2sv;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3d
#define GLEE_C_DEFINED_glWindowPos3d
void __stdcall GLee_Lazy_glWindowPos3d(GLdouble x, GLdouble y, GLdouble z) {if (GLeeInit()) glWindowPos3d(x, y, z);}
GLEEPFNGLWINDOWPOS3DPROC GLeeFuncPtr_glWindowPos3d=GLee_Lazy_glWindowPos3d;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3dv
#define GLEE_C_DEFINED_glWindowPos3dv
void __stdcall GLee_Lazy_glWindowPos3dv(const GLdouble * v) {if (GLeeInit()) glWindowPos3dv(v);}
GLEEPFNGLWINDOWPOS3DVPROC GLeeFuncPtr_glWindowPos3dv=GLee_Lazy_glWindowPos3dv;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3f
#define GLEE_C_DEFINED_glWindowPos3f
void __stdcall GLee_Lazy_glWindowPos3f(GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glWindowPos3f(x, y, z);}
GLEEPFNGLWINDOWPOS3FPROC GLeeFuncPtr_glWindowPos3f=GLee_Lazy_glWindowPos3f;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3fv
#define GLEE_C_DEFINED_glWindowPos3fv
void __stdcall GLee_Lazy_glWindowPos3fv(const GLfloat * v) {if (GLeeInit()) glWindowPos3fv(v);}
GLEEPFNGLWINDOWPOS3FVPROC GLeeFuncPtr_glWindowPos3fv=GLee_Lazy_glWindowPos3fv;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3i
#define GLEE_C_DEFINED_glWindowPos3i
void __stdcall GLee_Lazy_glWindowPos3i(GLint x, GLint y, GLint z) {if (GLeeInit()) glWindowPos3i(x, y, z);}
GLEEPFNGLWINDOWPOS3IPROC GLeeFuncPtr_glWindowPos3i=GLee_Lazy_glWindowPos3i;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3iv
#define GLEE_C_DEFINED_glWindowPos3iv
void __stdcall GLee_Lazy_glWindowPos3iv(const GLint * v) {if (GLeeInit()) glWindowPos3iv(v);}
GLEEPFNGLWINDOWPOS3IVPROC GLeeFuncPtr_glWindowPos3iv=GLee_Lazy_glWindowPos3iv;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3s
#define GLEE_C_DEFINED_glWindowPos3s
void __stdcall GLee_Lazy_glWindowPos3s(GLshort x, GLshort y, GLshort z) {if (GLeeInit()) glWindowPos3s(x, y, z);}
GLEEPFNGLWINDOWPOS3SPROC GLeeFuncPtr_glWindowPos3s=GLee_Lazy_glWindowPos3s;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3sv
#define GLEE_C_DEFINED_glWindowPos3sv
void __stdcall GLee_Lazy_glWindowPos3sv(const GLshort * v) {if (GLeeInit()) glWindowPos3sv(v);}
GLEEPFNGLWINDOWPOS3SVPROC GLeeFuncPtr_glWindowPos3sv=GLee_Lazy_glWindowPos3sv;
#endif
#endif
/* GL_VERSION_1_5 */
#ifdef __GLEE_GL_VERSION_1_5
#ifndef GLEE_C_DEFINED_glGenQueries
#define GLEE_C_DEFINED_glGenQueries
void __stdcall GLee_Lazy_glGenQueries(GLsizei n, GLuint * ids) {if (GLeeInit()) glGenQueries(n, ids);}
GLEEPFNGLGENQUERIESPROC GLeeFuncPtr_glGenQueries=GLee_Lazy_glGenQueries;
#endif
#ifndef GLEE_C_DEFINED_glDeleteQueries
#define GLEE_C_DEFINED_glDeleteQueries
void __stdcall GLee_Lazy_glDeleteQueries(GLsizei n, const GLuint * ids) {if (GLeeInit()) glDeleteQueries(n, ids);}
GLEEPFNGLDELETEQUERIESPROC GLeeFuncPtr_glDeleteQueries=GLee_Lazy_glDeleteQueries;
#endif
#ifndef GLEE_C_DEFINED_glIsQuery
#define GLEE_C_DEFINED_glIsQuery
GLboolean __stdcall GLee_Lazy_glIsQuery(GLuint id) {if (GLeeInit()) return glIsQuery(id); return (GLboolean)0;}
GLEEPFNGLISQUERYPROC GLeeFuncPtr_glIsQuery=GLee_Lazy_glIsQuery;
#endif
#ifndef GLEE_C_DEFINED_glBeginQuery
#define GLEE_C_DEFINED_glBeginQuery
void __stdcall GLee_Lazy_glBeginQuery(GLenum target, GLuint id) {if (GLeeInit()) glBeginQuery(target, id);}
GLEEPFNGLBEGINQUERYPROC GLeeFuncPtr_glBeginQuery=GLee_Lazy_glBeginQuery;
#endif
#ifndef GLEE_C_DEFINED_glEndQuery
#define GLEE_C_DEFINED_glEndQuery
void __stdcall GLee_Lazy_glEndQuery(GLenum target) {if (GLeeInit()) glEndQuery(target);}
GLEEPFNGLENDQUERYPROC GLeeFuncPtr_glEndQuery=GLee_Lazy_glEndQuery;
#endif
#ifndef GLEE_C_DEFINED_glGetQueryiv
#define GLEE_C_DEFINED_glGetQueryiv
void __stdcall GLee_Lazy_glGetQueryiv(GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetQueryiv(target, pname, params);}
GLEEPFNGLGETQUERYIVPROC GLeeFuncPtr_glGetQueryiv=GLee_Lazy_glGetQueryiv;
#endif
#ifndef GLEE_C_DEFINED_glGetQueryObjectiv
#define GLEE_C_DEFINED_glGetQueryObjectiv
void __stdcall GLee_Lazy_glGetQueryObjectiv(GLuint id, GLenum pname, GLint * params) {if (GLeeInit()) glGetQueryObjectiv(id, pname, params);}
GLEEPFNGLGETQUERYOBJECTIVPROC GLeeFuncPtr_glGetQueryObjectiv=GLee_Lazy_glGetQueryObjectiv;
#endif
#ifndef GLEE_C_DEFINED_glGetQueryObjectuiv
#define GLEE_C_DEFINED_glGetQueryObjectuiv
void __stdcall GLee_Lazy_glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint * params) {if (GLeeInit()) glGetQueryObjectuiv(id, pname, params);}
GLEEPFNGLGETQUERYOBJECTUIVPROC GLeeFuncPtr_glGetQueryObjectuiv=GLee_Lazy_glGetQueryObjectuiv;
#endif
#ifndef GLEE_C_DEFINED_glBindBuffer
#define GLEE_C_DEFINED_glBindBuffer
void __stdcall GLee_Lazy_glBindBuffer(GLenum target, GLuint buffer) {if (GLeeInit()) glBindBuffer(target, buffer);}
GLEEPFNGLBINDBUFFERPROC GLeeFuncPtr_glBindBuffer=GLee_Lazy_glBindBuffer;
#endif
#ifndef GLEE_C_DEFINED_glDeleteBuffers
#define GLEE_C_DEFINED_glDeleteBuffers
void __stdcall GLee_Lazy_glDeleteBuffers(GLsizei n, const GLuint * buffers) {if (GLeeInit()) glDeleteBuffers(n, buffers);}
GLEEPFNGLDELETEBUFFERSPROC GLeeFuncPtr_glDeleteBuffers=GLee_Lazy_glDeleteBuffers;
#endif
#ifndef GLEE_C_DEFINED_glGenBuffers
#define GLEE_C_DEFINED_glGenBuffers
void __stdcall GLee_Lazy_glGenBuffers(GLsizei n, GLuint * buffers) {if (GLeeInit()) glGenBuffers(n, buffers);}
GLEEPFNGLGENBUFFERSPROC GLeeFuncPtr_glGenBuffers=GLee_Lazy_glGenBuffers;
#endif
#ifndef GLEE_C_DEFINED_glIsBuffer
#define GLEE_C_DEFINED_glIsBuffer
GLboolean __stdcall GLee_Lazy_glIsBuffer(GLuint buffer) {if (GLeeInit()) return glIsBuffer(buffer); return (GLboolean)0;}
GLEEPFNGLISBUFFERPROC GLeeFuncPtr_glIsBuffer=GLee_Lazy_glIsBuffer;
#endif
#ifndef GLEE_C_DEFINED_glBufferData
#define GLEE_C_DEFINED_glBufferData
void __stdcall GLee_Lazy_glBufferData(GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage) {if (GLeeInit()) glBufferData(target, size, data, usage);}
GLEEPFNGLBUFFERDATAPROC GLeeFuncPtr_glBufferData=GLee_Lazy_glBufferData;
#endif
#ifndef GLEE_C_DEFINED_glBufferSubData
#define GLEE_C_DEFINED_glBufferSubData
void __stdcall GLee_Lazy_glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data) {if (GLeeInit()) glBufferSubData(target, offset, size, data);}
GLEEPFNGLBUFFERSUBDATAPROC GLeeFuncPtr_glBufferSubData=GLee_Lazy_glBufferSubData;
#endif
#ifndef GLEE_C_DEFINED_glGetBufferSubData
#define GLEE_C_DEFINED_glGetBufferSubData
void __stdcall GLee_Lazy_glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid * data) {if (GLeeInit()) glGetBufferSubData(target, offset, size, data);}
GLEEPFNGLGETBUFFERSUBDATAPROC GLeeFuncPtr_glGetBufferSubData=GLee_Lazy_glGetBufferSubData;
#endif
#ifndef GLEE_C_DEFINED_glMapBuffer
#define GLEE_C_DEFINED_glMapBuffer
GLvoid* __stdcall GLee_Lazy_glMapBuffer(GLenum target, GLenum access) {if (GLeeInit()) return glMapBuffer(target, access); return (GLvoid*)0;}
GLEEPFNGLMAPBUFFERPROC GLeeFuncPtr_glMapBuffer=GLee_Lazy_glMapBuffer;
#endif
#ifndef GLEE_C_DEFINED_glUnmapBuffer
#define GLEE_C_DEFINED_glUnmapBuffer
GLboolean __stdcall GLee_Lazy_glUnmapBuffer(GLenum target) {if (GLeeInit()) return glUnmapBuffer(target); return (GLboolean)0;}
GLEEPFNGLUNMAPBUFFERPROC GLeeFuncPtr_glUnmapBuffer=GLee_Lazy_glUnmapBuffer;
#endif
#ifndef GLEE_C_DEFINED_glGetBufferParameteriv
#define GLEE_C_DEFINED_glGetBufferParameteriv
void __stdcall GLee_Lazy_glGetBufferParameteriv(GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetBufferParameteriv(target, pname, params);}
GLEEPFNGLGETBUFFERPARAMETERIVPROC GLeeFuncPtr_glGetBufferParameteriv=GLee_Lazy_glGetBufferParameteriv;
#endif
#ifndef GLEE_C_DEFINED_glGetBufferPointerv
#define GLEE_C_DEFINED_glGetBufferPointerv
void __stdcall GLee_Lazy_glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* * params) {if (GLeeInit()) glGetBufferPointerv(target, pname, params);}
GLEEPFNGLGETBUFFERPOINTERVPROC GLeeFuncPtr_glGetBufferPointerv=GLee_Lazy_glGetBufferPointerv;
#endif
#endif
/* GL_VERSION_2_0 */
#ifdef __GLEE_GL_VERSION_2_0
#ifndef GLEE_C_DEFINED_glBlendEquationSeparate
#define GLEE_C_DEFINED_glBlendEquationSeparate
void __stdcall GLee_Lazy_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) {if (GLeeInit()) glBlendEquationSeparate(modeRGB, modeAlpha);}
GLEEPFNGLBLENDEQUATIONSEPARATEPROC GLeeFuncPtr_glBlendEquationSeparate=GLee_Lazy_glBlendEquationSeparate;
#endif
#ifndef GLEE_C_DEFINED_glDrawBuffers
#define GLEE_C_DEFINED_glDrawBuffers
void __stdcall GLee_Lazy_glDrawBuffers(GLsizei n, const GLenum * bufs) {if (GLeeInit()) glDrawBuffers(n, bufs);}
GLEEPFNGLDRAWBUFFERSPROC GLeeFuncPtr_glDrawBuffers=GLee_Lazy_glDrawBuffers;
#endif
#ifndef GLEE_C_DEFINED_glStencilOpSeparate
#define GLEE_C_DEFINED_glStencilOpSeparate
void __stdcall GLee_Lazy_glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) {if (GLeeInit()) glStencilOpSeparate(face, sfail, dpfail, dppass);}
GLEEPFNGLSTENCILOPSEPARATEPROC GLeeFuncPtr_glStencilOpSeparate=GLee_Lazy_glStencilOpSeparate;
#endif
#ifndef GLEE_C_DEFINED_glStencilFuncSeparate
#define GLEE_C_DEFINED_glStencilFuncSeparate
void __stdcall GLee_Lazy_glStencilFuncSeparate(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask) {if (GLeeInit()) glStencilFuncSeparate(frontfunc, backfunc, ref, mask);}
GLEEPFNGLSTENCILFUNCSEPARATEPROC GLeeFuncPtr_glStencilFuncSeparate=GLee_Lazy_glStencilFuncSeparate;
#endif
#ifndef GLEE_C_DEFINED_glStencilMaskSeparate
#define GLEE_C_DEFINED_glStencilMaskSeparate
void __stdcall GLee_Lazy_glStencilMaskSeparate(GLenum face, GLuint mask) {if (GLeeInit()) glStencilMaskSeparate(face, mask);}
GLEEPFNGLSTENCILMASKSEPARATEPROC GLeeFuncPtr_glStencilMaskSeparate=GLee_Lazy_glStencilMaskSeparate;
#endif
#ifndef GLEE_C_DEFINED_glAttachShader
#define GLEE_C_DEFINED_glAttachShader
void __stdcall GLee_Lazy_glAttachShader(GLuint program, GLuint shader) {if (GLeeInit()) glAttachShader(program, shader);}
GLEEPFNGLATTACHSHADERPROC GLeeFuncPtr_glAttachShader=GLee_Lazy_glAttachShader;
#endif
#ifndef GLEE_C_DEFINED_glBindAttribLocation
#define GLEE_C_DEFINED_glBindAttribLocation
void __stdcall GLee_Lazy_glBindAttribLocation(GLuint program, GLuint index, const GLchar * name) {if (GLeeInit()) glBindAttribLocation(program, index, name);}
GLEEPFNGLBINDATTRIBLOCATIONPROC GLeeFuncPtr_glBindAttribLocation=GLee_Lazy_glBindAttribLocation;
#endif
#ifndef GLEE_C_DEFINED_glCompileShader
#define GLEE_C_DEFINED_glCompileShader
void __stdcall GLee_Lazy_glCompileShader(GLuint shader) {if (GLeeInit()) glCompileShader(shader);}
GLEEPFNGLCOMPILESHADERPROC GLeeFuncPtr_glCompileShader=GLee_Lazy_glCompileShader;
#endif
#ifndef GLEE_C_DEFINED_glCreateProgram
#define GLEE_C_DEFINED_glCreateProgram
GLuint __stdcall GLee_Lazy_glCreateProgram(void) {if (GLeeInit()) return glCreateProgram(); return (GLuint)0;}
GLEEPFNGLCREATEPROGRAMPROC GLeeFuncPtr_glCreateProgram=GLee_Lazy_glCreateProgram;
#endif
#ifndef GLEE_C_DEFINED_glCreateShader
#define GLEE_C_DEFINED_glCreateShader
GLuint __stdcall GLee_Lazy_glCreateShader(GLenum type) {if (GLeeInit()) return glCreateShader(type); return (GLuint)0;}
GLEEPFNGLCREATESHADERPROC GLeeFuncPtr_glCreateShader=GLee_Lazy_glCreateShader;
#endif
#ifndef GLEE_C_DEFINED_glDeleteProgram
#define GLEE_C_DEFINED_glDeleteProgram
void __stdcall GLee_Lazy_glDeleteProgram(GLuint program) {if (GLeeInit()) glDeleteProgram(program);}
GLEEPFNGLDELETEPROGRAMPROC GLeeFuncPtr_glDeleteProgram=GLee_Lazy_glDeleteProgram;
#endif
#ifndef GLEE_C_DEFINED_glDeleteShader
#define GLEE_C_DEFINED_glDeleteShader
void __stdcall GLee_Lazy_glDeleteShader(GLuint shader) {if (GLeeInit()) glDeleteShader(shader);}
GLEEPFNGLDELETESHADERPROC GLeeFuncPtr_glDeleteShader=GLee_Lazy_glDeleteShader;
#endif
#ifndef GLEE_C_DEFINED_glDetachShader
#define GLEE_C_DEFINED_glDetachShader
void __stdcall GLee_Lazy_glDetachShader(GLuint program, GLuint shader) {if (GLeeInit()) glDetachShader(program, shader);}
GLEEPFNGLDETACHSHADERPROC GLeeFuncPtr_glDetachShader=GLee_Lazy_glDetachShader;
#endif
#ifndef GLEE_C_DEFINED_glDisableVertexAttribArray
#define GLEE_C_DEFINED_glDisableVertexAttribArray
void __stdcall GLee_Lazy_glDisableVertexAttribArray(GLuint index) {if (GLeeInit()) glDisableVertexAttribArray(index);}
GLEEPFNGLDISABLEVERTEXATTRIBARRAYPROC GLeeFuncPtr_glDisableVertexAttribArray=GLee_Lazy_glDisableVertexAttribArray;
#endif
#ifndef GLEE_C_DEFINED_glEnableVertexAttribArray
#define GLEE_C_DEFINED_glEnableVertexAttribArray
void __stdcall GLee_Lazy_glEnableVertexAttribArray(GLuint index) {if (GLeeInit()) glEnableVertexAttribArray(index);}
GLEEPFNGLENABLEVERTEXATTRIBARRAYPROC GLeeFuncPtr_glEnableVertexAttribArray=GLee_Lazy_glEnableVertexAttribArray;
#endif
#ifndef GLEE_C_DEFINED_glGetActiveAttrib
#define GLEE_C_DEFINED_glGetActiveAttrib
void __stdcall GLee_Lazy_glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name) {if (GLeeInit()) glGetActiveAttrib(program, index, bufSize, length, size, type, name);}
GLEEPFNGLGETACTIVEATTRIBPROC GLeeFuncPtr_glGetActiveAttrib=GLee_Lazy_glGetActiveAttrib;
#endif
#ifndef GLEE_C_DEFINED_glGetActiveUniform
#define GLEE_C_DEFINED_glGetActiveUniform
void __stdcall GLee_Lazy_glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name) {if (GLeeInit()) glGetActiveUniform(program, index, bufSize, length, size, type, name);}
GLEEPFNGLGETACTIVEUNIFORMPROC GLeeFuncPtr_glGetActiveUniform=GLee_Lazy_glGetActiveUniform;
#endif
#ifndef GLEE_C_DEFINED_glGetAttachedShaders
#define GLEE_C_DEFINED_glGetAttachedShaders
void __stdcall GLee_Lazy_glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei * count, GLuint * obj) {if (GLeeInit()) glGetAttachedShaders(program, maxCount, count, obj);}
GLEEPFNGLGETATTACHEDSHADERSPROC GLeeFuncPtr_glGetAttachedShaders=GLee_Lazy_glGetAttachedShaders;
#endif
#ifndef GLEE_C_DEFINED_glGetAttribLocation
#define GLEE_C_DEFINED_glGetAttribLocation
GLint __stdcall GLee_Lazy_glGetAttribLocation(GLuint program, const GLchar * name) {if (GLeeInit()) return glGetAttribLocation(program, name); return (GLint)0;}
GLEEPFNGLGETATTRIBLOCATIONPROC GLeeFuncPtr_glGetAttribLocation=GLee_Lazy_glGetAttribLocation;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramiv
#define GLEE_C_DEFINED_glGetProgramiv
void __stdcall GLee_Lazy_glGetProgramiv(GLuint program, GLenum pname, GLint * params) {if (GLeeInit()) glGetProgramiv(program, pname, params);}
GLEEPFNGLGETPROGRAMIVPROC GLeeFuncPtr_glGetProgramiv=GLee_Lazy_glGetProgramiv;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramInfoLog
#define GLEE_C_DEFINED_glGetProgramInfoLog
void __stdcall GLee_Lazy_glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog) {if (GLeeInit()) glGetProgramInfoLog(program, bufSize, length, infoLog);}
GLEEPFNGLGETPROGRAMINFOLOGPROC GLeeFuncPtr_glGetProgramInfoLog=GLee_Lazy_glGetProgramInfoLog;
#endif
#ifndef GLEE_C_DEFINED_glGetShaderiv
#define GLEE_C_DEFINED_glGetShaderiv
void __stdcall GLee_Lazy_glGetShaderiv(GLuint shader, GLenum pname, GLint * params) {if (GLeeInit()) glGetShaderiv(shader, pname, params);}
GLEEPFNGLGETSHADERIVPROC GLeeFuncPtr_glGetShaderiv=GLee_Lazy_glGetShaderiv;
#endif
#ifndef GLEE_C_DEFINED_glGetShaderInfoLog
#define GLEE_C_DEFINED_glGetShaderInfoLog
void __stdcall GLee_Lazy_glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * infoLog) {if (GLeeInit()) glGetShaderInfoLog(shader, bufSize, length, infoLog);}
GLEEPFNGLGETSHADERINFOLOGPROC GLeeFuncPtr_glGetShaderInfoLog=GLee_Lazy_glGetShaderInfoLog;
#endif
#ifndef GLEE_C_DEFINED_glGetShaderSource
#define GLEE_C_DEFINED_glGetShaderSource
void __stdcall GLee_Lazy_glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * source) {if (GLeeInit()) glGetShaderSource(shader, bufSize, length, source);}
GLEEPFNGLGETSHADERSOURCEPROC GLeeFuncPtr_glGetShaderSource=GLee_Lazy_glGetShaderSource;
#endif
#ifndef GLEE_C_DEFINED_glGetUniformLocation
#define GLEE_C_DEFINED_glGetUniformLocation
GLint __stdcall GLee_Lazy_glGetUniformLocation(GLuint program, const GLchar * name) {if (GLeeInit()) return glGetUniformLocation(program, name); return (GLint)0;}
GLEEPFNGLGETUNIFORMLOCATIONPROC GLeeFuncPtr_glGetUniformLocation=GLee_Lazy_glGetUniformLocation;
#endif
#ifndef GLEE_C_DEFINED_glGetUniformfv
#define GLEE_C_DEFINED_glGetUniformfv
void __stdcall GLee_Lazy_glGetUniformfv(GLuint program, GLint location, GLfloat * params) {if (GLeeInit()) glGetUniformfv(program, location, params);}
GLEEPFNGLGETUNIFORMFVPROC GLeeFuncPtr_glGetUniformfv=GLee_Lazy_glGetUniformfv;
#endif
#ifndef GLEE_C_DEFINED_glGetUniformiv
#define GLEE_C_DEFINED_glGetUniformiv
void __stdcall GLee_Lazy_glGetUniformiv(GLuint program, GLint location, GLint * params) {if (GLeeInit()) glGetUniformiv(program, location, params);}
GLEEPFNGLGETUNIFORMIVPROC GLeeFuncPtr_glGetUniformiv=GLee_Lazy_glGetUniformiv;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribdv
#define GLEE_C_DEFINED_glGetVertexAttribdv
void __stdcall GLee_Lazy_glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble * params) {if (GLeeInit()) glGetVertexAttribdv(index, pname, params);}
GLEEPFNGLGETVERTEXATTRIBDVPROC GLeeFuncPtr_glGetVertexAttribdv=GLee_Lazy_glGetVertexAttribdv;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribfv
#define GLEE_C_DEFINED_glGetVertexAttribfv
void __stdcall GLee_Lazy_glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetVertexAttribfv(index, pname, params);}
GLEEPFNGLGETVERTEXATTRIBFVPROC GLeeFuncPtr_glGetVertexAttribfv=GLee_Lazy_glGetVertexAttribfv;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribiv
#define GLEE_C_DEFINED_glGetVertexAttribiv
void __stdcall GLee_Lazy_glGetVertexAttribiv(GLuint index, GLenum pname, GLint * params) {if (GLeeInit()) glGetVertexAttribiv(index, pname, params);}
GLEEPFNGLGETVERTEXATTRIBIVPROC GLeeFuncPtr_glGetVertexAttribiv=GLee_Lazy_glGetVertexAttribiv;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribPointerv
#define GLEE_C_DEFINED_glGetVertexAttribPointerv
void __stdcall GLee_Lazy_glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* * pointer) {if (GLeeInit()) glGetVertexAttribPointerv(index, pname, pointer);}
GLEEPFNGLGETVERTEXATTRIBPOINTERVPROC GLeeFuncPtr_glGetVertexAttribPointerv=GLee_Lazy_glGetVertexAttribPointerv;
#endif
#ifndef GLEE_C_DEFINED_glIsProgram
#define GLEE_C_DEFINED_glIsProgram
GLboolean __stdcall GLee_Lazy_glIsProgram(GLuint program) {if (GLeeInit()) return glIsProgram(program); return (GLboolean)0;}
GLEEPFNGLISPROGRAMPROC GLeeFuncPtr_glIsProgram=GLee_Lazy_glIsProgram;
#endif
#ifndef GLEE_C_DEFINED_glIsShader
#define GLEE_C_DEFINED_glIsShader
GLboolean __stdcall GLee_Lazy_glIsShader(GLuint shader) {if (GLeeInit()) return glIsShader(shader); return (GLboolean)0;}
GLEEPFNGLISSHADERPROC GLeeFuncPtr_glIsShader=GLee_Lazy_glIsShader;
#endif
#ifndef GLEE_C_DEFINED_glLinkProgram
#define GLEE_C_DEFINED_glLinkProgram
void __stdcall GLee_Lazy_glLinkProgram(GLuint program) {if (GLeeInit()) glLinkProgram(program);}
GLEEPFNGLLINKPROGRAMPROC GLeeFuncPtr_glLinkProgram=GLee_Lazy_glLinkProgram;
#endif
#ifndef GLEE_C_DEFINED_glShaderSource
#define GLEE_C_DEFINED_glShaderSource
void __stdcall GLee_Lazy_glShaderSource(GLuint shader, GLsizei count, const GLchar* * string, const GLint * length) {if (GLeeInit()) glShaderSource(shader, count, string, length);}
GLEEPFNGLSHADERSOURCEPROC GLeeFuncPtr_glShaderSource=GLee_Lazy_glShaderSource;
#endif
#ifndef GLEE_C_DEFINED_glUseProgram
#define GLEE_C_DEFINED_glUseProgram
void __stdcall GLee_Lazy_glUseProgram(GLuint program) {if (GLeeInit()) glUseProgram(program);}
GLEEPFNGLUSEPROGRAMPROC GLeeFuncPtr_glUseProgram=GLee_Lazy_glUseProgram;
#endif
#ifndef GLEE_C_DEFINED_glUniform1f
#define GLEE_C_DEFINED_glUniform1f
void __stdcall GLee_Lazy_glUniform1f(GLint location, GLfloat v0) {if (GLeeInit()) glUniform1f(location, v0);}
GLEEPFNGLUNIFORM1FPROC GLeeFuncPtr_glUniform1f=GLee_Lazy_glUniform1f;
#endif
#ifndef GLEE_C_DEFINED_glUniform2f
#define GLEE_C_DEFINED_glUniform2f
void __stdcall GLee_Lazy_glUniform2f(GLint location, GLfloat v0, GLfloat v1) {if (GLeeInit()) glUniform2f(location, v0, v1);}
GLEEPFNGLUNIFORM2FPROC GLeeFuncPtr_glUniform2f=GLee_Lazy_glUniform2f;
#endif
#ifndef GLEE_C_DEFINED_glUniform3f
#define GLEE_C_DEFINED_glUniform3f
void __stdcall GLee_Lazy_glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {if (GLeeInit()) glUniform3f(location, v0, v1, v2);}
GLEEPFNGLUNIFORM3FPROC GLeeFuncPtr_glUniform3f=GLee_Lazy_glUniform3f;
#endif
#ifndef GLEE_C_DEFINED_glUniform4f
#define GLEE_C_DEFINED_glUniform4f
void __stdcall GLee_Lazy_glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {if (GLeeInit()) glUniform4f(location, v0, v1, v2, v3);}
GLEEPFNGLUNIFORM4FPROC GLeeFuncPtr_glUniform4f=GLee_Lazy_glUniform4f;
#endif
#ifndef GLEE_C_DEFINED_glUniform1i
#define GLEE_C_DEFINED_glUniform1i
void __stdcall GLee_Lazy_glUniform1i(GLint location, GLint v0) {if (GLeeInit()) glUniform1i(location, v0);}
GLEEPFNGLUNIFORM1IPROC GLeeFuncPtr_glUniform1i=GLee_Lazy_glUniform1i;
#endif
#ifndef GLEE_C_DEFINED_glUniform2i
#define GLEE_C_DEFINED_glUniform2i
void __stdcall GLee_Lazy_glUniform2i(GLint location, GLint v0, GLint v1) {if (GLeeInit()) glUniform2i(location, v0, v1);}
GLEEPFNGLUNIFORM2IPROC GLeeFuncPtr_glUniform2i=GLee_Lazy_glUniform2i;
#endif
#ifndef GLEE_C_DEFINED_glUniform3i
#define GLEE_C_DEFINED_glUniform3i
void __stdcall GLee_Lazy_glUniform3i(GLint location, GLint v0, GLint v1, GLint v2) {if (GLeeInit()) glUniform3i(location, v0, v1, v2);}
GLEEPFNGLUNIFORM3IPROC GLeeFuncPtr_glUniform3i=GLee_Lazy_glUniform3i;
#endif
#ifndef GLEE_C_DEFINED_glUniform4i
#define GLEE_C_DEFINED_glUniform4i
void __stdcall GLee_Lazy_glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {if (GLeeInit()) glUniform4i(location, v0, v1, v2, v3);}
GLEEPFNGLUNIFORM4IPROC GLeeFuncPtr_glUniform4i=GLee_Lazy_glUniform4i;
#endif
#ifndef GLEE_C_DEFINED_glUniform1fv
#define GLEE_C_DEFINED_glUniform1fv
void __stdcall GLee_Lazy_glUniform1fv(GLint location, GLsizei count, const GLfloat * value) {if (GLeeInit()) glUniform1fv(location, count, value);}
GLEEPFNGLUNIFORM1FVPROC GLeeFuncPtr_glUniform1fv=GLee_Lazy_glUniform1fv;
#endif
#ifndef GLEE_C_DEFINED_glUniform2fv
#define GLEE_C_DEFINED_glUniform2fv
void __stdcall GLee_Lazy_glUniform2fv(GLint location, GLsizei count, const GLfloat * value) {if (GLeeInit()) glUniform2fv(location, count, value);}
GLEEPFNGLUNIFORM2FVPROC GLeeFuncPtr_glUniform2fv=GLee_Lazy_glUniform2fv;
#endif
#ifndef GLEE_C_DEFINED_glUniform3fv
#define GLEE_C_DEFINED_glUniform3fv
void __stdcall GLee_Lazy_glUniform3fv(GLint location, GLsizei count, const GLfloat * value) {if (GLeeInit()) glUniform3fv(location, count, value);}
GLEEPFNGLUNIFORM3FVPROC GLeeFuncPtr_glUniform3fv=GLee_Lazy_glUniform3fv;
#endif
#ifndef GLEE_C_DEFINED_glUniform4fv
#define GLEE_C_DEFINED_glUniform4fv
void __stdcall GLee_Lazy_glUniform4fv(GLint location, GLsizei count, const GLfloat * value) {if (GLeeInit()) glUniform4fv(location, count, value);}
GLEEPFNGLUNIFORM4FVPROC GLeeFuncPtr_glUniform4fv=GLee_Lazy_glUniform4fv;
#endif
#ifndef GLEE_C_DEFINED_glUniform1iv
#define GLEE_C_DEFINED_glUniform1iv
void __stdcall GLee_Lazy_glUniform1iv(GLint location, GLsizei count, const GLint * value) {if (GLeeInit()) glUniform1iv(location, count, value);}
GLEEPFNGLUNIFORM1IVPROC GLeeFuncPtr_glUniform1iv=GLee_Lazy_glUniform1iv;
#endif
#ifndef GLEE_C_DEFINED_glUniform2iv
#define GLEE_C_DEFINED_glUniform2iv
void __stdcall GLee_Lazy_glUniform2iv(GLint location, GLsizei count, const GLint * value) {if (GLeeInit()) glUniform2iv(location, count, value);}
GLEEPFNGLUNIFORM2IVPROC GLeeFuncPtr_glUniform2iv=GLee_Lazy_glUniform2iv;
#endif
#ifndef GLEE_C_DEFINED_glUniform3iv
#define GLEE_C_DEFINED_glUniform3iv
void __stdcall GLee_Lazy_glUniform3iv(GLint location, GLsizei count, const GLint * value) {if (GLeeInit()) glUniform3iv(location, count, value);}
GLEEPFNGLUNIFORM3IVPROC GLeeFuncPtr_glUniform3iv=GLee_Lazy_glUniform3iv;
#endif
#ifndef GLEE_C_DEFINED_glUniform4iv
#define GLEE_C_DEFINED_glUniform4iv
void __stdcall GLee_Lazy_glUniform4iv(GLint location, GLsizei count, const GLint * value) {if (GLeeInit()) glUniform4iv(location, count, value);}
GLEEPFNGLUNIFORM4IVPROC GLeeFuncPtr_glUniform4iv=GLee_Lazy_glUniform4iv;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix2fv
#define GLEE_C_DEFINED_glUniformMatrix2fv
void __stdcall GLee_Lazy_glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glUniformMatrix2fv(location, count, transpose, value);}
GLEEPFNGLUNIFORMMATRIX2FVPROC GLeeFuncPtr_glUniformMatrix2fv=GLee_Lazy_glUniformMatrix2fv;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix3fv
#define GLEE_C_DEFINED_glUniformMatrix3fv
void __stdcall GLee_Lazy_glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glUniformMatrix3fv(location, count, transpose, value);}
GLEEPFNGLUNIFORMMATRIX3FVPROC GLeeFuncPtr_glUniformMatrix3fv=GLee_Lazy_glUniformMatrix3fv;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix4fv
#define GLEE_C_DEFINED_glUniformMatrix4fv
void __stdcall GLee_Lazy_glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glUniformMatrix4fv(location, count, transpose, value);}
GLEEPFNGLUNIFORMMATRIX4FVPROC GLeeFuncPtr_glUniformMatrix4fv=GLee_Lazy_glUniformMatrix4fv;
#endif
#ifndef GLEE_C_DEFINED_glValidateProgram
#define GLEE_C_DEFINED_glValidateProgram
void __stdcall GLee_Lazy_glValidateProgram(GLuint program) {if (GLeeInit()) glValidateProgram(program);}
GLEEPFNGLVALIDATEPROGRAMPROC GLeeFuncPtr_glValidateProgram=GLee_Lazy_glValidateProgram;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1d
#define GLEE_C_DEFINED_glVertexAttrib1d
void __stdcall GLee_Lazy_glVertexAttrib1d(GLuint index, GLdouble x) {if (GLeeInit()) glVertexAttrib1d(index, x);}
GLEEPFNGLVERTEXATTRIB1DPROC GLeeFuncPtr_glVertexAttrib1d=GLee_Lazy_glVertexAttrib1d;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1dv
#define GLEE_C_DEFINED_glVertexAttrib1dv
void __stdcall GLee_Lazy_glVertexAttrib1dv(GLuint index, const GLdouble * v) {if (GLeeInit()) glVertexAttrib1dv(index, v);}
GLEEPFNGLVERTEXATTRIB1DVPROC GLeeFuncPtr_glVertexAttrib1dv=GLee_Lazy_glVertexAttrib1dv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1f
#define GLEE_C_DEFINED_glVertexAttrib1f
void __stdcall GLee_Lazy_glVertexAttrib1f(GLuint index, GLfloat x) {if (GLeeInit()) glVertexAttrib1f(index, x);}
GLEEPFNGLVERTEXATTRIB1FPROC GLeeFuncPtr_glVertexAttrib1f=GLee_Lazy_glVertexAttrib1f;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1fv
#define GLEE_C_DEFINED_glVertexAttrib1fv
void __stdcall GLee_Lazy_glVertexAttrib1fv(GLuint index, const GLfloat * v) {if (GLeeInit()) glVertexAttrib1fv(index, v);}
GLEEPFNGLVERTEXATTRIB1FVPROC GLeeFuncPtr_glVertexAttrib1fv=GLee_Lazy_glVertexAttrib1fv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1s
#define GLEE_C_DEFINED_glVertexAttrib1s
void __stdcall GLee_Lazy_glVertexAttrib1s(GLuint index, GLshort x) {if (GLeeInit()) glVertexAttrib1s(index, x);}
GLEEPFNGLVERTEXATTRIB1SPROC GLeeFuncPtr_glVertexAttrib1s=GLee_Lazy_glVertexAttrib1s;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1sv
#define GLEE_C_DEFINED_glVertexAttrib1sv
void __stdcall GLee_Lazy_glVertexAttrib1sv(GLuint index, const GLshort * v) {if (GLeeInit()) glVertexAttrib1sv(index, v);}
GLEEPFNGLVERTEXATTRIB1SVPROC GLeeFuncPtr_glVertexAttrib1sv=GLee_Lazy_glVertexAttrib1sv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2d
#define GLEE_C_DEFINED_glVertexAttrib2d
void __stdcall GLee_Lazy_glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y) {if (GLeeInit()) glVertexAttrib2d(index, x, y);}
GLEEPFNGLVERTEXATTRIB2DPROC GLeeFuncPtr_glVertexAttrib2d=GLee_Lazy_glVertexAttrib2d;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2dv
#define GLEE_C_DEFINED_glVertexAttrib2dv
void __stdcall GLee_Lazy_glVertexAttrib2dv(GLuint index, const GLdouble * v) {if (GLeeInit()) glVertexAttrib2dv(index, v);}
GLEEPFNGLVERTEXATTRIB2DVPROC GLeeFuncPtr_glVertexAttrib2dv=GLee_Lazy_glVertexAttrib2dv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2f
#define GLEE_C_DEFINED_glVertexAttrib2f
void __stdcall GLee_Lazy_glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y) {if (GLeeInit()) glVertexAttrib2f(index, x, y);}
GLEEPFNGLVERTEXATTRIB2FPROC GLeeFuncPtr_glVertexAttrib2f=GLee_Lazy_glVertexAttrib2f;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2fv
#define GLEE_C_DEFINED_glVertexAttrib2fv
void __stdcall GLee_Lazy_glVertexAttrib2fv(GLuint index, const GLfloat * v) {if (GLeeInit()) glVertexAttrib2fv(index, v);}
GLEEPFNGLVERTEXATTRIB2FVPROC GLeeFuncPtr_glVertexAttrib2fv=GLee_Lazy_glVertexAttrib2fv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2s
#define GLEE_C_DEFINED_glVertexAttrib2s
void __stdcall GLee_Lazy_glVertexAttrib2s(GLuint index, GLshort x, GLshort y) {if (GLeeInit()) glVertexAttrib2s(index, x, y);}
GLEEPFNGLVERTEXATTRIB2SPROC GLeeFuncPtr_glVertexAttrib2s=GLee_Lazy_glVertexAttrib2s;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2sv
#define GLEE_C_DEFINED_glVertexAttrib2sv
void __stdcall GLee_Lazy_glVertexAttrib2sv(GLuint index, const GLshort * v) {if (GLeeInit()) glVertexAttrib2sv(index, v);}
GLEEPFNGLVERTEXATTRIB2SVPROC GLeeFuncPtr_glVertexAttrib2sv=GLee_Lazy_glVertexAttrib2sv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3d
#define GLEE_C_DEFINED_glVertexAttrib3d
void __stdcall GLee_Lazy_glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z) {if (GLeeInit()) glVertexAttrib3d(index, x, y, z);}
GLEEPFNGLVERTEXATTRIB3DPROC GLeeFuncPtr_glVertexAttrib3d=GLee_Lazy_glVertexAttrib3d;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3dv
#define GLEE_C_DEFINED_glVertexAttrib3dv
void __stdcall GLee_Lazy_glVertexAttrib3dv(GLuint index, const GLdouble * v) {if (GLeeInit()) glVertexAttrib3dv(index, v);}
GLEEPFNGLVERTEXATTRIB3DVPROC GLeeFuncPtr_glVertexAttrib3dv=GLee_Lazy_glVertexAttrib3dv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3f
#define GLEE_C_DEFINED_glVertexAttrib3f
void __stdcall GLee_Lazy_glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glVertexAttrib3f(index, x, y, z);}
GLEEPFNGLVERTEXATTRIB3FPROC GLeeFuncPtr_glVertexAttrib3f=GLee_Lazy_glVertexAttrib3f;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3fv
#define GLEE_C_DEFINED_glVertexAttrib3fv
void __stdcall GLee_Lazy_glVertexAttrib3fv(GLuint index, const GLfloat * v) {if (GLeeInit()) glVertexAttrib3fv(index, v);}
GLEEPFNGLVERTEXATTRIB3FVPROC GLeeFuncPtr_glVertexAttrib3fv=GLee_Lazy_glVertexAttrib3fv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3s
#define GLEE_C_DEFINED_glVertexAttrib3s
void __stdcall GLee_Lazy_glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z) {if (GLeeInit()) glVertexAttrib3s(index, x, y, z);}
GLEEPFNGLVERTEXATTRIB3SPROC GLeeFuncPtr_glVertexAttrib3s=GLee_Lazy_glVertexAttrib3s;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3sv
#define GLEE_C_DEFINED_glVertexAttrib3sv
void __stdcall GLee_Lazy_glVertexAttrib3sv(GLuint index, const GLshort * v) {if (GLeeInit()) glVertexAttrib3sv(index, v);}
GLEEPFNGLVERTEXATTRIB3SVPROC GLeeFuncPtr_glVertexAttrib3sv=GLee_Lazy_glVertexAttrib3sv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4Nbv
#define GLEE_C_DEFINED_glVertexAttrib4Nbv
void __stdcall GLee_Lazy_glVertexAttrib4Nbv(GLuint index, const GLbyte * v) {if (GLeeInit()) glVertexAttrib4Nbv(index, v);}
GLEEPFNGLVERTEXATTRIB4NBVPROC GLeeFuncPtr_glVertexAttrib4Nbv=GLee_Lazy_glVertexAttrib4Nbv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4Niv
#define GLEE_C_DEFINED_glVertexAttrib4Niv
void __stdcall GLee_Lazy_glVertexAttrib4Niv(GLuint index, const GLint * v) {if (GLeeInit()) glVertexAttrib4Niv(index, v);}
GLEEPFNGLVERTEXATTRIB4NIVPROC GLeeFuncPtr_glVertexAttrib4Niv=GLee_Lazy_glVertexAttrib4Niv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4Nsv
#define GLEE_C_DEFINED_glVertexAttrib4Nsv
void __stdcall GLee_Lazy_glVertexAttrib4Nsv(GLuint index, const GLshort * v) {if (GLeeInit()) glVertexAttrib4Nsv(index, v);}
GLEEPFNGLVERTEXATTRIB4NSVPROC GLeeFuncPtr_glVertexAttrib4Nsv=GLee_Lazy_glVertexAttrib4Nsv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4Nub
#define GLEE_C_DEFINED_glVertexAttrib4Nub
void __stdcall GLee_Lazy_glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) {if (GLeeInit()) glVertexAttrib4Nub(index, x, y, z, w);}
GLEEPFNGLVERTEXATTRIB4NUBPROC GLeeFuncPtr_glVertexAttrib4Nub=GLee_Lazy_glVertexAttrib4Nub;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4Nubv
#define GLEE_C_DEFINED_glVertexAttrib4Nubv
void __stdcall GLee_Lazy_glVertexAttrib4Nubv(GLuint index, const GLubyte * v) {if (GLeeInit()) glVertexAttrib4Nubv(index, v);}
GLEEPFNGLVERTEXATTRIB4NUBVPROC GLeeFuncPtr_glVertexAttrib4Nubv=GLee_Lazy_glVertexAttrib4Nubv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4Nuiv
#define GLEE_C_DEFINED_glVertexAttrib4Nuiv
void __stdcall GLee_Lazy_glVertexAttrib4Nuiv(GLuint index, const GLuint * v) {if (GLeeInit()) glVertexAttrib4Nuiv(index, v);}
GLEEPFNGLVERTEXATTRIB4NUIVPROC GLeeFuncPtr_glVertexAttrib4Nuiv=GLee_Lazy_glVertexAttrib4Nuiv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4Nusv
#define GLEE_C_DEFINED_glVertexAttrib4Nusv
void __stdcall GLee_Lazy_glVertexAttrib4Nusv(GLuint index, const GLushort * v) {if (GLeeInit()) glVertexAttrib4Nusv(index, v);}
GLEEPFNGLVERTEXATTRIB4NUSVPROC GLeeFuncPtr_glVertexAttrib4Nusv=GLee_Lazy_glVertexAttrib4Nusv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4bv
#define GLEE_C_DEFINED_glVertexAttrib4bv
void __stdcall GLee_Lazy_glVertexAttrib4bv(GLuint index, const GLbyte * v) {if (GLeeInit()) glVertexAttrib4bv(index, v);}
GLEEPFNGLVERTEXATTRIB4BVPROC GLeeFuncPtr_glVertexAttrib4bv=GLee_Lazy_glVertexAttrib4bv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4d
#define GLEE_C_DEFINED_glVertexAttrib4d
void __stdcall GLee_Lazy_glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {if (GLeeInit()) glVertexAttrib4d(index, x, y, z, w);}
GLEEPFNGLVERTEXATTRIB4DPROC GLeeFuncPtr_glVertexAttrib4d=GLee_Lazy_glVertexAttrib4d;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4dv
#define GLEE_C_DEFINED_glVertexAttrib4dv
void __stdcall GLee_Lazy_glVertexAttrib4dv(GLuint index, const GLdouble * v) {if (GLeeInit()) glVertexAttrib4dv(index, v);}
GLEEPFNGLVERTEXATTRIB4DVPROC GLeeFuncPtr_glVertexAttrib4dv=GLee_Lazy_glVertexAttrib4dv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4f
#define GLEE_C_DEFINED_glVertexAttrib4f
void __stdcall GLee_Lazy_glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {if (GLeeInit()) glVertexAttrib4f(index, x, y, z, w);}
GLEEPFNGLVERTEXATTRIB4FPROC GLeeFuncPtr_glVertexAttrib4f=GLee_Lazy_glVertexAttrib4f;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4fv
#define GLEE_C_DEFINED_glVertexAttrib4fv
void __stdcall GLee_Lazy_glVertexAttrib4fv(GLuint index, const GLfloat * v) {if (GLeeInit()) glVertexAttrib4fv(index, v);}
GLEEPFNGLVERTEXATTRIB4FVPROC GLeeFuncPtr_glVertexAttrib4fv=GLee_Lazy_glVertexAttrib4fv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4iv
#define GLEE_C_DEFINED_glVertexAttrib4iv
void __stdcall GLee_Lazy_glVertexAttrib4iv(GLuint index, const GLint * v) {if (GLeeInit()) glVertexAttrib4iv(index, v);}
GLEEPFNGLVERTEXATTRIB4IVPROC GLeeFuncPtr_glVertexAttrib4iv=GLee_Lazy_glVertexAttrib4iv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4s
#define GLEE_C_DEFINED_glVertexAttrib4s
void __stdcall GLee_Lazy_glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) {if (GLeeInit()) glVertexAttrib4s(index, x, y, z, w);}
GLEEPFNGLVERTEXATTRIB4SPROC GLeeFuncPtr_glVertexAttrib4s=GLee_Lazy_glVertexAttrib4s;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4sv
#define GLEE_C_DEFINED_glVertexAttrib4sv
void __stdcall GLee_Lazy_glVertexAttrib4sv(GLuint index, const GLshort * v) {if (GLeeInit()) glVertexAttrib4sv(index, v);}
GLEEPFNGLVERTEXATTRIB4SVPROC GLeeFuncPtr_glVertexAttrib4sv=GLee_Lazy_glVertexAttrib4sv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4ubv
#define GLEE_C_DEFINED_glVertexAttrib4ubv
void __stdcall GLee_Lazy_glVertexAttrib4ubv(GLuint index, const GLubyte * v) {if (GLeeInit()) glVertexAttrib4ubv(index, v);}
GLEEPFNGLVERTEXATTRIB4UBVPROC GLeeFuncPtr_glVertexAttrib4ubv=GLee_Lazy_glVertexAttrib4ubv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4uiv
#define GLEE_C_DEFINED_glVertexAttrib4uiv
void __stdcall GLee_Lazy_glVertexAttrib4uiv(GLuint index, const GLuint * v) {if (GLeeInit()) glVertexAttrib4uiv(index, v);}
GLEEPFNGLVERTEXATTRIB4UIVPROC GLeeFuncPtr_glVertexAttrib4uiv=GLee_Lazy_glVertexAttrib4uiv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4usv
#define GLEE_C_DEFINED_glVertexAttrib4usv
void __stdcall GLee_Lazy_glVertexAttrib4usv(GLuint index, const GLushort * v) {if (GLeeInit()) glVertexAttrib4usv(index, v);}
GLEEPFNGLVERTEXATTRIB4USVPROC GLeeFuncPtr_glVertexAttrib4usv=GLee_Lazy_glVertexAttrib4usv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribPointer
#define GLEE_C_DEFINED_glVertexAttribPointer
void __stdcall GLee_Lazy_glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer) {if (GLeeInit()) glVertexAttribPointer(index, size, type, normalized, stride, pointer);}
GLEEPFNGLVERTEXATTRIBPOINTERPROC GLeeFuncPtr_glVertexAttribPointer=GLee_Lazy_glVertexAttribPointer;
#endif
#endif
/* GL_VERSION_2_1 */
#ifdef __GLEE_GL_VERSION_2_1
#ifndef GLEE_C_DEFINED_glUniformMatrix2x3fv
#define GLEE_C_DEFINED_glUniformMatrix2x3fv
void __stdcall GLee_Lazy_glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glUniformMatrix2x3fv(location, count, transpose, value);}
GLEEPFNGLUNIFORMMATRIX2X3FVPROC GLeeFuncPtr_glUniformMatrix2x3fv=GLee_Lazy_glUniformMatrix2x3fv;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix3x2fv
#define GLEE_C_DEFINED_glUniformMatrix3x2fv
void __stdcall GLee_Lazy_glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glUniformMatrix3x2fv(location, count, transpose, value);}
GLEEPFNGLUNIFORMMATRIX3X2FVPROC GLeeFuncPtr_glUniformMatrix3x2fv=GLee_Lazy_glUniformMatrix3x2fv;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix2x4fv
#define GLEE_C_DEFINED_glUniformMatrix2x4fv
void __stdcall GLee_Lazy_glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glUniformMatrix2x4fv(location, count, transpose, value);}
GLEEPFNGLUNIFORMMATRIX2X4FVPROC GLeeFuncPtr_glUniformMatrix2x4fv=GLee_Lazy_glUniformMatrix2x4fv;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix4x2fv
#define GLEE_C_DEFINED_glUniformMatrix4x2fv
void __stdcall GLee_Lazy_glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glUniformMatrix4x2fv(location, count, transpose, value);}
GLEEPFNGLUNIFORMMATRIX4X2FVPROC GLeeFuncPtr_glUniformMatrix4x2fv=GLee_Lazy_glUniformMatrix4x2fv;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix3x4fv
#define GLEE_C_DEFINED_glUniformMatrix3x4fv
void __stdcall GLee_Lazy_glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glUniformMatrix3x4fv(location, count, transpose, value);}
GLEEPFNGLUNIFORMMATRIX3X4FVPROC GLeeFuncPtr_glUniformMatrix3x4fv=GLee_Lazy_glUniformMatrix3x4fv;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix4x3fv
#define GLEE_C_DEFINED_glUniformMatrix4x3fv
void __stdcall GLee_Lazy_glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glUniformMatrix4x3fv(location, count, transpose, value);}
GLEEPFNGLUNIFORMMATRIX4X3FVPROC GLeeFuncPtr_glUniformMatrix4x3fv=GLee_Lazy_glUniformMatrix4x3fv;
#endif
#endif
/* GL_VERSION_3_0 */
#ifdef __GLEE_GL_VERSION_3_0
#ifndef GLEE_C_DEFINED_glColorMaski
#define GLEE_C_DEFINED_glColorMaski
void __stdcall GLee_Lazy_glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) {if (GLeeInit()) glColorMaski(index, r, g, b, a);}
GLEEPFNGLCOLORMASKIPROC GLeeFuncPtr_glColorMaski=GLee_Lazy_glColorMaski;
#endif
#ifndef GLEE_C_DEFINED_glGetBooleani_v
#define GLEE_C_DEFINED_glGetBooleani_v
void __stdcall GLee_Lazy_glGetBooleani_v(GLenum target, GLuint index, GLboolean * data) {if (GLeeInit()) glGetBooleani_v(target, index, data);}
GLEEPFNGLGETBOOLEANI_VPROC GLeeFuncPtr_glGetBooleani_v=GLee_Lazy_glGetBooleani_v;
#endif
#ifndef GLEE_C_DEFINED_glGetIntegeri_v
#define GLEE_C_DEFINED_glGetIntegeri_v
void __stdcall GLee_Lazy_glGetIntegeri_v(GLenum target, GLuint index, GLint * data) {if (GLeeInit()) glGetIntegeri_v(target, index, data);}
GLEEPFNGLGETINTEGERI_VPROC GLeeFuncPtr_glGetIntegeri_v=GLee_Lazy_glGetIntegeri_v;
#endif
#ifndef GLEE_C_DEFINED_glEnablei
#define GLEE_C_DEFINED_glEnablei
void __stdcall GLee_Lazy_glEnablei(GLenum target, GLuint index) {if (GLeeInit()) glEnablei(target, index);}
GLEEPFNGLENABLEIPROC GLeeFuncPtr_glEnablei=GLee_Lazy_glEnablei;
#endif
#ifndef GLEE_C_DEFINED_glDisablei
#define GLEE_C_DEFINED_glDisablei
void __stdcall GLee_Lazy_glDisablei(GLenum target, GLuint index) {if (GLeeInit()) glDisablei(target, index);}
GLEEPFNGLDISABLEIPROC GLeeFuncPtr_glDisablei=GLee_Lazy_glDisablei;
#endif
#ifndef GLEE_C_DEFINED_glIsEnabledi
#define GLEE_C_DEFINED_glIsEnabledi
GLboolean __stdcall GLee_Lazy_glIsEnabledi(GLenum target, GLuint index) {if (GLeeInit()) return glIsEnabledi(target, index); return (GLboolean)0;}
GLEEPFNGLISENABLEDIPROC GLeeFuncPtr_glIsEnabledi=GLee_Lazy_glIsEnabledi;
#endif
#ifndef GLEE_C_DEFINED_glBeginTransformFeedback
#define GLEE_C_DEFINED_glBeginTransformFeedback
void __stdcall GLee_Lazy_glBeginTransformFeedback(GLenum primitiveMode) {if (GLeeInit()) glBeginTransformFeedback(primitiveMode);}
GLEEPFNGLBEGINTRANSFORMFEEDBACKPROC GLeeFuncPtr_glBeginTransformFeedback=GLee_Lazy_glBeginTransformFeedback;
#endif
#ifndef GLEE_C_DEFINED_glEndTransformFeedback
#define GLEE_C_DEFINED_glEndTransformFeedback
void __stdcall GLee_Lazy_glEndTransformFeedback(void) {if (GLeeInit()) glEndTransformFeedback();}
GLEEPFNGLENDTRANSFORMFEEDBACKPROC GLeeFuncPtr_glEndTransformFeedback=GLee_Lazy_glEndTransformFeedback;
#endif
#ifndef GLEE_C_DEFINED_glBindBufferRange
#define GLEE_C_DEFINED_glBindBufferRange
void __stdcall GLee_Lazy_glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) {if (GLeeInit()) glBindBufferRange(target, index, buffer, offset, size);}
GLEEPFNGLBINDBUFFERRANGEPROC GLeeFuncPtr_glBindBufferRange=GLee_Lazy_glBindBufferRange;
#endif
#ifndef GLEE_C_DEFINED_glBindBufferBase
#define GLEE_C_DEFINED_glBindBufferBase
void __stdcall GLee_Lazy_glBindBufferBase(GLenum target, GLuint index, GLuint buffer) {if (GLeeInit()) glBindBufferBase(target, index, buffer);}
GLEEPFNGLBINDBUFFERBASEPROC GLeeFuncPtr_glBindBufferBase=GLee_Lazy_glBindBufferBase;
#endif
#ifndef GLEE_C_DEFINED_glTransformFeedbackVaryings
#define GLEE_C_DEFINED_glTransformFeedbackVaryings
void __stdcall GLee_Lazy_glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLint * locations, GLenum bufferMode) {if (GLeeInit()) glTransformFeedbackVaryings(program, count, locations, bufferMode);}
GLEEPFNGLTRANSFORMFEEDBACKVARYINGSPROC GLeeFuncPtr_glTransformFeedbackVaryings=GLee_Lazy_glTransformFeedbackVaryings;
#endif
#ifndef GLEE_C_DEFINED_glGetTransformFeedbackVarying
#define GLEE_C_DEFINED_glGetTransformFeedbackVarying
void __stdcall GLee_Lazy_glGetTransformFeedbackVarying(GLuint program, GLuint index, GLint * location) {if (GLeeInit()) glGetTransformFeedbackVarying(program, index, location);}
GLEEPFNGLGETTRANSFORMFEEDBACKVARYINGPROC GLeeFuncPtr_glGetTransformFeedbackVarying=GLee_Lazy_glGetTransformFeedbackVarying;
#endif
#ifndef GLEE_C_DEFINED_glClampColor
#define GLEE_C_DEFINED_glClampColor
void __stdcall GLee_Lazy_glClampColor(GLenum target, GLenum clamp) {if (GLeeInit()) glClampColor(target, clamp);}
GLEEPFNGLCLAMPCOLORPROC GLeeFuncPtr_glClampColor=GLee_Lazy_glClampColor;
#endif
#ifndef GLEE_C_DEFINED_glBeginConditionalRender
#define GLEE_C_DEFINED_glBeginConditionalRender
void __stdcall GLee_Lazy_glBeginConditionalRender(GLuint id, GLenum mode) {if (GLeeInit()) glBeginConditionalRender(id, mode);}
GLEEPFNGLBEGINCONDITIONALRENDERPROC GLeeFuncPtr_glBeginConditionalRender=GLee_Lazy_glBeginConditionalRender;
#endif
#ifndef GLEE_C_DEFINED_glEndConditionalRender
#define GLEE_C_DEFINED_glEndConditionalRender
void __stdcall GLee_Lazy_glEndConditionalRender(void) {if (GLeeInit()) glEndConditionalRender();}
GLEEPFNGLENDCONDITIONALRENDERPROC GLeeFuncPtr_glEndConditionalRender=GLee_Lazy_glEndConditionalRender;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI1i
#define GLEE_C_DEFINED_glVertexAttribI1i
void __stdcall GLee_Lazy_glVertexAttribI1i(GLuint index, GLint x) {if (GLeeInit()) glVertexAttribI1i(index, x);}
GLEEPFNGLVERTEXATTRIBI1IPROC GLeeFuncPtr_glVertexAttribI1i=GLee_Lazy_glVertexAttribI1i;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI2i
#define GLEE_C_DEFINED_glVertexAttribI2i
void __stdcall GLee_Lazy_glVertexAttribI2i(GLuint index, GLint x, GLint y) {if (GLeeInit()) glVertexAttribI2i(index, x, y);}
GLEEPFNGLVERTEXATTRIBI2IPROC GLeeFuncPtr_glVertexAttribI2i=GLee_Lazy_glVertexAttribI2i;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI3i
#define GLEE_C_DEFINED_glVertexAttribI3i
void __stdcall GLee_Lazy_glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z) {if (GLeeInit()) glVertexAttribI3i(index, x, y, z);}
GLEEPFNGLVERTEXATTRIBI3IPROC GLeeFuncPtr_glVertexAttribI3i=GLee_Lazy_glVertexAttribI3i;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4i
#define GLEE_C_DEFINED_glVertexAttribI4i
void __stdcall GLee_Lazy_glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) {if (GLeeInit()) glVertexAttribI4i(index, x, y, z, w);}
GLEEPFNGLVERTEXATTRIBI4IPROC GLeeFuncPtr_glVertexAttribI4i=GLee_Lazy_glVertexAttribI4i;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI1ui
#define GLEE_C_DEFINED_glVertexAttribI1ui
void __stdcall GLee_Lazy_glVertexAttribI1ui(GLuint index, GLuint x) {if (GLeeInit()) glVertexAttribI1ui(index, x);}
GLEEPFNGLVERTEXATTRIBI1UIPROC GLeeFuncPtr_glVertexAttribI1ui=GLee_Lazy_glVertexAttribI1ui;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI2ui
#define GLEE_C_DEFINED_glVertexAttribI2ui
void __stdcall GLee_Lazy_glVertexAttribI2ui(GLuint index, GLuint x, GLuint y) {if (GLeeInit()) glVertexAttribI2ui(index, x, y);}
GLEEPFNGLVERTEXATTRIBI2UIPROC GLeeFuncPtr_glVertexAttribI2ui=GLee_Lazy_glVertexAttribI2ui;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI3ui
#define GLEE_C_DEFINED_glVertexAttribI3ui
void __stdcall GLee_Lazy_glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z) {if (GLeeInit()) glVertexAttribI3ui(index, x, y, z);}
GLEEPFNGLVERTEXATTRIBI3UIPROC GLeeFuncPtr_glVertexAttribI3ui=GLee_Lazy_glVertexAttribI3ui;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4ui
#define GLEE_C_DEFINED_glVertexAttribI4ui
void __stdcall GLee_Lazy_glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) {if (GLeeInit()) glVertexAttribI4ui(index, x, y, z, w);}
GLEEPFNGLVERTEXATTRIBI4UIPROC GLeeFuncPtr_glVertexAttribI4ui=GLee_Lazy_glVertexAttribI4ui;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI1iv
#define GLEE_C_DEFINED_glVertexAttribI1iv
void __stdcall GLee_Lazy_glVertexAttribI1iv(GLuint index, const GLint * v) {if (GLeeInit()) glVertexAttribI1iv(index, v);}
GLEEPFNGLVERTEXATTRIBI1IVPROC GLeeFuncPtr_glVertexAttribI1iv=GLee_Lazy_glVertexAttribI1iv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI2iv
#define GLEE_C_DEFINED_glVertexAttribI2iv
void __stdcall GLee_Lazy_glVertexAttribI2iv(GLuint index, const GLint * v) {if (GLeeInit()) glVertexAttribI2iv(index, v);}
GLEEPFNGLVERTEXATTRIBI2IVPROC GLeeFuncPtr_glVertexAttribI2iv=GLee_Lazy_glVertexAttribI2iv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI3iv
#define GLEE_C_DEFINED_glVertexAttribI3iv
void __stdcall GLee_Lazy_glVertexAttribI3iv(GLuint index, const GLint * v) {if (GLeeInit()) glVertexAttribI3iv(index, v);}
GLEEPFNGLVERTEXATTRIBI3IVPROC GLeeFuncPtr_glVertexAttribI3iv=GLee_Lazy_glVertexAttribI3iv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4iv
#define GLEE_C_DEFINED_glVertexAttribI4iv
void __stdcall GLee_Lazy_glVertexAttribI4iv(GLuint index, const GLint * v) {if (GLeeInit()) glVertexAttribI4iv(index, v);}
GLEEPFNGLVERTEXATTRIBI4IVPROC GLeeFuncPtr_glVertexAttribI4iv=GLee_Lazy_glVertexAttribI4iv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI1uiv
#define GLEE_C_DEFINED_glVertexAttribI1uiv
void __stdcall GLee_Lazy_glVertexAttribI1uiv(GLuint index, const GLuint * v) {if (GLeeInit()) glVertexAttribI1uiv(index, v);}
GLEEPFNGLVERTEXATTRIBI1UIVPROC GLeeFuncPtr_glVertexAttribI1uiv=GLee_Lazy_glVertexAttribI1uiv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI2uiv
#define GLEE_C_DEFINED_glVertexAttribI2uiv
void __stdcall GLee_Lazy_glVertexAttribI2uiv(GLuint index, const GLuint * v) {if (GLeeInit()) glVertexAttribI2uiv(index, v);}
GLEEPFNGLVERTEXATTRIBI2UIVPROC GLeeFuncPtr_glVertexAttribI2uiv=GLee_Lazy_glVertexAttribI2uiv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI3uiv
#define GLEE_C_DEFINED_glVertexAttribI3uiv
void __stdcall GLee_Lazy_glVertexAttribI3uiv(GLuint index, const GLuint * v) {if (GLeeInit()) glVertexAttribI3uiv(index, v);}
GLEEPFNGLVERTEXATTRIBI3UIVPROC GLeeFuncPtr_glVertexAttribI3uiv=GLee_Lazy_glVertexAttribI3uiv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4uiv
#define GLEE_C_DEFINED_glVertexAttribI4uiv
void __stdcall GLee_Lazy_glVertexAttribI4uiv(GLuint index, const GLuint * v) {if (GLeeInit()) glVertexAttribI4uiv(index, v);}
GLEEPFNGLVERTEXATTRIBI4UIVPROC GLeeFuncPtr_glVertexAttribI4uiv=GLee_Lazy_glVertexAttribI4uiv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4bv
#define GLEE_C_DEFINED_glVertexAttribI4bv
void __stdcall GLee_Lazy_glVertexAttribI4bv(GLuint index, const GLbyte * v) {if (GLeeInit()) glVertexAttribI4bv(index, v);}
GLEEPFNGLVERTEXATTRIBI4BVPROC GLeeFuncPtr_glVertexAttribI4bv=GLee_Lazy_glVertexAttribI4bv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4sv
#define GLEE_C_DEFINED_glVertexAttribI4sv
void __stdcall GLee_Lazy_glVertexAttribI4sv(GLuint index, const GLshort * v) {if (GLeeInit()) glVertexAttribI4sv(index, v);}
GLEEPFNGLVERTEXATTRIBI4SVPROC GLeeFuncPtr_glVertexAttribI4sv=GLee_Lazy_glVertexAttribI4sv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4ubv
#define GLEE_C_DEFINED_glVertexAttribI4ubv
void __stdcall GLee_Lazy_glVertexAttribI4ubv(GLuint index, const GLubyte * v) {if (GLeeInit()) glVertexAttribI4ubv(index, v);}
GLEEPFNGLVERTEXATTRIBI4UBVPROC GLeeFuncPtr_glVertexAttribI4ubv=GLee_Lazy_glVertexAttribI4ubv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4usv
#define GLEE_C_DEFINED_glVertexAttribI4usv
void __stdcall GLee_Lazy_glVertexAttribI4usv(GLuint index, const GLushort * v) {if (GLeeInit()) glVertexAttribI4usv(index, v);}
GLEEPFNGLVERTEXATTRIBI4USVPROC GLeeFuncPtr_glVertexAttribI4usv=GLee_Lazy_glVertexAttribI4usv;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribIPointer
#define GLEE_C_DEFINED_glVertexAttribIPointer
void __stdcall GLee_Lazy_glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer) {if (GLeeInit()) glVertexAttribIPointer(index, size, type, stride, pointer);}
GLEEPFNGLVERTEXATTRIBIPOINTERPROC GLeeFuncPtr_glVertexAttribIPointer=GLee_Lazy_glVertexAttribIPointer;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribIiv
#define GLEE_C_DEFINED_glGetVertexAttribIiv
void __stdcall GLee_Lazy_glGetVertexAttribIiv(GLuint index, GLenum pname, GLint * params) {if (GLeeInit()) glGetVertexAttribIiv(index, pname, params);}
GLEEPFNGLGETVERTEXATTRIBIIVPROC GLeeFuncPtr_glGetVertexAttribIiv=GLee_Lazy_glGetVertexAttribIiv;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribIuiv
#define GLEE_C_DEFINED_glGetVertexAttribIuiv
void __stdcall GLee_Lazy_glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint * params) {if (GLeeInit()) glGetVertexAttribIuiv(index, pname, params);}
GLEEPFNGLGETVERTEXATTRIBIUIVPROC GLeeFuncPtr_glGetVertexAttribIuiv=GLee_Lazy_glGetVertexAttribIuiv;
#endif
#ifndef GLEE_C_DEFINED_glGetUniformuiv
#define GLEE_C_DEFINED_glGetUniformuiv
void __stdcall GLee_Lazy_glGetUniformuiv(GLuint program, GLint location, GLuint * params) {if (GLeeInit()) glGetUniformuiv(program, location, params);}
GLEEPFNGLGETUNIFORMUIVPROC GLeeFuncPtr_glGetUniformuiv=GLee_Lazy_glGetUniformuiv;
#endif
#ifndef GLEE_C_DEFINED_glBindFragDataLocation
#define GLEE_C_DEFINED_glBindFragDataLocation
void __stdcall GLee_Lazy_glBindFragDataLocation(GLuint program, GLuint color, const GLchar * name) {if (GLeeInit()) glBindFragDataLocation(program, color, name);}
GLEEPFNGLBINDFRAGDATALOCATIONPROC GLeeFuncPtr_glBindFragDataLocation=GLee_Lazy_glBindFragDataLocation;
#endif
#ifndef GLEE_C_DEFINED_glGetFragDataLocation
#define GLEE_C_DEFINED_glGetFragDataLocation
GLint __stdcall GLee_Lazy_glGetFragDataLocation(GLuint program, const GLchar * name) {if (GLeeInit()) return glGetFragDataLocation(program, name); return (GLint)0;}
GLEEPFNGLGETFRAGDATALOCATIONPROC GLeeFuncPtr_glGetFragDataLocation=GLee_Lazy_glGetFragDataLocation;
#endif
#ifndef GLEE_C_DEFINED_glUniform1ui
#define GLEE_C_DEFINED_glUniform1ui
void __stdcall GLee_Lazy_glUniform1ui(GLint location, GLuint v0) {if (GLeeInit()) glUniform1ui(location, v0);}
GLEEPFNGLUNIFORM1UIPROC GLeeFuncPtr_glUniform1ui=GLee_Lazy_glUniform1ui;
#endif
#ifndef GLEE_C_DEFINED_glUniform2ui
#define GLEE_C_DEFINED_glUniform2ui
void __stdcall GLee_Lazy_glUniform2ui(GLint location, GLuint v0, GLuint v1) {if (GLeeInit()) glUniform2ui(location, v0, v1);}
GLEEPFNGLUNIFORM2UIPROC GLeeFuncPtr_glUniform2ui=GLee_Lazy_glUniform2ui;
#endif
#ifndef GLEE_C_DEFINED_glUniform3ui
#define GLEE_C_DEFINED_glUniform3ui
void __stdcall GLee_Lazy_glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) {if (GLeeInit()) glUniform3ui(location, v0, v1, v2);}
GLEEPFNGLUNIFORM3UIPROC GLeeFuncPtr_glUniform3ui=GLee_Lazy_glUniform3ui;
#endif
#ifndef GLEE_C_DEFINED_glUniform4ui
#define GLEE_C_DEFINED_glUniform4ui
void __stdcall GLee_Lazy_glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) {if (GLeeInit()) glUniform4ui(location, v0, v1, v2, v3);}
GLEEPFNGLUNIFORM4UIPROC GLeeFuncPtr_glUniform4ui=GLee_Lazy_glUniform4ui;
#endif
#ifndef GLEE_C_DEFINED_glUniform1uiv
#define GLEE_C_DEFINED_glUniform1uiv
void __stdcall GLee_Lazy_glUniform1uiv(GLint location, GLsizei count, const GLuint * value) {if (GLeeInit()) glUniform1uiv(location, count, value);}
GLEEPFNGLUNIFORM1UIVPROC GLeeFuncPtr_glUniform1uiv=GLee_Lazy_glUniform1uiv;
#endif
#ifndef GLEE_C_DEFINED_glUniform2uiv
#define GLEE_C_DEFINED_glUniform2uiv
void __stdcall GLee_Lazy_glUniform2uiv(GLint location, GLsizei count, const GLuint * value) {if (GLeeInit()) glUniform2uiv(location, count, value);}
GLEEPFNGLUNIFORM2UIVPROC GLeeFuncPtr_glUniform2uiv=GLee_Lazy_glUniform2uiv;
#endif
#ifndef GLEE_C_DEFINED_glUniform3uiv
#define GLEE_C_DEFINED_glUniform3uiv
void __stdcall GLee_Lazy_glUniform3uiv(GLint location, GLsizei count, const GLuint * value) {if (GLeeInit()) glUniform3uiv(location, count, value);}
GLEEPFNGLUNIFORM3UIVPROC GLeeFuncPtr_glUniform3uiv=GLee_Lazy_glUniform3uiv;
#endif
#ifndef GLEE_C_DEFINED_glUniform4uiv
#define GLEE_C_DEFINED_glUniform4uiv
void __stdcall GLee_Lazy_glUniform4uiv(GLint location, GLsizei count, const GLuint * value) {if (GLeeInit()) glUniform4uiv(location, count, value);}
GLEEPFNGLUNIFORM4UIVPROC GLeeFuncPtr_glUniform4uiv=GLee_Lazy_glUniform4uiv;
#endif
#ifndef GLEE_C_DEFINED_glTexParameterIiv
#define GLEE_C_DEFINED_glTexParameterIiv
void __stdcall GLee_Lazy_glTexParameterIiv(GLenum target, GLenum pname, const GLint * params) {if (GLeeInit()) glTexParameterIiv(target, pname, params);}
GLEEPFNGLTEXPARAMETERIIVPROC GLeeFuncPtr_glTexParameterIiv=GLee_Lazy_glTexParameterIiv;
#endif
#ifndef GLEE_C_DEFINED_glTexParameterIuiv
#define GLEE_C_DEFINED_glTexParameterIuiv
void __stdcall GLee_Lazy_glTexParameterIuiv(GLenum target, GLenum pname, const GLuint * params) {if (GLeeInit()) glTexParameterIuiv(target, pname, params);}
GLEEPFNGLTEXPARAMETERIUIVPROC GLeeFuncPtr_glTexParameterIuiv=GLee_Lazy_glTexParameterIuiv;
#endif
#ifndef GLEE_C_DEFINED_glGetTexParameterIiv
#define GLEE_C_DEFINED_glGetTexParameterIiv
void __stdcall GLee_Lazy_glGetTexParameterIiv(GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetTexParameterIiv(target, pname, params);}
GLEEPFNGLGETTEXPARAMETERIIVPROC GLeeFuncPtr_glGetTexParameterIiv=GLee_Lazy_glGetTexParameterIiv;
#endif
#ifndef GLEE_C_DEFINED_glGetTexParameterIuiv
#define GLEE_C_DEFINED_glGetTexParameterIuiv
void __stdcall GLee_Lazy_glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint * params) {if (GLeeInit()) glGetTexParameterIuiv(target, pname, params);}
GLEEPFNGLGETTEXPARAMETERIUIVPROC GLeeFuncPtr_glGetTexParameterIuiv=GLee_Lazy_glGetTexParameterIuiv;
#endif
#ifndef GLEE_C_DEFINED_glClearBufferiv
#define GLEE_C_DEFINED_glClearBufferiv
void __stdcall GLee_Lazy_glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint * value) {if (GLeeInit()) glClearBufferiv(buffer, drawbuffer, value);}
GLEEPFNGLCLEARBUFFERIVPROC GLeeFuncPtr_glClearBufferiv=GLee_Lazy_glClearBufferiv;
#endif
#ifndef GLEE_C_DEFINED_glClearBufferuiv
#define GLEE_C_DEFINED_glClearBufferuiv
void __stdcall GLee_Lazy_glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint * value) {if (GLeeInit()) glClearBufferuiv(buffer, drawbuffer, value);}
GLEEPFNGLCLEARBUFFERUIVPROC GLeeFuncPtr_glClearBufferuiv=GLee_Lazy_glClearBufferuiv;
#endif
#ifndef GLEE_C_DEFINED_glClearBufferfv
#define GLEE_C_DEFINED_glClearBufferfv
void __stdcall GLee_Lazy_glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat * value) {if (GLeeInit()) glClearBufferfv(buffer, drawbuffer, value);}
GLEEPFNGLCLEARBUFFERFVPROC GLeeFuncPtr_glClearBufferfv=GLee_Lazy_glClearBufferfv;
#endif
#ifndef GLEE_C_DEFINED_glClearBufferfi
#define GLEE_C_DEFINED_glClearBufferfi
void __stdcall GLee_Lazy_glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) {if (GLeeInit()) glClearBufferfi(buffer, drawbuffer, depth, stencil);}
GLEEPFNGLCLEARBUFFERFIPROC GLeeFuncPtr_glClearBufferfi=GLee_Lazy_glClearBufferfi;
#endif
#ifndef GLEE_C_DEFINED_glGetStringi
#define GLEE_C_DEFINED_glGetStringi
const GLubyte * __stdcall GLee_Lazy_glGetStringi(GLenum name, GLuint index) {if (GLeeInit()) return glGetStringi(name, index); return (const GLubyte *)0;}
GLEEPFNGLGETSTRINGIPROC GLeeFuncPtr_glGetStringi=GLee_Lazy_glGetStringi;
#endif
#endif
/* GL_ARB_multitexture */
#ifdef __GLEE_GL_ARB_multitexture
#ifndef GLEE_C_DEFINED_glActiveTextureARB
#define GLEE_C_DEFINED_glActiveTextureARB
void __stdcall GLee_Lazy_glActiveTextureARB(GLenum texture) {if (GLeeInit()) glActiveTextureARB(texture);}
GLEEPFNGLACTIVETEXTUREARBPROC GLeeFuncPtr_glActiveTextureARB=GLee_Lazy_glActiveTextureARB;
#endif
#ifndef GLEE_C_DEFINED_glClientActiveTextureARB
#define GLEE_C_DEFINED_glClientActiveTextureARB
void __stdcall GLee_Lazy_glClientActiveTextureARB(GLenum texture) {if (GLeeInit()) glClientActiveTextureARB(texture);}
GLEEPFNGLCLIENTACTIVETEXTUREARBPROC GLeeFuncPtr_glClientActiveTextureARB=GLee_Lazy_glClientActiveTextureARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1dARB
#define GLEE_C_DEFINED_glMultiTexCoord1dARB
void __stdcall GLee_Lazy_glMultiTexCoord1dARB(GLenum target, GLdouble s) {if (GLeeInit()) glMultiTexCoord1dARB(target, s);}
GLEEPFNGLMULTITEXCOORD1DARBPROC GLeeFuncPtr_glMultiTexCoord1dARB=GLee_Lazy_glMultiTexCoord1dARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1dvARB
#define GLEE_C_DEFINED_glMultiTexCoord1dvARB
void __stdcall GLee_Lazy_glMultiTexCoord1dvARB(GLenum target, const GLdouble * v) {if (GLeeInit()) glMultiTexCoord1dvARB(target, v);}
GLEEPFNGLMULTITEXCOORD1DVARBPROC GLeeFuncPtr_glMultiTexCoord1dvARB=GLee_Lazy_glMultiTexCoord1dvARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1fARB
#define GLEE_C_DEFINED_glMultiTexCoord1fARB
void __stdcall GLee_Lazy_glMultiTexCoord1fARB(GLenum target, GLfloat s) {if (GLeeInit()) glMultiTexCoord1fARB(target, s);}
GLEEPFNGLMULTITEXCOORD1FARBPROC GLeeFuncPtr_glMultiTexCoord1fARB=GLee_Lazy_glMultiTexCoord1fARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1fvARB
#define GLEE_C_DEFINED_glMultiTexCoord1fvARB
void __stdcall GLee_Lazy_glMultiTexCoord1fvARB(GLenum target, const GLfloat * v) {if (GLeeInit()) glMultiTexCoord1fvARB(target, v);}
GLEEPFNGLMULTITEXCOORD1FVARBPROC GLeeFuncPtr_glMultiTexCoord1fvARB=GLee_Lazy_glMultiTexCoord1fvARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1iARB
#define GLEE_C_DEFINED_glMultiTexCoord1iARB
void __stdcall GLee_Lazy_glMultiTexCoord1iARB(GLenum target, GLint s) {if (GLeeInit()) glMultiTexCoord1iARB(target, s);}
GLEEPFNGLMULTITEXCOORD1IARBPROC GLeeFuncPtr_glMultiTexCoord1iARB=GLee_Lazy_glMultiTexCoord1iARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1ivARB
#define GLEE_C_DEFINED_glMultiTexCoord1ivARB
void __stdcall GLee_Lazy_glMultiTexCoord1ivARB(GLenum target, const GLint * v) {if (GLeeInit()) glMultiTexCoord1ivARB(target, v);}
GLEEPFNGLMULTITEXCOORD1IVARBPROC GLeeFuncPtr_glMultiTexCoord1ivARB=GLee_Lazy_glMultiTexCoord1ivARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1sARB
#define GLEE_C_DEFINED_glMultiTexCoord1sARB
void __stdcall GLee_Lazy_glMultiTexCoord1sARB(GLenum target, GLshort s) {if (GLeeInit()) glMultiTexCoord1sARB(target, s);}
GLEEPFNGLMULTITEXCOORD1SARBPROC GLeeFuncPtr_glMultiTexCoord1sARB=GLee_Lazy_glMultiTexCoord1sARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1svARB
#define GLEE_C_DEFINED_glMultiTexCoord1svARB
void __stdcall GLee_Lazy_glMultiTexCoord1svARB(GLenum target, const GLshort * v) {if (GLeeInit()) glMultiTexCoord1svARB(target, v);}
GLEEPFNGLMULTITEXCOORD1SVARBPROC GLeeFuncPtr_glMultiTexCoord1svARB=GLee_Lazy_glMultiTexCoord1svARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2dARB
#define GLEE_C_DEFINED_glMultiTexCoord2dARB
void __stdcall GLee_Lazy_glMultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t) {if (GLeeInit()) glMultiTexCoord2dARB(target, s, t);}
GLEEPFNGLMULTITEXCOORD2DARBPROC GLeeFuncPtr_glMultiTexCoord2dARB=GLee_Lazy_glMultiTexCoord2dARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2dvARB
#define GLEE_C_DEFINED_glMultiTexCoord2dvARB
void __stdcall GLee_Lazy_glMultiTexCoord2dvARB(GLenum target, const GLdouble * v) {if (GLeeInit()) glMultiTexCoord2dvARB(target, v);}
GLEEPFNGLMULTITEXCOORD2DVARBPROC GLeeFuncPtr_glMultiTexCoord2dvARB=GLee_Lazy_glMultiTexCoord2dvARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2fARB
#define GLEE_C_DEFINED_glMultiTexCoord2fARB
void __stdcall GLee_Lazy_glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t) {if (GLeeInit()) glMultiTexCoord2fARB(target, s, t);}
GLEEPFNGLMULTITEXCOORD2FARBPROC GLeeFuncPtr_glMultiTexCoord2fARB=GLee_Lazy_glMultiTexCoord2fARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2fvARB
#define GLEE_C_DEFINED_glMultiTexCoord2fvARB
void __stdcall GLee_Lazy_glMultiTexCoord2fvARB(GLenum target, const GLfloat * v) {if (GLeeInit()) glMultiTexCoord2fvARB(target, v);}
GLEEPFNGLMULTITEXCOORD2FVARBPROC GLeeFuncPtr_glMultiTexCoord2fvARB=GLee_Lazy_glMultiTexCoord2fvARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2iARB
#define GLEE_C_DEFINED_glMultiTexCoord2iARB
void __stdcall GLee_Lazy_glMultiTexCoord2iARB(GLenum target, GLint s, GLint t) {if (GLeeInit()) glMultiTexCoord2iARB(target, s, t);}
GLEEPFNGLMULTITEXCOORD2IARBPROC GLeeFuncPtr_glMultiTexCoord2iARB=GLee_Lazy_glMultiTexCoord2iARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2ivARB
#define GLEE_C_DEFINED_glMultiTexCoord2ivARB
void __stdcall GLee_Lazy_glMultiTexCoord2ivARB(GLenum target, const GLint * v) {if (GLeeInit()) glMultiTexCoord2ivARB(target, v);}
GLEEPFNGLMULTITEXCOORD2IVARBPROC GLeeFuncPtr_glMultiTexCoord2ivARB=GLee_Lazy_glMultiTexCoord2ivARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2sARB
#define GLEE_C_DEFINED_glMultiTexCoord2sARB
void __stdcall GLee_Lazy_glMultiTexCoord2sARB(GLenum target, GLshort s, GLshort t) {if (GLeeInit()) glMultiTexCoord2sARB(target, s, t);}
GLEEPFNGLMULTITEXCOORD2SARBPROC GLeeFuncPtr_glMultiTexCoord2sARB=GLee_Lazy_glMultiTexCoord2sARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2svARB
#define GLEE_C_DEFINED_glMultiTexCoord2svARB
void __stdcall GLee_Lazy_glMultiTexCoord2svARB(GLenum target, const GLshort * v) {if (GLeeInit()) glMultiTexCoord2svARB(target, v);}
GLEEPFNGLMULTITEXCOORD2SVARBPROC GLeeFuncPtr_glMultiTexCoord2svARB=GLee_Lazy_glMultiTexCoord2svARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3dARB
#define GLEE_C_DEFINED_glMultiTexCoord3dARB
void __stdcall GLee_Lazy_glMultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r) {if (GLeeInit()) glMultiTexCoord3dARB(target, s, t, r);}
GLEEPFNGLMULTITEXCOORD3DARBPROC GLeeFuncPtr_glMultiTexCoord3dARB=GLee_Lazy_glMultiTexCoord3dARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3dvARB
#define GLEE_C_DEFINED_glMultiTexCoord3dvARB
void __stdcall GLee_Lazy_glMultiTexCoord3dvARB(GLenum target, const GLdouble * v) {if (GLeeInit()) glMultiTexCoord3dvARB(target, v);}
GLEEPFNGLMULTITEXCOORD3DVARBPROC GLeeFuncPtr_glMultiTexCoord3dvARB=GLee_Lazy_glMultiTexCoord3dvARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3fARB
#define GLEE_C_DEFINED_glMultiTexCoord3fARB
void __stdcall GLee_Lazy_glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r) {if (GLeeInit()) glMultiTexCoord3fARB(target, s, t, r);}
GLEEPFNGLMULTITEXCOORD3FARBPROC GLeeFuncPtr_glMultiTexCoord3fARB=GLee_Lazy_glMultiTexCoord3fARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3fvARB
#define GLEE_C_DEFINED_glMultiTexCoord3fvARB
void __stdcall GLee_Lazy_glMultiTexCoord3fvARB(GLenum target, const GLfloat * v) {if (GLeeInit()) glMultiTexCoord3fvARB(target, v);}
GLEEPFNGLMULTITEXCOORD3FVARBPROC GLeeFuncPtr_glMultiTexCoord3fvARB=GLee_Lazy_glMultiTexCoord3fvARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3iARB
#define GLEE_C_DEFINED_glMultiTexCoord3iARB
void __stdcall GLee_Lazy_glMultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r) {if (GLeeInit()) glMultiTexCoord3iARB(target, s, t, r);}
GLEEPFNGLMULTITEXCOORD3IARBPROC GLeeFuncPtr_glMultiTexCoord3iARB=GLee_Lazy_glMultiTexCoord3iARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3ivARB
#define GLEE_C_DEFINED_glMultiTexCoord3ivARB
void __stdcall GLee_Lazy_glMultiTexCoord3ivARB(GLenum target, const GLint * v) {if (GLeeInit()) glMultiTexCoord3ivARB(target, v);}
GLEEPFNGLMULTITEXCOORD3IVARBPROC GLeeFuncPtr_glMultiTexCoord3ivARB=GLee_Lazy_glMultiTexCoord3ivARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3sARB
#define GLEE_C_DEFINED_glMultiTexCoord3sARB
void __stdcall GLee_Lazy_glMultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshort r) {if (GLeeInit()) glMultiTexCoord3sARB(target, s, t, r);}
GLEEPFNGLMULTITEXCOORD3SARBPROC GLeeFuncPtr_glMultiTexCoord3sARB=GLee_Lazy_glMultiTexCoord3sARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3svARB
#define GLEE_C_DEFINED_glMultiTexCoord3svARB
void __stdcall GLee_Lazy_glMultiTexCoord3svARB(GLenum target, const GLshort * v) {if (GLeeInit()) glMultiTexCoord3svARB(target, v);}
GLEEPFNGLMULTITEXCOORD3SVARBPROC GLeeFuncPtr_glMultiTexCoord3svARB=GLee_Lazy_glMultiTexCoord3svARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4dARB
#define GLEE_C_DEFINED_glMultiTexCoord4dARB
void __stdcall GLee_Lazy_glMultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) {if (GLeeInit()) glMultiTexCoord4dARB(target, s, t, r, q);}
GLEEPFNGLMULTITEXCOORD4DARBPROC GLeeFuncPtr_glMultiTexCoord4dARB=GLee_Lazy_glMultiTexCoord4dARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4dvARB
#define GLEE_C_DEFINED_glMultiTexCoord4dvARB
void __stdcall GLee_Lazy_glMultiTexCoord4dvARB(GLenum target, const GLdouble * v) {if (GLeeInit()) glMultiTexCoord4dvARB(target, v);}
GLEEPFNGLMULTITEXCOORD4DVARBPROC GLeeFuncPtr_glMultiTexCoord4dvARB=GLee_Lazy_glMultiTexCoord4dvARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4fARB
#define GLEE_C_DEFINED_glMultiTexCoord4fARB
void __stdcall GLee_Lazy_glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) {if (GLeeInit()) glMultiTexCoord4fARB(target, s, t, r, q);}
GLEEPFNGLMULTITEXCOORD4FARBPROC GLeeFuncPtr_glMultiTexCoord4fARB=GLee_Lazy_glMultiTexCoord4fARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4fvARB
#define GLEE_C_DEFINED_glMultiTexCoord4fvARB
void __stdcall GLee_Lazy_glMultiTexCoord4fvARB(GLenum target, const GLfloat * v) {if (GLeeInit()) glMultiTexCoord4fvARB(target, v);}
GLEEPFNGLMULTITEXCOORD4FVARBPROC GLeeFuncPtr_glMultiTexCoord4fvARB=GLee_Lazy_glMultiTexCoord4fvARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4iARB
#define GLEE_C_DEFINED_glMultiTexCoord4iARB
void __stdcall GLee_Lazy_glMultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, GLint q) {if (GLeeInit()) glMultiTexCoord4iARB(target, s, t, r, q);}
GLEEPFNGLMULTITEXCOORD4IARBPROC GLeeFuncPtr_glMultiTexCoord4iARB=GLee_Lazy_glMultiTexCoord4iARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4ivARB
#define GLEE_C_DEFINED_glMultiTexCoord4ivARB
void __stdcall GLee_Lazy_glMultiTexCoord4ivARB(GLenum target, const GLint * v) {if (GLeeInit()) glMultiTexCoord4ivARB(target, v);}
GLEEPFNGLMULTITEXCOORD4IVARBPROC GLeeFuncPtr_glMultiTexCoord4ivARB=GLee_Lazy_glMultiTexCoord4ivARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4sARB
#define GLEE_C_DEFINED_glMultiTexCoord4sARB
void __stdcall GLee_Lazy_glMultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) {if (GLeeInit()) glMultiTexCoord4sARB(target, s, t, r, q);}
GLEEPFNGLMULTITEXCOORD4SARBPROC GLeeFuncPtr_glMultiTexCoord4sARB=GLee_Lazy_glMultiTexCoord4sARB;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4svARB
#define GLEE_C_DEFINED_glMultiTexCoord4svARB
void __stdcall GLee_Lazy_glMultiTexCoord4svARB(GLenum target, const GLshort * v) {if (GLeeInit()) glMultiTexCoord4svARB(target, v);}
GLEEPFNGLMULTITEXCOORD4SVARBPROC GLeeFuncPtr_glMultiTexCoord4svARB=GLee_Lazy_glMultiTexCoord4svARB;
#endif
#endif
/* GL_ARB_transpose_matrix */
#ifdef __GLEE_GL_ARB_transpose_matrix
#ifndef GLEE_C_DEFINED_glLoadTransposeMatrixfARB
#define GLEE_C_DEFINED_glLoadTransposeMatrixfARB
void __stdcall GLee_Lazy_glLoadTransposeMatrixfARB(const GLfloat * m) {if (GLeeInit()) glLoadTransposeMatrixfARB(m);}
GLEEPFNGLLOADTRANSPOSEMATRIXFARBPROC GLeeFuncPtr_glLoadTransposeMatrixfARB=GLee_Lazy_glLoadTransposeMatrixfARB;
#endif
#ifndef GLEE_C_DEFINED_glLoadTransposeMatrixdARB
#define GLEE_C_DEFINED_glLoadTransposeMatrixdARB
void __stdcall GLee_Lazy_glLoadTransposeMatrixdARB(const GLdouble * m) {if (GLeeInit()) glLoadTransposeMatrixdARB(m);}
GLEEPFNGLLOADTRANSPOSEMATRIXDARBPROC GLeeFuncPtr_glLoadTransposeMatrixdARB=GLee_Lazy_glLoadTransposeMatrixdARB;
#endif
#ifndef GLEE_C_DEFINED_glMultTransposeMatrixfARB
#define GLEE_C_DEFINED_glMultTransposeMatrixfARB
void __stdcall GLee_Lazy_glMultTransposeMatrixfARB(const GLfloat * m) {if (GLeeInit()) glMultTransposeMatrixfARB(m);}
GLEEPFNGLMULTTRANSPOSEMATRIXFARBPROC GLeeFuncPtr_glMultTransposeMatrixfARB=GLee_Lazy_glMultTransposeMatrixfARB;
#endif
#ifndef GLEE_C_DEFINED_glMultTransposeMatrixdARB
#define GLEE_C_DEFINED_glMultTransposeMatrixdARB
void __stdcall GLee_Lazy_glMultTransposeMatrixdARB(const GLdouble * m) {if (GLeeInit()) glMultTransposeMatrixdARB(m);}
GLEEPFNGLMULTTRANSPOSEMATRIXDARBPROC GLeeFuncPtr_glMultTransposeMatrixdARB=GLee_Lazy_glMultTransposeMatrixdARB;
#endif
#endif
/* GL_ARB_multisample */
#ifdef __GLEE_GL_ARB_multisample
#ifndef GLEE_C_DEFINED_glSampleCoverageARB
#define GLEE_C_DEFINED_glSampleCoverageARB
void __stdcall GLee_Lazy_glSampleCoverageARB(GLclampf value, GLboolean invert) {if (GLeeInit()) glSampleCoverageARB(value, invert);}
GLEEPFNGLSAMPLECOVERAGEARBPROC GLeeFuncPtr_glSampleCoverageARB=GLee_Lazy_glSampleCoverageARB;
#endif
#endif
/* GL_ARB_texture_env_add */
#ifdef __GLEE_GL_ARB_texture_env_add
#endif
/* GL_ARB_texture_cube_map */
#ifdef __GLEE_GL_ARB_texture_cube_map
#endif
/* GL_ARB_texture_compression */
#ifdef __GLEE_GL_ARB_texture_compression
#ifndef GLEE_C_DEFINED_glCompressedTexImage3DARB
#define GLEE_C_DEFINED_glCompressedTexImage3DARB
void __stdcall GLee_Lazy_glCompressedTexImage3DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data) {if (GLeeInit()) glCompressedTexImage3DARB(target, level, internalformat, width, height, depth, border, imageSize, data);}
GLEEPFNGLCOMPRESSEDTEXIMAGE3DARBPROC GLeeFuncPtr_glCompressedTexImage3DARB=GLee_Lazy_glCompressedTexImage3DARB;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexImage2DARB
#define GLEE_C_DEFINED_glCompressedTexImage2DARB
void __stdcall GLee_Lazy_glCompressedTexImage2DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * data) {if (GLeeInit()) glCompressedTexImage2DARB(target, level, internalformat, width, height, border, imageSize, data);}
GLEEPFNGLCOMPRESSEDTEXIMAGE2DARBPROC GLeeFuncPtr_glCompressedTexImage2DARB=GLee_Lazy_glCompressedTexImage2DARB;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexImage1DARB
#define GLEE_C_DEFINED_glCompressedTexImage1DARB
void __stdcall GLee_Lazy_glCompressedTexImage1DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid * data) {if (GLeeInit()) glCompressedTexImage1DARB(target, level, internalformat, width, border, imageSize, data);}
GLEEPFNGLCOMPRESSEDTEXIMAGE1DARBPROC GLeeFuncPtr_glCompressedTexImage1DARB=GLee_Lazy_glCompressedTexImage1DARB;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexSubImage3DARB
#define GLEE_C_DEFINED_glCompressedTexSubImage3DARB
void __stdcall GLee_Lazy_glCompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data) {if (GLeeInit()) glCompressedTexSubImage3DARB(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);}
GLEEPFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC GLeeFuncPtr_glCompressedTexSubImage3DARB=GLee_Lazy_glCompressedTexSubImage3DARB;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexSubImage2DARB
#define GLEE_C_DEFINED_glCompressedTexSubImage2DARB
void __stdcall GLee_Lazy_glCompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data) {if (GLeeInit()) glCompressedTexSubImage2DARB(target, level, xoffset, yoffset, width, height, format, imageSize, data);}
GLEEPFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC GLeeFuncPtr_glCompressedTexSubImage2DARB=GLee_Lazy_glCompressedTexSubImage2DARB;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTexSubImage1DARB
#define GLEE_C_DEFINED_glCompressedTexSubImage1DARB
void __stdcall GLee_Lazy_glCompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * data) {if (GLeeInit()) glCompressedTexSubImage1DARB(target, level, xoffset, width, format, imageSize, data);}
GLEEPFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC GLeeFuncPtr_glCompressedTexSubImage1DARB=GLee_Lazy_glCompressedTexSubImage1DARB;
#endif
#ifndef GLEE_C_DEFINED_glGetCompressedTexImageARB
#define GLEE_C_DEFINED_glGetCompressedTexImageARB
void __stdcall GLee_Lazy_glGetCompressedTexImageARB(GLenum target, GLint level, GLvoid * img) {if (GLeeInit()) glGetCompressedTexImageARB(target, level, img);}
GLEEPFNGLGETCOMPRESSEDTEXIMAGEARBPROC GLeeFuncPtr_glGetCompressedTexImageARB=GLee_Lazy_glGetCompressedTexImageARB;
#endif
#endif
/* GL_ARB_texture_border_clamp */
#ifdef __GLEE_GL_ARB_texture_border_clamp
#endif
/* GL_ARB_point_parameters */
#ifdef __GLEE_GL_ARB_point_parameters
#ifndef GLEE_C_DEFINED_glPointParameterfARB
#define GLEE_C_DEFINED_glPointParameterfARB
void __stdcall GLee_Lazy_glPointParameterfARB(GLenum pname, GLfloat param) {if (GLeeInit()) glPointParameterfARB(pname, param);}
GLEEPFNGLPOINTPARAMETERFARBPROC GLeeFuncPtr_glPointParameterfARB=GLee_Lazy_glPointParameterfARB;
#endif
#ifndef GLEE_C_DEFINED_glPointParameterfvARB
#define GLEE_C_DEFINED_glPointParameterfvARB
void __stdcall GLee_Lazy_glPointParameterfvARB(GLenum pname, const GLfloat * params) {if (GLeeInit()) glPointParameterfvARB(pname, params);}
GLEEPFNGLPOINTPARAMETERFVARBPROC GLeeFuncPtr_glPointParameterfvARB=GLee_Lazy_glPointParameterfvARB;
#endif
#endif
/* GL_ARB_vertex_blend */
#ifdef __GLEE_GL_ARB_vertex_blend
#ifndef GLEE_C_DEFINED_glWeightbvARB
#define GLEE_C_DEFINED_glWeightbvARB
void __stdcall GLee_Lazy_glWeightbvARB(GLint size, const GLbyte * weights) {if (GLeeInit()) glWeightbvARB(size, weights);}
GLEEPFNGLWEIGHTBVARBPROC GLeeFuncPtr_glWeightbvARB=GLee_Lazy_glWeightbvARB;
#endif
#ifndef GLEE_C_DEFINED_glWeightsvARB
#define GLEE_C_DEFINED_glWeightsvARB
void __stdcall GLee_Lazy_glWeightsvARB(GLint size, const GLshort * weights) {if (GLeeInit()) glWeightsvARB(size, weights);}
GLEEPFNGLWEIGHTSVARBPROC GLeeFuncPtr_glWeightsvARB=GLee_Lazy_glWeightsvARB;
#endif
#ifndef GLEE_C_DEFINED_glWeightivARB
#define GLEE_C_DEFINED_glWeightivARB
void __stdcall GLee_Lazy_glWeightivARB(GLint size, const GLint * weights) {if (GLeeInit()) glWeightivARB(size, weights);}
GLEEPFNGLWEIGHTIVARBPROC GLeeFuncPtr_glWeightivARB=GLee_Lazy_glWeightivARB;
#endif
#ifndef GLEE_C_DEFINED_glWeightfvARB
#define GLEE_C_DEFINED_glWeightfvARB
void __stdcall GLee_Lazy_glWeightfvARB(GLint size, const GLfloat * weights) {if (GLeeInit()) glWeightfvARB(size, weights);}
GLEEPFNGLWEIGHTFVARBPROC GLeeFuncPtr_glWeightfvARB=GLee_Lazy_glWeightfvARB;
#endif
#ifndef GLEE_C_DEFINED_glWeightdvARB
#define GLEE_C_DEFINED_glWeightdvARB
void __stdcall GLee_Lazy_glWeightdvARB(GLint size, const GLdouble * weights) {if (GLeeInit()) glWeightdvARB(size, weights);}
GLEEPFNGLWEIGHTDVARBPROC GLeeFuncPtr_glWeightdvARB=GLee_Lazy_glWeightdvARB;
#endif
#ifndef GLEE_C_DEFINED_glWeightubvARB
#define GLEE_C_DEFINED_glWeightubvARB
void __stdcall GLee_Lazy_glWeightubvARB(GLint size, const GLubyte * weights) {if (GLeeInit()) glWeightubvARB(size, weights);}
GLEEPFNGLWEIGHTUBVARBPROC GLeeFuncPtr_glWeightubvARB=GLee_Lazy_glWeightubvARB;
#endif
#ifndef GLEE_C_DEFINED_glWeightusvARB
#define GLEE_C_DEFINED_glWeightusvARB
void __stdcall GLee_Lazy_glWeightusvARB(GLint size, const GLushort * weights) {if (GLeeInit()) glWeightusvARB(size, weights);}
GLEEPFNGLWEIGHTUSVARBPROC GLeeFuncPtr_glWeightusvARB=GLee_Lazy_glWeightusvARB;
#endif
#ifndef GLEE_C_DEFINED_glWeightuivARB
#define GLEE_C_DEFINED_glWeightuivARB
void __stdcall GLee_Lazy_glWeightuivARB(GLint size, const GLuint * weights) {if (GLeeInit()) glWeightuivARB(size, weights);}
GLEEPFNGLWEIGHTUIVARBPROC GLeeFuncPtr_glWeightuivARB=GLee_Lazy_glWeightuivARB;
#endif
#ifndef GLEE_C_DEFINED_glWeightPointerARB
#define GLEE_C_DEFINED_glWeightPointerARB
void __stdcall GLee_Lazy_glWeightPointerARB(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer) {if (GLeeInit()) glWeightPointerARB(size, type, stride, pointer);}
GLEEPFNGLWEIGHTPOINTERARBPROC GLeeFuncPtr_glWeightPointerARB=GLee_Lazy_glWeightPointerARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexBlendARB
#define GLEE_C_DEFINED_glVertexBlendARB
void __stdcall GLee_Lazy_glVertexBlendARB(GLint count) {if (GLeeInit()) glVertexBlendARB(count);}
GLEEPFNGLVERTEXBLENDARBPROC GLeeFuncPtr_glVertexBlendARB=GLee_Lazy_glVertexBlendARB;
#endif
#endif
/* GL_ARB_matrix_palette */
#ifdef __GLEE_GL_ARB_matrix_palette
#ifndef GLEE_C_DEFINED_glCurrentPaletteMatrixARB
#define GLEE_C_DEFINED_glCurrentPaletteMatrixARB
void __stdcall GLee_Lazy_glCurrentPaletteMatrixARB(GLint index) {if (GLeeInit()) glCurrentPaletteMatrixARB(index);}
GLEEPFNGLCURRENTPALETTEMATRIXARBPROC GLeeFuncPtr_glCurrentPaletteMatrixARB=GLee_Lazy_glCurrentPaletteMatrixARB;
#endif
#ifndef GLEE_C_DEFINED_glMatrixIndexubvARB
#define GLEE_C_DEFINED_glMatrixIndexubvARB
void __stdcall GLee_Lazy_glMatrixIndexubvARB(GLint size, const GLubyte * indices) {if (GLeeInit()) glMatrixIndexubvARB(size, indices);}
GLEEPFNGLMATRIXINDEXUBVARBPROC GLeeFuncPtr_glMatrixIndexubvARB=GLee_Lazy_glMatrixIndexubvARB;
#endif
#ifndef GLEE_C_DEFINED_glMatrixIndexusvARB
#define GLEE_C_DEFINED_glMatrixIndexusvARB
void __stdcall GLee_Lazy_glMatrixIndexusvARB(GLint size, const GLushort * indices) {if (GLeeInit()) glMatrixIndexusvARB(size, indices);}
GLEEPFNGLMATRIXINDEXUSVARBPROC GLeeFuncPtr_glMatrixIndexusvARB=GLee_Lazy_glMatrixIndexusvARB;
#endif
#ifndef GLEE_C_DEFINED_glMatrixIndexuivARB
#define GLEE_C_DEFINED_glMatrixIndexuivARB
void __stdcall GLee_Lazy_glMatrixIndexuivARB(GLint size, const GLuint * indices) {if (GLeeInit()) glMatrixIndexuivARB(size, indices);}
GLEEPFNGLMATRIXINDEXUIVARBPROC GLeeFuncPtr_glMatrixIndexuivARB=GLee_Lazy_glMatrixIndexuivARB;
#endif
#ifndef GLEE_C_DEFINED_glMatrixIndexPointerARB
#define GLEE_C_DEFINED_glMatrixIndexPointerARB
void __stdcall GLee_Lazy_glMatrixIndexPointerARB(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer) {if (GLeeInit()) glMatrixIndexPointerARB(size, type, stride, pointer);}
GLEEPFNGLMATRIXINDEXPOINTERARBPROC GLeeFuncPtr_glMatrixIndexPointerARB=GLee_Lazy_glMatrixIndexPointerARB;
#endif
#endif
/* GL_ARB_texture_env_combine */
#ifdef __GLEE_GL_ARB_texture_env_combine
#endif
/* GL_ARB_texture_env_crossbar */
#ifdef __GLEE_GL_ARB_texture_env_crossbar
#endif
/* GL_ARB_texture_env_dot3 */
#ifdef __GLEE_GL_ARB_texture_env_dot3
#endif
/* GL_ARB_texture_mirrored_repeat */
#ifdef __GLEE_GL_ARB_texture_mirrored_repeat
#endif
/* GL_ARB_depth_texture */
#ifdef __GLEE_GL_ARB_depth_texture
#endif
/* GL_ARB_shadow */
#ifdef __GLEE_GL_ARB_shadow
#endif
/* GL_ARB_shadow_ambient */
#ifdef __GLEE_GL_ARB_shadow_ambient
#endif
/* GL_ARB_window_pos */
#ifdef __GLEE_GL_ARB_window_pos
#ifndef GLEE_C_DEFINED_glWindowPos2dARB
#define GLEE_C_DEFINED_glWindowPos2dARB
void __stdcall GLee_Lazy_glWindowPos2dARB(GLdouble x, GLdouble y) {if (GLeeInit()) glWindowPos2dARB(x, y);}
GLEEPFNGLWINDOWPOS2DARBPROC GLeeFuncPtr_glWindowPos2dARB=GLee_Lazy_glWindowPos2dARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2dvARB
#define GLEE_C_DEFINED_glWindowPos2dvARB
void __stdcall GLee_Lazy_glWindowPos2dvARB(const GLdouble * v) {if (GLeeInit()) glWindowPos2dvARB(v);}
GLEEPFNGLWINDOWPOS2DVARBPROC GLeeFuncPtr_glWindowPos2dvARB=GLee_Lazy_glWindowPos2dvARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2fARB
#define GLEE_C_DEFINED_glWindowPos2fARB
void __stdcall GLee_Lazy_glWindowPos2fARB(GLfloat x, GLfloat y) {if (GLeeInit()) glWindowPos2fARB(x, y);}
GLEEPFNGLWINDOWPOS2FARBPROC GLeeFuncPtr_glWindowPos2fARB=GLee_Lazy_glWindowPos2fARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2fvARB
#define GLEE_C_DEFINED_glWindowPos2fvARB
void __stdcall GLee_Lazy_glWindowPos2fvARB(const GLfloat * v) {if (GLeeInit()) glWindowPos2fvARB(v);}
GLEEPFNGLWINDOWPOS2FVARBPROC GLeeFuncPtr_glWindowPos2fvARB=GLee_Lazy_glWindowPos2fvARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2iARB
#define GLEE_C_DEFINED_glWindowPos2iARB
void __stdcall GLee_Lazy_glWindowPos2iARB(GLint x, GLint y) {if (GLeeInit()) glWindowPos2iARB(x, y);}
GLEEPFNGLWINDOWPOS2IARBPROC GLeeFuncPtr_glWindowPos2iARB=GLee_Lazy_glWindowPos2iARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2ivARB
#define GLEE_C_DEFINED_glWindowPos2ivARB
void __stdcall GLee_Lazy_glWindowPos2ivARB(const GLint * v) {if (GLeeInit()) glWindowPos2ivARB(v);}
GLEEPFNGLWINDOWPOS2IVARBPROC GLeeFuncPtr_glWindowPos2ivARB=GLee_Lazy_glWindowPos2ivARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2sARB
#define GLEE_C_DEFINED_glWindowPos2sARB
void __stdcall GLee_Lazy_glWindowPos2sARB(GLshort x, GLshort y) {if (GLeeInit()) glWindowPos2sARB(x, y);}
GLEEPFNGLWINDOWPOS2SARBPROC GLeeFuncPtr_glWindowPos2sARB=GLee_Lazy_glWindowPos2sARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2svARB
#define GLEE_C_DEFINED_glWindowPos2svARB
void __stdcall GLee_Lazy_glWindowPos2svARB(const GLshort * v) {if (GLeeInit()) glWindowPos2svARB(v);}
GLEEPFNGLWINDOWPOS2SVARBPROC GLeeFuncPtr_glWindowPos2svARB=GLee_Lazy_glWindowPos2svARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3dARB
#define GLEE_C_DEFINED_glWindowPos3dARB
void __stdcall GLee_Lazy_glWindowPos3dARB(GLdouble x, GLdouble y, GLdouble z) {if (GLeeInit()) glWindowPos3dARB(x, y, z);}
GLEEPFNGLWINDOWPOS3DARBPROC GLeeFuncPtr_glWindowPos3dARB=GLee_Lazy_glWindowPos3dARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3dvARB
#define GLEE_C_DEFINED_glWindowPos3dvARB
void __stdcall GLee_Lazy_glWindowPos3dvARB(const GLdouble * v) {if (GLeeInit()) glWindowPos3dvARB(v);}
GLEEPFNGLWINDOWPOS3DVARBPROC GLeeFuncPtr_glWindowPos3dvARB=GLee_Lazy_glWindowPos3dvARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3fARB
#define GLEE_C_DEFINED_glWindowPos3fARB
void __stdcall GLee_Lazy_glWindowPos3fARB(GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glWindowPos3fARB(x, y, z);}
GLEEPFNGLWINDOWPOS3FARBPROC GLeeFuncPtr_glWindowPos3fARB=GLee_Lazy_glWindowPos3fARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3fvARB
#define GLEE_C_DEFINED_glWindowPos3fvARB
void __stdcall GLee_Lazy_glWindowPos3fvARB(const GLfloat * v) {if (GLeeInit()) glWindowPos3fvARB(v);}
GLEEPFNGLWINDOWPOS3FVARBPROC GLeeFuncPtr_glWindowPos3fvARB=GLee_Lazy_glWindowPos3fvARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3iARB
#define GLEE_C_DEFINED_glWindowPos3iARB
void __stdcall GLee_Lazy_glWindowPos3iARB(GLint x, GLint y, GLint z) {if (GLeeInit()) glWindowPos3iARB(x, y, z);}
GLEEPFNGLWINDOWPOS3IARBPROC GLeeFuncPtr_glWindowPos3iARB=GLee_Lazy_glWindowPos3iARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3ivARB
#define GLEE_C_DEFINED_glWindowPos3ivARB
void __stdcall GLee_Lazy_glWindowPos3ivARB(const GLint * v) {if (GLeeInit()) glWindowPos3ivARB(v);}
GLEEPFNGLWINDOWPOS3IVARBPROC GLeeFuncPtr_glWindowPos3ivARB=GLee_Lazy_glWindowPos3ivARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3sARB
#define GLEE_C_DEFINED_glWindowPos3sARB
void __stdcall GLee_Lazy_glWindowPos3sARB(GLshort x, GLshort y, GLshort z) {if (GLeeInit()) glWindowPos3sARB(x, y, z);}
GLEEPFNGLWINDOWPOS3SARBPROC GLeeFuncPtr_glWindowPos3sARB=GLee_Lazy_glWindowPos3sARB;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3svARB
#define GLEE_C_DEFINED_glWindowPos3svARB
void __stdcall GLee_Lazy_glWindowPos3svARB(const GLshort * v) {if (GLeeInit()) glWindowPos3svARB(v);}
GLEEPFNGLWINDOWPOS3SVARBPROC GLeeFuncPtr_glWindowPos3svARB=GLee_Lazy_glWindowPos3svARB;
#endif
#endif
/* GL_ARB_vertex_program */
#ifdef __GLEE_GL_ARB_vertex_program
#ifndef GLEE_C_DEFINED_glVertexAttrib1dARB
#define GLEE_C_DEFINED_glVertexAttrib1dARB
void __stdcall GLee_Lazy_glVertexAttrib1dARB(GLuint index, GLdouble x) {if (GLeeInit()) glVertexAttrib1dARB(index, x);}
GLEEPFNGLVERTEXATTRIB1DARBPROC GLeeFuncPtr_glVertexAttrib1dARB=GLee_Lazy_glVertexAttrib1dARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1dvARB
#define GLEE_C_DEFINED_glVertexAttrib1dvARB
void __stdcall GLee_Lazy_glVertexAttrib1dvARB(GLuint index, const GLdouble * v) {if (GLeeInit()) glVertexAttrib1dvARB(index, v);}
GLEEPFNGLVERTEXATTRIB1DVARBPROC GLeeFuncPtr_glVertexAttrib1dvARB=GLee_Lazy_glVertexAttrib1dvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1fARB
#define GLEE_C_DEFINED_glVertexAttrib1fARB
void __stdcall GLee_Lazy_glVertexAttrib1fARB(GLuint index, GLfloat x) {if (GLeeInit()) glVertexAttrib1fARB(index, x);}
GLEEPFNGLVERTEXATTRIB1FARBPROC GLeeFuncPtr_glVertexAttrib1fARB=GLee_Lazy_glVertexAttrib1fARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1fvARB
#define GLEE_C_DEFINED_glVertexAttrib1fvARB
void __stdcall GLee_Lazy_glVertexAttrib1fvARB(GLuint index, const GLfloat * v) {if (GLeeInit()) glVertexAttrib1fvARB(index, v);}
GLEEPFNGLVERTEXATTRIB1FVARBPROC GLeeFuncPtr_glVertexAttrib1fvARB=GLee_Lazy_glVertexAttrib1fvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1sARB
#define GLEE_C_DEFINED_glVertexAttrib1sARB
void __stdcall GLee_Lazy_glVertexAttrib1sARB(GLuint index, GLshort x) {if (GLeeInit()) glVertexAttrib1sARB(index, x);}
GLEEPFNGLVERTEXATTRIB1SARBPROC GLeeFuncPtr_glVertexAttrib1sARB=GLee_Lazy_glVertexAttrib1sARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1svARB
#define GLEE_C_DEFINED_glVertexAttrib1svARB
void __stdcall GLee_Lazy_glVertexAttrib1svARB(GLuint index, const GLshort * v) {if (GLeeInit()) glVertexAttrib1svARB(index, v);}
GLEEPFNGLVERTEXATTRIB1SVARBPROC GLeeFuncPtr_glVertexAttrib1svARB=GLee_Lazy_glVertexAttrib1svARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2dARB
#define GLEE_C_DEFINED_glVertexAttrib2dARB
void __stdcall GLee_Lazy_glVertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y) {if (GLeeInit()) glVertexAttrib2dARB(index, x, y);}
GLEEPFNGLVERTEXATTRIB2DARBPROC GLeeFuncPtr_glVertexAttrib2dARB=GLee_Lazy_glVertexAttrib2dARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2dvARB
#define GLEE_C_DEFINED_glVertexAttrib2dvARB
void __stdcall GLee_Lazy_glVertexAttrib2dvARB(GLuint index, const GLdouble * v) {if (GLeeInit()) glVertexAttrib2dvARB(index, v);}
GLEEPFNGLVERTEXATTRIB2DVARBPROC GLeeFuncPtr_glVertexAttrib2dvARB=GLee_Lazy_glVertexAttrib2dvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2fARB
#define GLEE_C_DEFINED_glVertexAttrib2fARB
void __stdcall GLee_Lazy_glVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y) {if (GLeeInit()) glVertexAttrib2fARB(index, x, y);}
GLEEPFNGLVERTEXATTRIB2FARBPROC GLeeFuncPtr_glVertexAttrib2fARB=GLee_Lazy_glVertexAttrib2fARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2fvARB
#define GLEE_C_DEFINED_glVertexAttrib2fvARB
void __stdcall GLee_Lazy_glVertexAttrib2fvARB(GLuint index, const GLfloat * v) {if (GLeeInit()) glVertexAttrib2fvARB(index, v);}
GLEEPFNGLVERTEXATTRIB2FVARBPROC GLeeFuncPtr_glVertexAttrib2fvARB=GLee_Lazy_glVertexAttrib2fvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2sARB
#define GLEE_C_DEFINED_glVertexAttrib2sARB
void __stdcall GLee_Lazy_glVertexAttrib2sARB(GLuint index, GLshort x, GLshort y) {if (GLeeInit()) glVertexAttrib2sARB(index, x, y);}
GLEEPFNGLVERTEXATTRIB2SARBPROC GLeeFuncPtr_glVertexAttrib2sARB=GLee_Lazy_glVertexAttrib2sARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2svARB
#define GLEE_C_DEFINED_glVertexAttrib2svARB
void __stdcall GLee_Lazy_glVertexAttrib2svARB(GLuint index, const GLshort * v) {if (GLeeInit()) glVertexAttrib2svARB(index, v);}
GLEEPFNGLVERTEXATTRIB2SVARBPROC GLeeFuncPtr_glVertexAttrib2svARB=GLee_Lazy_glVertexAttrib2svARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3dARB
#define GLEE_C_DEFINED_glVertexAttrib3dARB
void __stdcall GLee_Lazy_glVertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z) {if (GLeeInit()) glVertexAttrib3dARB(index, x, y, z);}
GLEEPFNGLVERTEXATTRIB3DARBPROC GLeeFuncPtr_glVertexAttrib3dARB=GLee_Lazy_glVertexAttrib3dARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3dvARB
#define GLEE_C_DEFINED_glVertexAttrib3dvARB
void __stdcall GLee_Lazy_glVertexAttrib3dvARB(GLuint index, const GLdouble * v) {if (GLeeInit()) glVertexAttrib3dvARB(index, v);}
GLEEPFNGLVERTEXATTRIB3DVARBPROC GLeeFuncPtr_glVertexAttrib3dvARB=GLee_Lazy_glVertexAttrib3dvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3fARB
#define GLEE_C_DEFINED_glVertexAttrib3fARB
void __stdcall GLee_Lazy_glVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glVertexAttrib3fARB(index, x, y, z);}
GLEEPFNGLVERTEXATTRIB3FARBPROC GLeeFuncPtr_glVertexAttrib3fARB=GLee_Lazy_glVertexAttrib3fARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3fvARB
#define GLEE_C_DEFINED_glVertexAttrib3fvARB
void __stdcall GLee_Lazy_glVertexAttrib3fvARB(GLuint index, const GLfloat * v) {if (GLeeInit()) glVertexAttrib3fvARB(index, v);}
GLEEPFNGLVERTEXATTRIB3FVARBPROC GLeeFuncPtr_glVertexAttrib3fvARB=GLee_Lazy_glVertexAttrib3fvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3sARB
#define GLEE_C_DEFINED_glVertexAttrib3sARB
void __stdcall GLee_Lazy_glVertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z) {if (GLeeInit()) glVertexAttrib3sARB(index, x, y, z);}
GLEEPFNGLVERTEXATTRIB3SARBPROC GLeeFuncPtr_glVertexAttrib3sARB=GLee_Lazy_glVertexAttrib3sARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3svARB
#define GLEE_C_DEFINED_glVertexAttrib3svARB
void __stdcall GLee_Lazy_glVertexAttrib3svARB(GLuint index, const GLshort * v) {if (GLeeInit()) glVertexAttrib3svARB(index, v);}
GLEEPFNGLVERTEXATTRIB3SVARBPROC GLeeFuncPtr_glVertexAttrib3svARB=GLee_Lazy_glVertexAttrib3svARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4NbvARB
#define GLEE_C_DEFINED_glVertexAttrib4NbvARB
void __stdcall GLee_Lazy_glVertexAttrib4NbvARB(GLuint index, const GLbyte * v) {if (GLeeInit()) glVertexAttrib4NbvARB(index, v);}
GLEEPFNGLVERTEXATTRIB4NBVARBPROC GLeeFuncPtr_glVertexAttrib4NbvARB=GLee_Lazy_glVertexAttrib4NbvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4NivARB
#define GLEE_C_DEFINED_glVertexAttrib4NivARB
void __stdcall GLee_Lazy_glVertexAttrib4NivARB(GLuint index, const GLint * v) {if (GLeeInit()) glVertexAttrib4NivARB(index, v);}
GLEEPFNGLVERTEXATTRIB4NIVARBPROC GLeeFuncPtr_glVertexAttrib4NivARB=GLee_Lazy_glVertexAttrib4NivARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4NsvARB
#define GLEE_C_DEFINED_glVertexAttrib4NsvARB
void __stdcall GLee_Lazy_glVertexAttrib4NsvARB(GLuint index, const GLshort * v) {if (GLeeInit()) glVertexAttrib4NsvARB(index, v);}
GLEEPFNGLVERTEXATTRIB4NSVARBPROC GLeeFuncPtr_glVertexAttrib4NsvARB=GLee_Lazy_glVertexAttrib4NsvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4NubARB
#define GLEE_C_DEFINED_glVertexAttrib4NubARB
void __stdcall GLee_Lazy_glVertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) {if (GLeeInit()) glVertexAttrib4NubARB(index, x, y, z, w);}
GLEEPFNGLVERTEXATTRIB4NUBARBPROC GLeeFuncPtr_glVertexAttrib4NubARB=GLee_Lazy_glVertexAttrib4NubARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4NubvARB
#define GLEE_C_DEFINED_glVertexAttrib4NubvARB
void __stdcall GLee_Lazy_glVertexAttrib4NubvARB(GLuint index, const GLubyte * v) {if (GLeeInit()) glVertexAttrib4NubvARB(index, v);}
GLEEPFNGLVERTEXATTRIB4NUBVARBPROC GLeeFuncPtr_glVertexAttrib4NubvARB=GLee_Lazy_glVertexAttrib4NubvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4NuivARB
#define GLEE_C_DEFINED_glVertexAttrib4NuivARB
void __stdcall GLee_Lazy_glVertexAttrib4NuivARB(GLuint index, const GLuint * v) {if (GLeeInit()) glVertexAttrib4NuivARB(index, v);}
GLEEPFNGLVERTEXATTRIB4NUIVARBPROC GLeeFuncPtr_glVertexAttrib4NuivARB=GLee_Lazy_glVertexAttrib4NuivARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4NusvARB
#define GLEE_C_DEFINED_glVertexAttrib4NusvARB
void __stdcall GLee_Lazy_glVertexAttrib4NusvARB(GLuint index, const GLushort * v) {if (GLeeInit()) glVertexAttrib4NusvARB(index, v);}
GLEEPFNGLVERTEXATTRIB4NUSVARBPROC GLeeFuncPtr_glVertexAttrib4NusvARB=GLee_Lazy_glVertexAttrib4NusvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4bvARB
#define GLEE_C_DEFINED_glVertexAttrib4bvARB
void __stdcall GLee_Lazy_glVertexAttrib4bvARB(GLuint index, const GLbyte * v) {if (GLeeInit()) glVertexAttrib4bvARB(index, v);}
GLEEPFNGLVERTEXATTRIB4BVARBPROC GLeeFuncPtr_glVertexAttrib4bvARB=GLee_Lazy_glVertexAttrib4bvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4dARB
#define GLEE_C_DEFINED_glVertexAttrib4dARB
void __stdcall GLee_Lazy_glVertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {if (GLeeInit()) glVertexAttrib4dARB(index, x, y, z, w);}
GLEEPFNGLVERTEXATTRIB4DARBPROC GLeeFuncPtr_glVertexAttrib4dARB=GLee_Lazy_glVertexAttrib4dARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4dvARB
#define GLEE_C_DEFINED_glVertexAttrib4dvARB
void __stdcall GLee_Lazy_glVertexAttrib4dvARB(GLuint index, const GLdouble * v) {if (GLeeInit()) glVertexAttrib4dvARB(index, v);}
GLEEPFNGLVERTEXATTRIB4DVARBPROC GLeeFuncPtr_glVertexAttrib4dvARB=GLee_Lazy_glVertexAttrib4dvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4fARB
#define GLEE_C_DEFINED_glVertexAttrib4fARB
void __stdcall GLee_Lazy_glVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {if (GLeeInit()) glVertexAttrib4fARB(index, x, y, z, w);}
GLEEPFNGLVERTEXATTRIB4FARBPROC GLeeFuncPtr_glVertexAttrib4fARB=GLee_Lazy_glVertexAttrib4fARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4fvARB
#define GLEE_C_DEFINED_glVertexAttrib4fvARB
void __stdcall GLee_Lazy_glVertexAttrib4fvARB(GLuint index, const GLfloat * v) {if (GLeeInit()) glVertexAttrib4fvARB(index, v);}
GLEEPFNGLVERTEXATTRIB4FVARBPROC GLeeFuncPtr_glVertexAttrib4fvARB=GLee_Lazy_glVertexAttrib4fvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4ivARB
#define GLEE_C_DEFINED_glVertexAttrib4ivARB
void __stdcall GLee_Lazy_glVertexAttrib4ivARB(GLuint index, const GLint * v) {if (GLeeInit()) glVertexAttrib4ivARB(index, v);}
GLEEPFNGLVERTEXATTRIB4IVARBPROC GLeeFuncPtr_glVertexAttrib4ivARB=GLee_Lazy_glVertexAttrib4ivARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4sARB
#define GLEE_C_DEFINED_glVertexAttrib4sARB
void __stdcall GLee_Lazy_glVertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) {if (GLeeInit()) glVertexAttrib4sARB(index, x, y, z, w);}
GLEEPFNGLVERTEXATTRIB4SARBPROC GLeeFuncPtr_glVertexAttrib4sARB=GLee_Lazy_glVertexAttrib4sARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4svARB
#define GLEE_C_DEFINED_glVertexAttrib4svARB
void __stdcall GLee_Lazy_glVertexAttrib4svARB(GLuint index, const GLshort * v) {if (GLeeInit()) glVertexAttrib4svARB(index, v);}
GLEEPFNGLVERTEXATTRIB4SVARBPROC GLeeFuncPtr_glVertexAttrib4svARB=GLee_Lazy_glVertexAttrib4svARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4ubvARB
#define GLEE_C_DEFINED_glVertexAttrib4ubvARB
void __stdcall GLee_Lazy_glVertexAttrib4ubvARB(GLuint index, const GLubyte * v) {if (GLeeInit()) glVertexAttrib4ubvARB(index, v);}
GLEEPFNGLVERTEXATTRIB4UBVARBPROC GLeeFuncPtr_glVertexAttrib4ubvARB=GLee_Lazy_glVertexAttrib4ubvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4uivARB
#define GLEE_C_DEFINED_glVertexAttrib4uivARB
void __stdcall GLee_Lazy_glVertexAttrib4uivARB(GLuint index, const GLuint * v) {if (GLeeInit()) glVertexAttrib4uivARB(index, v);}
GLEEPFNGLVERTEXATTRIB4UIVARBPROC GLeeFuncPtr_glVertexAttrib4uivARB=GLee_Lazy_glVertexAttrib4uivARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4usvARB
#define GLEE_C_DEFINED_glVertexAttrib4usvARB
void __stdcall GLee_Lazy_glVertexAttrib4usvARB(GLuint index, const GLushort * v) {if (GLeeInit()) glVertexAttrib4usvARB(index, v);}
GLEEPFNGLVERTEXATTRIB4USVARBPROC GLeeFuncPtr_glVertexAttrib4usvARB=GLee_Lazy_glVertexAttrib4usvARB;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribPointerARB
#define GLEE_C_DEFINED_glVertexAttribPointerARB
void __stdcall GLee_Lazy_glVertexAttribPointerARB(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer) {if (GLeeInit()) glVertexAttribPointerARB(index, size, type, normalized, stride, pointer);}
GLEEPFNGLVERTEXATTRIBPOINTERARBPROC GLeeFuncPtr_glVertexAttribPointerARB=GLee_Lazy_glVertexAttribPointerARB;
#endif
#ifndef GLEE_C_DEFINED_glEnableVertexAttribArrayARB
#define GLEE_C_DEFINED_glEnableVertexAttribArrayARB
void __stdcall GLee_Lazy_glEnableVertexAttribArrayARB(GLuint index) {if (GLeeInit()) glEnableVertexAttribArrayARB(index);}
GLEEPFNGLENABLEVERTEXATTRIBARRAYARBPROC GLeeFuncPtr_glEnableVertexAttribArrayARB=GLee_Lazy_glEnableVertexAttribArrayARB;
#endif
#ifndef GLEE_C_DEFINED_glDisableVertexAttribArrayARB
#define GLEE_C_DEFINED_glDisableVertexAttribArrayARB
void __stdcall GLee_Lazy_glDisableVertexAttribArrayARB(GLuint index) {if (GLeeInit()) glDisableVertexAttribArrayARB(index);}
GLEEPFNGLDISABLEVERTEXATTRIBARRAYARBPROC GLeeFuncPtr_glDisableVertexAttribArrayARB=GLee_Lazy_glDisableVertexAttribArrayARB;
#endif
#ifndef GLEE_C_DEFINED_glProgramStringARB
#define GLEE_C_DEFINED_glProgramStringARB
void __stdcall GLee_Lazy_glProgramStringARB(GLenum target, GLenum format, GLsizei len, const GLvoid * string) {if (GLeeInit()) glProgramStringARB(target, format, len, string);}
GLEEPFNGLPROGRAMSTRINGARBPROC GLeeFuncPtr_glProgramStringARB=GLee_Lazy_glProgramStringARB;
#endif
#ifndef GLEE_C_DEFINED_glBindProgramARB
#define GLEE_C_DEFINED_glBindProgramARB
void __stdcall GLee_Lazy_glBindProgramARB(GLenum target, GLuint program) {if (GLeeInit()) glBindProgramARB(target, program);}
GLEEPFNGLBINDPROGRAMARBPROC GLeeFuncPtr_glBindProgramARB=GLee_Lazy_glBindProgramARB;
#endif
#ifndef GLEE_C_DEFINED_glDeleteProgramsARB
#define GLEE_C_DEFINED_glDeleteProgramsARB
void __stdcall GLee_Lazy_glDeleteProgramsARB(GLsizei n, const GLuint * programs) {if (GLeeInit()) glDeleteProgramsARB(n, programs);}
GLEEPFNGLDELETEPROGRAMSARBPROC GLeeFuncPtr_glDeleteProgramsARB=GLee_Lazy_glDeleteProgramsARB;
#endif
#ifndef GLEE_C_DEFINED_glGenProgramsARB
#define GLEE_C_DEFINED_glGenProgramsARB
void __stdcall GLee_Lazy_glGenProgramsARB(GLsizei n, GLuint * programs) {if (GLeeInit()) glGenProgramsARB(n, programs);}
GLEEPFNGLGENPROGRAMSARBPROC GLeeFuncPtr_glGenProgramsARB=GLee_Lazy_glGenProgramsARB;
#endif
#ifndef GLEE_C_DEFINED_glProgramEnvParameter4dARB
#define GLEE_C_DEFINED_glProgramEnvParameter4dARB
void __stdcall GLee_Lazy_glProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {if (GLeeInit()) glProgramEnvParameter4dARB(target, index, x, y, z, w);}
GLEEPFNGLPROGRAMENVPARAMETER4DARBPROC GLeeFuncPtr_glProgramEnvParameter4dARB=GLee_Lazy_glProgramEnvParameter4dARB;
#endif
#ifndef GLEE_C_DEFINED_glProgramEnvParameter4dvARB
#define GLEE_C_DEFINED_glProgramEnvParameter4dvARB
void __stdcall GLee_Lazy_glProgramEnvParameter4dvARB(GLenum target, GLuint index, const GLdouble * params) {if (GLeeInit()) glProgramEnvParameter4dvARB(target, index, params);}
GLEEPFNGLPROGRAMENVPARAMETER4DVARBPROC GLeeFuncPtr_glProgramEnvParameter4dvARB=GLee_Lazy_glProgramEnvParameter4dvARB;
#endif
#ifndef GLEE_C_DEFINED_glProgramEnvParameter4fARB
#define GLEE_C_DEFINED_glProgramEnvParameter4fARB
void __stdcall GLee_Lazy_glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {if (GLeeInit()) glProgramEnvParameter4fARB(target, index, x, y, z, w);}
GLEEPFNGLPROGRAMENVPARAMETER4FARBPROC GLeeFuncPtr_glProgramEnvParameter4fARB=GLee_Lazy_glProgramEnvParameter4fARB;
#endif
#ifndef GLEE_C_DEFINED_glProgramEnvParameter4fvARB
#define GLEE_C_DEFINED_glProgramEnvParameter4fvARB
void __stdcall GLee_Lazy_glProgramEnvParameter4fvARB(GLenum target, GLuint index, const GLfloat * params) {if (GLeeInit()) glProgramEnvParameter4fvARB(target, index, params);}
GLEEPFNGLPROGRAMENVPARAMETER4FVARBPROC GLeeFuncPtr_glProgramEnvParameter4fvARB=GLee_Lazy_glProgramEnvParameter4fvARB;
#endif
#ifndef GLEE_C_DEFINED_glProgramLocalParameter4dARB
#define GLEE_C_DEFINED_glProgramLocalParameter4dARB
void __stdcall GLee_Lazy_glProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {if (GLeeInit()) glProgramLocalParameter4dARB(target, index, x, y, z, w);}
GLEEPFNGLPROGRAMLOCALPARAMETER4DARBPROC GLeeFuncPtr_glProgramLocalParameter4dARB=GLee_Lazy_glProgramLocalParameter4dARB;
#endif
#ifndef GLEE_C_DEFINED_glProgramLocalParameter4dvARB
#define GLEE_C_DEFINED_glProgramLocalParameter4dvARB
void __stdcall GLee_Lazy_glProgramLocalParameter4dvARB(GLenum target, GLuint index, const GLdouble * params) {if (GLeeInit()) glProgramLocalParameter4dvARB(target, index, params);}
GLEEPFNGLPROGRAMLOCALPARAMETER4DVARBPROC GLeeFuncPtr_glProgramLocalParameter4dvARB=GLee_Lazy_glProgramLocalParameter4dvARB;
#endif
#ifndef GLEE_C_DEFINED_glProgramLocalParameter4fARB
#define GLEE_C_DEFINED_glProgramLocalParameter4fARB
void __stdcall GLee_Lazy_glProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {if (GLeeInit()) glProgramLocalParameter4fARB(target, index, x, y, z, w);}
GLEEPFNGLPROGRAMLOCALPARAMETER4FARBPROC GLeeFuncPtr_glProgramLocalParameter4fARB=GLee_Lazy_glProgramLocalParameter4fARB;
#endif
#ifndef GLEE_C_DEFINED_glProgramLocalParameter4fvARB
#define GLEE_C_DEFINED_glProgramLocalParameter4fvARB
void __stdcall GLee_Lazy_glProgramLocalParameter4fvARB(GLenum target, GLuint index, const GLfloat * params) {if (GLeeInit()) glProgramLocalParameter4fvARB(target, index, params);}
GLEEPFNGLPROGRAMLOCALPARAMETER4FVARBPROC GLeeFuncPtr_glProgramLocalParameter4fvARB=GLee_Lazy_glProgramLocalParameter4fvARB;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramEnvParameterdvARB
#define GLEE_C_DEFINED_glGetProgramEnvParameterdvARB
void __stdcall GLee_Lazy_glGetProgramEnvParameterdvARB(GLenum target, GLuint index, GLdouble * params) {if (GLeeInit()) glGetProgramEnvParameterdvARB(target, index, params);}
GLEEPFNGLGETPROGRAMENVPARAMETERDVARBPROC GLeeFuncPtr_glGetProgramEnvParameterdvARB=GLee_Lazy_glGetProgramEnvParameterdvARB;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramEnvParameterfvARB
#define GLEE_C_DEFINED_glGetProgramEnvParameterfvARB
void __stdcall GLee_Lazy_glGetProgramEnvParameterfvARB(GLenum target, GLuint index, GLfloat * params) {if (GLeeInit()) glGetProgramEnvParameterfvARB(target, index, params);}
GLEEPFNGLGETPROGRAMENVPARAMETERFVARBPROC GLeeFuncPtr_glGetProgramEnvParameterfvARB=GLee_Lazy_glGetProgramEnvParameterfvARB;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramLocalParameterdvARB
#define GLEE_C_DEFINED_glGetProgramLocalParameterdvARB
void __stdcall GLee_Lazy_glGetProgramLocalParameterdvARB(GLenum target, GLuint index, GLdouble * params) {if (GLeeInit()) glGetProgramLocalParameterdvARB(target, index, params);}
GLEEPFNGLGETPROGRAMLOCALPARAMETERDVARBPROC GLeeFuncPtr_glGetProgramLocalParameterdvARB=GLee_Lazy_glGetProgramLocalParameterdvARB;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramLocalParameterfvARB
#define GLEE_C_DEFINED_glGetProgramLocalParameterfvARB
void __stdcall GLee_Lazy_glGetProgramLocalParameterfvARB(GLenum target, GLuint index, GLfloat * params) {if (GLeeInit()) glGetProgramLocalParameterfvARB(target, index, params);}
GLEEPFNGLGETPROGRAMLOCALPARAMETERFVARBPROC GLeeFuncPtr_glGetProgramLocalParameterfvARB=GLee_Lazy_glGetProgramLocalParameterfvARB;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramivARB
#define GLEE_C_DEFINED_glGetProgramivARB
void __stdcall GLee_Lazy_glGetProgramivARB(GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetProgramivARB(target, pname, params);}
GLEEPFNGLGETPROGRAMIVARBPROC GLeeFuncPtr_glGetProgramivARB=GLee_Lazy_glGetProgramivARB;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramStringARB
#define GLEE_C_DEFINED_glGetProgramStringARB
void __stdcall GLee_Lazy_glGetProgramStringARB(GLenum target, GLenum pname, GLvoid * string) {if (GLeeInit()) glGetProgramStringARB(target, pname, string);}
GLEEPFNGLGETPROGRAMSTRINGARBPROC GLeeFuncPtr_glGetProgramStringARB=GLee_Lazy_glGetProgramStringARB;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribdvARB
#define GLEE_C_DEFINED_glGetVertexAttribdvARB
void __stdcall GLee_Lazy_glGetVertexAttribdvARB(GLuint index, GLenum pname, GLdouble * params) {if (GLeeInit()) glGetVertexAttribdvARB(index, pname, params);}
GLEEPFNGLGETVERTEXATTRIBDVARBPROC GLeeFuncPtr_glGetVertexAttribdvARB=GLee_Lazy_glGetVertexAttribdvARB;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribfvARB
#define GLEE_C_DEFINED_glGetVertexAttribfvARB
void __stdcall GLee_Lazy_glGetVertexAttribfvARB(GLuint index, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetVertexAttribfvARB(index, pname, params);}
GLEEPFNGLGETVERTEXATTRIBFVARBPROC GLeeFuncPtr_glGetVertexAttribfvARB=GLee_Lazy_glGetVertexAttribfvARB;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribivARB
#define GLEE_C_DEFINED_glGetVertexAttribivARB
void __stdcall GLee_Lazy_glGetVertexAttribivARB(GLuint index, GLenum pname, GLint * params) {if (GLeeInit()) glGetVertexAttribivARB(index, pname, params);}
GLEEPFNGLGETVERTEXATTRIBIVARBPROC GLeeFuncPtr_glGetVertexAttribivARB=GLee_Lazy_glGetVertexAttribivARB;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribPointervARB
#define GLEE_C_DEFINED_glGetVertexAttribPointervARB
void __stdcall GLee_Lazy_glGetVertexAttribPointervARB(GLuint index, GLenum pname, GLvoid* * pointer) {if (GLeeInit()) glGetVertexAttribPointervARB(index, pname, pointer);}
GLEEPFNGLGETVERTEXATTRIBPOINTERVARBPROC GLeeFuncPtr_glGetVertexAttribPointervARB=GLee_Lazy_glGetVertexAttribPointervARB;
#endif
#ifndef GLEE_C_DEFINED_glIsProgramARB
#define GLEE_C_DEFINED_glIsProgramARB
GLboolean __stdcall GLee_Lazy_glIsProgramARB(GLuint program) {if (GLeeInit()) return glIsProgramARB(program); return (GLboolean)0;}
GLEEPFNGLISPROGRAMARBPROC GLeeFuncPtr_glIsProgramARB=GLee_Lazy_glIsProgramARB;
#endif
#endif
/* GL_ARB_fragment_program */
#ifdef __GLEE_GL_ARB_fragment_program
#endif
/* GL_ARB_vertex_buffer_object */
#ifdef __GLEE_GL_ARB_vertex_buffer_object
#ifndef GLEE_C_DEFINED_glBindBufferARB
#define GLEE_C_DEFINED_glBindBufferARB
void __stdcall GLee_Lazy_glBindBufferARB(GLenum target, GLuint buffer) {if (GLeeInit()) glBindBufferARB(target, buffer);}
GLEEPFNGLBINDBUFFERARBPROC GLeeFuncPtr_glBindBufferARB=GLee_Lazy_glBindBufferARB;
#endif
#ifndef GLEE_C_DEFINED_glDeleteBuffersARB
#define GLEE_C_DEFINED_glDeleteBuffersARB
void __stdcall GLee_Lazy_glDeleteBuffersARB(GLsizei n, const GLuint * buffers) {if (GLeeInit()) glDeleteBuffersARB(n, buffers);}
GLEEPFNGLDELETEBUFFERSARBPROC GLeeFuncPtr_glDeleteBuffersARB=GLee_Lazy_glDeleteBuffersARB;
#endif
#ifndef GLEE_C_DEFINED_glGenBuffersARB
#define GLEE_C_DEFINED_glGenBuffersARB
void __stdcall GLee_Lazy_glGenBuffersARB(GLsizei n, GLuint * buffers) {if (GLeeInit()) glGenBuffersARB(n, buffers);}
GLEEPFNGLGENBUFFERSARBPROC GLeeFuncPtr_glGenBuffersARB=GLee_Lazy_glGenBuffersARB;
#endif
#ifndef GLEE_C_DEFINED_glIsBufferARB
#define GLEE_C_DEFINED_glIsBufferARB
GLboolean __stdcall GLee_Lazy_glIsBufferARB(GLuint buffer) {if (GLeeInit()) return glIsBufferARB(buffer); return (GLboolean)0;}
GLEEPFNGLISBUFFERARBPROC GLeeFuncPtr_glIsBufferARB=GLee_Lazy_glIsBufferARB;
#endif
#ifndef GLEE_C_DEFINED_glBufferDataARB
#define GLEE_C_DEFINED_glBufferDataARB
void __stdcall GLee_Lazy_glBufferDataARB(GLenum target, GLsizeiptrARB size, const GLvoid * data, GLenum usage) {if (GLeeInit()) glBufferDataARB(target, size, data, usage);}
GLEEPFNGLBUFFERDATAARBPROC GLeeFuncPtr_glBufferDataARB=GLee_Lazy_glBufferDataARB;
#endif
#ifndef GLEE_C_DEFINED_glBufferSubDataARB
#define GLEE_C_DEFINED_glBufferSubDataARB
void __stdcall GLee_Lazy_glBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid * data) {if (GLeeInit()) glBufferSubDataARB(target, offset, size, data);}
GLEEPFNGLBUFFERSUBDATAARBPROC GLeeFuncPtr_glBufferSubDataARB=GLee_Lazy_glBufferSubDataARB;
#endif
#ifndef GLEE_C_DEFINED_glGetBufferSubDataARB
#define GLEE_C_DEFINED_glGetBufferSubDataARB
void __stdcall GLee_Lazy_glGetBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid * data) {if (GLeeInit()) glGetBufferSubDataARB(target, offset, size, data);}
GLEEPFNGLGETBUFFERSUBDATAARBPROC GLeeFuncPtr_glGetBufferSubDataARB=GLee_Lazy_glGetBufferSubDataARB;
#endif
#ifndef GLEE_C_DEFINED_glMapBufferARB
#define GLEE_C_DEFINED_glMapBufferARB
GLvoid* __stdcall GLee_Lazy_glMapBufferARB(GLenum target, GLenum access) {if (GLeeInit()) return glMapBufferARB(target, access); return (GLvoid*)0;}
GLEEPFNGLMAPBUFFERARBPROC GLeeFuncPtr_glMapBufferARB=GLee_Lazy_glMapBufferARB;
#endif
#ifndef GLEE_C_DEFINED_glUnmapBufferARB
#define GLEE_C_DEFINED_glUnmapBufferARB
GLboolean __stdcall GLee_Lazy_glUnmapBufferARB(GLenum target) {if (GLeeInit()) return glUnmapBufferARB(target); return (GLboolean)0;}
GLEEPFNGLUNMAPBUFFERARBPROC GLeeFuncPtr_glUnmapBufferARB=GLee_Lazy_glUnmapBufferARB;
#endif
#ifndef GLEE_C_DEFINED_glGetBufferParameterivARB
#define GLEE_C_DEFINED_glGetBufferParameterivARB
void __stdcall GLee_Lazy_glGetBufferParameterivARB(GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetBufferParameterivARB(target, pname, params);}
GLEEPFNGLGETBUFFERPARAMETERIVARBPROC GLeeFuncPtr_glGetBufferParameterivARB=GLee_Lazy_glGetBufferParameterivARB;
#endif
#ifndef GLEE_C_DEFINED_glGetBufferPointervARB
#define GLEE_C_DEFINED_glGetBufferPointervARB
void __stdcall GLee_Lazy_glGetBufferPointervARB(GLenum target, GLenum pname, GLvoid* * params) {if (GLeeInit()) glGetBufferPointervARB(target, pname, params);}
GLEEPFNGLGETBUFFERPOINTERVARBPROC GLeeFuncPtr_glGetBufferPointervARB=GLee_Lazy_glGetBufferPointervARB;
#endif
#endif
/* GL_ARB_occlusion_query */
#ifdef __GLEE_GL_ARB_occlusion_query
#ifndef GLEE_C_DEFINED_glGenQueriesARB
#define GLEE_C_DEFINED_glGenQueriesARB
void __stdcall GLee_Lazy_glGenQueriesARB(GLsizei n, GLuint * ids) {if (GLeeInit()) glGenQueriesARB(n, ids);}
GLEEPFNGLGENQUERIESARBPROC GLeeFuncPtr_glGenQueriesARB=GLee_Lazy_glGenQueriesARB;
#endif
#ifndef GLEE_C_DEFINED_glDeleteQueriesARB
#define GLEE_C_DEFINED_glDeleteQueriesARB
void __stdcall GLee_Lazy_glDeleteQueriesARB(GLsizei n, const GLuint * ids) {if (GLeeInit()) glDeleteQueriesARB(n, ids);}
GLEEPFNGLDELETEQUERIESARBPROC GLeeFuncPtr_glDeleteQueriesARB=GLee_Lazy_glDeleteQueriesARB;
#endif
#ifndef GLEE_C_DEFINED_glIsQueryARB
#define GLEE_C_DEFINED_glIsQueryARB
GLboolean __stdcall GLee_Lazy_glIsQueryARB(GLuint id) {if (GLeeInit()) return glIsQueryARB(id); return (GLboolean)0;}
GLEEPFNGLISQUERYARBPROC GLeeFuncPtr_glIsQueryARB=GLee_Lazy_glIsQueryARB;
#endif
#ifndef GLEE_C_DEFINED_glBeginQueryARB
#define GLEE_C_DEFINED_glBeginQueryARB
void __stdcall GLee_Lazy_glBeginQueryARB(GLenum target, GLuint id) {if (GLeeInit()) glBeginQueryARB(target, id);}
GLEEPFNGLBEGINQUERYARBPROC GLeeFuncPtr_glBeginQueryARB=GLee_Lazy_glBeginQueryARB;
#endif
#ifndef GLEE_C_DEFINED_glEndQueryARB
#define GLEE_C_DEFINED_glEndQueryARB
void __stdcall GLee_Lazy_glEndQueryARB(GLenum target) {if (GLeeInit()) glEndQueryARB(target);}
GLEEPFNGLENDQUERYARBPROC GLeeFuncPtr_glEndQueryARB=GLee_Lazy_glEndQueryARB;
#endif
#ifndef GLEE_C_DEFINED_glGetQueryivARB
#define GLEE_C_DEFINED_glGetQueryivARB
void __stdcall GLee_Lazy_glGetQueryivARB(GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetQueryivARB(target, pname, params);}
GLEEPFNGLGETQUERYIVARBPROC GLeeFuncPtr_glGetQueryivARB=GLee_Lazy_glGetQueryivARB;
#endif
#ifndef GLEE_C_DEFINED_glGetQueryObjectivARB
#define GLEE_C_DEFINED_glGetQueryObjectivARB
void __stdcall GLee_Lazy_glGetQueryObjectivARB(GLuint id, GLenum pname, GLint * params) {if (GLeeInit()) glGetQueryObjectivARB(id, pname, params);}
GLEEPFNGLGETQUERYOBJECTIVARBPROC GLeeFuncPtr_glGetQueryObjectivARB=GLee_Lazy_glGetQueryObjectivARB;
#endif
#ifndef GLEE_C_DEFINED_glGetQueryObjectuivARB
#define GLEE_C_DEFINED_glGetQueryObjectuivARB
void __stdcall GLee_Lazy_glGetQueryObjectuivARB(GLuint id, GLenum pname, GLuint * params) {if (GLeeInit()) glGetQueryObjectuivARB(id, pname, params);}
GLEEPFNGLGETQUERYOBJECTUIVARBPROC GLeeFuncPtr_glGetQueryObjectuivARB=GLee_Lazy_glGetQueryObjectuivARB;
#endif
#endif
/* GL_ARB_shader_objects */
#ifdef __GLEE_GL_ARB_shader_objects
#ifndef GLEE_C_DEFINED_glDeleteObjectARB
#define GLEE_C_DEFINED_glDeleteObjectARB
void __stdcall GLee_Lazy_glDeleteObjectARB(GLhandleARB obj) {if (GLeeInit()) glDeleteObjectARB(obj);}
GLEEPFNGLDELETEOBJECTARBPROC GLeeFuncPtr_glDeleteObjectARB=GLee_Lazy_glDeleteObjectARB;
#endif
#ifndef GLEE_C_DEFINED_glGetHandleARB
#define GLEE_C_DEFINED_glGetHandleARB
GLhandleARB __stdcall GLee_Lazy_glGetHandleARB(GLenum pname) {if (GLeeInit()) return glGetHandleARB(pname); return (GLhandleARB)0;}
GLEEPFNGLGETHANDLEARBPROC GLeeFuncPtr_glGetHandleARB=GLee_Lazy_glGetHandleARB;
#endif
#ifndef GLEE_C_DEFINED_glDetachObjectARB
#define GLEE_C_DEFINED_glDetachObjectARB
void __stdcall GLee_Lazy_glDetachObjectARB(GLhandleARB containerObj, GLhandleARB attachedObj) {if (GLeeInit()) glDetachObjectARB(containerObj, attachedObj);}
GLEEPFNGLDETACHOBJECTARBPROC GLeeFuncPtr_glDetachObjectARB=GLee_Lazy_glDetachObjectARB;
#endif
#ifndef GLEE_C_DEFINED_glCreateShaderObjectARB
#define GLEE_C_DEFINED_glCreateShaderObjectARB
GLhandleARB __stdcall GLee_Lazy_glCreateShaderObjectARB(GLenum shaderType) {if (GLeeInit()) return glCreateShaderObjectARB(shaderType); return (GLhandleARB)0;}
GLEEPFNGLCREATESHADEROBJECTARBPROC GLeeFuncPtr_glCreateShaderObjectARB=GLee_Lazy_glCreateShaderObjectARB;
#endif
#ifndef GLEE_C_DEFINED_glShaderSourceARB
#define GLEE_C_DEFINED_glShaderSourceARB
void __stdcall GLee_Lazy_glShaderSourceARB(GLhandleARB shaderObj, GLsizei count, const GLcharARB* * string, const GLint * length) {if (GLeeInit()) glShaderSourceARB(shaderObj, count, string, length);}
GLEEPFNGLSHADERSOURCEARBPROC GLeeFuncPtr_glShaderSourceARB=GLee_Lazy_glShaderSourceARB;
#endif
#ifndef GLEE_C_DEFINED_glCompileShaderARB
#define GLEE_C_DEFINED_glCompileShaderARB
void __stdcall GLee_Lazy_glCompileShaderARB(GLhandleARB shaderObj) {if (GLeeInit()) glCompileShaderARB(shaderObj);}
GLEEPFNGLCOMPILESHADERARBPROC GLeeFuncPtr_glCompileShaderARB=GLee_Lazy_glCompileShaderARB;
#endif
#ifndef GLEE_C_DEFINED_glCreateProgramObjectARB
#define GLEE_C_DEFINED_glCreateProgramObjectARB
GLhandleARB __stdcall GLee_Lazy_glCreateProgramObjectARB(void) {if (GLeeInit()) return glCreateProgramObjectARB(); return (GLhandleARB)0;}
GLEEPFNGLCREATEPROGRAMOBJECTARBPROC GLeeFuncPtr_glCreateProgramObjectARB=GLee_Lazy_glCreateProgramObjectARB;
#endif
#ifndef GLEE_C_DEFINED_glAttachObjectARB
#define GLEE_C_DEFINED_glAttachObjectARB
void __stdcall GLee_Lazy_glAttachObjectARB(GLhandleARB containerObj, GLhandleARB obj) {if (GLeeInit()) glAttachObjectARB(containerObj, obj);}
GLEEPFNGLATTACHOBJECTARBPROC GLeeFuncPtr_glAttachObjectARB=GLee_Lazy_glAttachObjectARB;
#endif
#ifndef GLEE_C_DEFINED_glLinkProgramARB
#define GLEE_C_DEFINED_glLinkProgramARB
void __stdcall GLee_Lazy_glLinkProgramARB(GLhandleARB programObj) {if (GLeeInit()) glLinkProgramARB(programObj);}
GLEEPFNGLLINKPROGRAMARBPROC GLeeFuncPtr_glLinkProgramARB=GLee_Lazy_glLinkProgramARB;
#endif
#ifndef GLEE_C_DEFINED_glUseProgramObjectARB
#define GLEE_C_DEFINED_glUseProgramObjectARB
void __stdcall GLee_Lazy_glUseProgramObjectARB(GLhandleARB programObj) {if (GLeeInit()) glUseProgramObjectARB(programObj);}
GLEEPFNGLUSEPROGRAMOBJECTARBPROC GLeeFuncPtr_glUseProgramObjectARB=GLee_Lazy_glUseProgramObjectARB;
#endif
#ifndef GLEE_C_DEFINED_glValidateProgramARB
#define GLEE_C_DEFINED_glValidateProgramARB
void __stdcall GLee_Lazy_glValidateProgramARB(GLhandleARB programObj) {if (GLeeInit()) glValidateProgramARB(programObj);}
GLEEPFNGLVALIDATEPROGRAMARBPROC GLeeFuncPtr_glValidateProgramARB=GLee_Lazy_glValidateProgramARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform1fARB
#define GLEE_C_DEFINED_glUniform1fARB
void __stdcall GLee_Lazy_glUniform1fARB(GLint location, GLfloat v0) {if (GLeeInit()) glUniform1fARB(location, v0);}
GLEEPFNGLUNIFORM1FARBPROC GLeeFuncPtr_glUniform1fARB=GLee_Lazy_glUniform1fARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform2fARB
#define GLEE_C_DEFINED_glUniform2fARB
void __stdcall GLee_Lazy_glUniform2fARB(GLint location, GLfloat v0, GLfloat v1) {if (GLeeInit()) glUniform2fARB(location, v0, v1);}
GLEEPFNGLUNIFORM2FARBPROC GLeeFuncPtr_glUniform2fARB=GLee_Lazy_glUniform2fARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform3fARB
#define GLEE_C_DEFINED_glUniform3fARB
void __stdcall GLee_Lazy_glUniform3fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {if (GLeeInit()) glUniform3fARB(location, v0, v1, v2);}
GLEEPFNGLUNIFORM3FARBPROC GLeeFuncPtr_glUniform3fARB=GLee_Lazy_glUniform3fARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform4fARB
#define GLEE_C_DEFINED_glUniform4fARB
void __stdcall GLee_Lazy_glUniform4fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {if (GLeeInit()) glUniform4fARB(location, v0, v1, v2, v3);}
GLEEPFNGLUNIFORM4FARBPROC GLeeFuncPtr_glUniform4fARB=GLee_Lazy_glUniform4fARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform1iARB
#define GLEE_C_DEFINED_glUniform1iARB
void __stdcall GLee_Lazy_glUniform1iARB(GLint location, GLint v0) {if (GLeeInit()) glUniform1iARB(location, v0);}
GLEEPFNGLUNIFORM1IARBPROC GLeeFuncPtr_glUniform1iARB=GLee_Lazy_glUniform1iARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform2iARB
#define GLEE_C_DEFINED_glUniform2iARB
void __stdcall GLee_Lazy_glUniform2iARB(GLint location, GLint v0, GLint v1) {if (GLeeInit()) glUniform2iARB(location, v0, v1);}
GLEEPFNGLUNIFORM2IARBPROC GLeeFuncPtr_glUniform2iARB=GLee_Lazy_glUniform2iARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform3iARB
#define GLEE_C_DEFINED_glUniform3iARB
void __stdcall GLee_Lazy_glUniform3iARB(GLint location, GLint v0, GLint v1, GLint v2) {if (GLeeInit()) glUniform3iARB(location, v0, v1, v2);}
GLEEPFNGLUNIFORM3IARBPROC GLeeFuncPtr_glUniform3iARB=GLee_Lazy_glUniform3iARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform4iARB
#define GLEE_C_DEFINED_glUniform4iARB
void __stdcall GLee_Lazy_glUniform4iARB(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {if (GLeeInit()) glUniform4iARB(location, v0, v1, v2, v3);}
GLEEPFNGLUNIFORM4IARBPROC GLeeFuncPtr_glUniform4iARB=GLee_Lazy_glUniform4iARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform1fvARB
#define GLEE_C_DEFINED_glUniform1fvARB
void __stdcall GLee_Lazy_glUniform1fvARB(GLint location, GLsizei count, const GLfloat * value) {if (GLeeInit()) glUniform1fvARB(location, count, value);}
GLEEPFNGLUNIFORM1FVARBPROC GLeeFuncPtr_glUniform1fvARB=GLee_Lazy_glUniform1fvARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform2fvARB
#define GLEE_C_DEFINED_glUniform2fvARB
void __stdcall GLee_Lazy_glUniform2fvARB(GLint location, GLsizei count, const GLfloat * value) {if (GLeeInit()) glUniform2fvARB(location, count, value);}
GLEEPFNGLUNIFORM2FVARBPROC GLeeFuncPtr_glUniform2fvARB=GLee_Lazy_glUniform2fvARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform3fvARB
#define GLEE_C_DEFINED_glUniform3fvARB
void __stdcall GLee_Lazy_glUniform3fvARB(GLint location, GLsizei count, const GLfloat * value) {if (GLeeInit()) glUniform3fvARB(location, count, value);}
GLEEPFNGLUNIFORM3FVARBPROC GLeeFuncPtr_glUniform3fvARB=GLee_Lazy_glUniform3fvARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform4fvARB
#define GLEE_C_DEFINED_glUniform4fvARB
void __stdcall GLee_Lazy_glUniform4fvARB(GLint location, GLsizei count, const GLfloat * value) {if (GLeeInit()) glUniform4fvARB(location, count, value);}
GLEEPFNGLUNIFORM4FVARBPROC GLeeFuncPtr_glUniform4fvARB=GLee_Lazy_glUniform4fvARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform1ivARB
#define GLEE_C_DEFINED_glUniform1ivARB
void __stdcall GLee_Lazy_glUniform1ivARB(GLint location, GLsizei count, const GLint * value) {if (GLeeInit()) glUniform1ivARB(location, count, value);}
GLEEPFNGLUNIFORM1IVARBPROC GLeeFuncPtr_glUniform1ivARB=GLee_Lazy_glUniform1ivARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform2ivARB
#define GLEE_C_DEFINED_glUniform2ivARB
void __stdcall GLee_Lazy_glUniform2ivARB(GLint location, GLsizei count, const GLint * value) {if (GLeeInit()) glUniform2ivARB(location, count, value);}
GLEEPFNGLUNIFORM2IVARBPROC GLeeFuncPtr_glUniform2ivARB=GLee_Lazy_glUniform2ivARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform3ivARB
#define GLEE_C_DEFINED_glUniform3ivARB
void __stdcall GLee_Lazy_glUniform3ivARB(GLint location, GLsizei count, const GLint * value) {if (GLeeInit()) glUniform3ivARB(location, count, value);}
GLEEPFNGLUNIFORM3IVARBPROC GLeeFuncPtr_glUniform3ivARB=GLee_Lazy_glUniform3ivARB;
#endif
#ifndef GLEE_C_DEFINED_glUniform4ivARB
#define GLEE_C_DEFINED_glUniform4ivARB
void __stdcall GLee_Lazy_glUniform4ivARB(GLint location, GLsizei count, const GLint * value) {if (GLeeInit()) glUniform4ivARB(location, count, value);}
GLEEPFNGLUNIFORM4IVARBPROC GLeeFuncPtr_glUniform4ivARB=GLee_Lazy_glUniform4ivARB;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix2fvARB
#define GLEE_C_DEFINED_glUniformMatrix2fvARB
void __stdcall GLee_Lazy_glUniformMatrix2fvARB(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glUniformMatrix2fvARB(location, count, transpose, value);}
GLEEPFNGLUNIFORMMATRIX2FVARBPROC GLeeFuncPtr_glUniformMatrix2fvARB=GLee_Lazy_glUniformMatrix2fvARB;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix3fvARB
#define GLEE_C_DEFINED_glUniformMatrix3fvARB
void __stdcall GLee_Lazy_glUniformMatrix3fvARB(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glUniformMatrix3fvARB(location, count, transpose, value);}
GLEEPFNGLUNIFORMMATRIX3FVARBPROC GLeeFuncPtr_glUniformMatrix3fvARB=GLee_Lazy_glUniformMatrix3fvARB;
#endif
#ifndef GLEE_C_DEFINED_glUniformMatrix4fvARB
#define GLEE_C_DEFINED_glUniformMatrix4fvARB
void __stdcall GLee_Lazy_glUniformMatrix4fvARB(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glUniformMatrix4fvARB(location, count, transpose, value);}
GLEEPFNGLUNIFORMMATRIX4FVARBPROC GLeeFuncPtr_glUniformMatrix4fvARB=GLee_Lazy_glUniformMatrix4fvARB;
#endif
#ifndef GLEE_C_DEFINED_glGetObjectParameterfvARB
#define GLEE_C_DEFINED_glGetObjectParameterfvARB
void __stdcall GLee_Lazy_glGetObjectParameterfvARB(GLhandleARB obj, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetObjectParameterfvARB(obj, pname, params);}
GLEEPFNGLGETOBJECTPARAMETERFVARBPROC GLeeFuncPtr_glGetObjectParameterfvARB=GLee_Lazy_glGetObjectParameterfvARB;
#endif
#ifndef GLEE_C_DEFINED_glGetObjectParameterivARB
#define GLEE_C_DEFINED_glGetObjectParameterivARB
void __stdcall GLee_Lazy_glGetObjectParameterivARB(GLhandleARB obj, GLenum pname, GLint * params) {if (GLeeInit()) glGetObjectParameterivARB(obj, pname, params);}
GLEEPFNGLGETOBJECTPARAMETERIVARBPROC GLeeFuncPtr_glGetObjectParameterivARB=GLee_Lazy_glGetObjectParameterivARB;
#endif
#ifndef GLEE_C_DEFINED_glGetInfoLogARB
#define GLEE_C_DEFINED_glGetInfoLogARB
void __stdcall GLee_Lazy_glGetInfoLogARB(GLhandleARB obj, GLsizei maxLength, GLsizei * length, GLcharARB * infoLog) {if (GLeeInit()) glGetInfoLogARB(obj, maxLength, length, infoLog);}
GLEEPFNGLGETINFOLOGARBPROC GLeeFuncPtr_glGetInfoLogARB=GLee_Lazy_glGetInfoLogARB;
#endif
#ifndef GLEE_C_DEFINED_glGetAttachedObjectsARB
#define GLEE_C_DEFINED_glGetAttachedObjectsARB
void __stdcall GLee_Lazy_glGetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, GLsizei * count, GLhandleARB * obj) {if (GLeeInit()) glGetAttachedObjectsARB(containerObj, maxCount, count, obj);}
GLEEPFNGLGETATTACHEDOBJECTSARBPROC GLeeFuncPtr_glGetAttachedObjectsARB=GLee_Lazy_glGetAttachedObjectsARB;
#endif
#ifndef GLEE_C_DEFINED_glGetUniformLocationARB
#define GLEE_C_DEFINED_glGetUniformLocationARB
GLint __stdcall GLee_Lazy_glGetUniformLocationARB(GLhandleARB programObj, const GLcharARB * name) {if (GLeeInit()) return glGetUniformLocationARB(programObj, name); return (GLint)0;}
GLEEPFNGLGETUNIFORMLOCATIONARBPROC GLeeFuncPtr_glGetUniformLocationARB=GLee_Lazy_glGetUniformLocationARB;
#endif
#ifndef GLEE_C_DEFINED_glGetActiveUniformARB
#define GLEE_C_DEFINED_glGetActiveUniformARB
void __stdcall GLee_Lazy_glGetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei * length, GLint * size, GLenum * type, GLcharARB * name) {if (GLeeInit()) glGetActiveUniformARB(programObj, index, maxLength, length, size, type, name);}
GLEEPFNGLGETACTIVEUNIFORMARBPROC GLeeFuncPtr_glGetActiveUniformARB=GLee_Lazy_glGetActiveUniformARB;
#endif
#ifndef GLEE_C_DEFINED_glGetUniformfvARB
#define GLEE_C_DEFINED_glGetUniformfvARB
void __stdcall GLee_Lazy_glGetUniformfvARB(GLhandleARB programObj, GLint location, GLfloat * params) {if (GLeeInit()) glGetUniformfvARB(programObj, location, params);}
GLEEPFNGLGETUNIFORMFVARBPROC GLeeFuncPtr_glGetUniformfvARB=GLee_Lazy_glGetUniformfvARB;
#endif
#ifndef GLEE_C_DEFINED_glGetUniformivARB
#define GLEE_C_DEFINED_glGetUniformivARB
void __stdcall GLee_Lazy_glGetUniformivARB(GLhandleARB programObj, GLint location, GLint * params) {if (GLeeInit()) glGetUniformivARB(programObj, location, params);}
GLEEPFNGLGETUNIFORMIVARBPROC GLeeFuncPtr_glGetUniformivARB=GLee_Lazy_glGetUniformivARB;
#endif
#ifndef GLEE_C_DEFINED_glGetShaderSourceARB
#define GLEE_C_DEFINED_glGetShaderSourceARB
void __stdcall GLee_Lazy_glGetShaderSourceARB(GLhandleARB obj, GLsizei maxLength, GLsizei * length, GLcharARB * source) {if (GLeeInit()) glGetShaderSourceARB(obj, maxLength, length, source);}
GLEEPFNGLGETSHADERSOURCEARBPROC GLeeFuncPtr_glGetShaderSourceARB=GLee_Lazy_glGetShaderSourceARB;
#endif
#endif
/* GL_ARB_vertex_shader */
#ifdef __GLEE_GL_ARB_vertex_shader
#ifndef GLEE_C_DEFINED_glBindAttribLocationARB
#define GLEE_C_DEFINED_glBindAttribLocationARB
void __stdcall GLee_Lazy_glBindAttribLocationARB(GLhandleARB programObj, GLuint index, const GLcharARB * name) {if (GLeeInit()) glBindAttribLocationARB(programObj, index, name);}
GLEEPFNGLBINDATTRIBLOCATIONARBPROC GLeeFuncPtr_glBindAttribLocationARB=GLee_Lazy_glBindAttribLocationARB;
#endif
#ifndef GLEE_C_DEFINED_glGetActiveAttribARB
#define GLEE_C_DEFINED_glGetActiveAttribARB
void __stdcall GLee_Lazy_glGetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei * length, GLint * size, GLenum * type, GLcharARB * name) {if (GLeeInit()) glGetActiveAttribARB(programObj, index, maxLength, length, size, type, name);}
GLEEPFNGLGETACTIVEATTRIBARBPROC GLeeFuncPtr_glGetActiveAttribARB=GLee_Lazy_glGetActiveAttribARB;
#endif
#ifndef GLEE_C_DEFINED_glGetAttribLocationARB
#define GLEE_C_DEFINED_glGetAttribLocationARB
GLint __stdcall GLee_Lazy_glGetAttribLocationARB(GLhandleARB programObj, const GLcharARB * name) {if (GLeeInit()) return glGetAttribLocationARB(programObj, name); return (GLint)0;}
GLEEPFNGLGETATTRIBLOCATIONARBPROC GLeeFuncPtr_glGetAttribLocationARB=GLee_Lazy_glGetAttribLocationARB;
#endif
#endif
/* GL_ARB_fragment_shader */
#ifdef __GLEE_GL_ARB_fragment_shader
#endif
/* GL_ARB_shading_language_100 */
#ifdef __GLEE_GL_ARB_shading_language_100
#endif
/* GL_ARB_texture_non_power_of_two */
#ifdef __GLEE_GL_ARB_texture_non_power_of_two
#endif
/* GL_ARB_point_sprite */
#ifdef __GLEE_GL_ARB_point_sprite
#endif
/* GL_ARB_fragment_program_shadow */
#ifdef __GLEE_GL_ARB_fragment_program_shadow
#endif
/* GL_ARB_draw_buffers */
#ifdef __GLEE_GL_ARB_draw_buffers
#ifndef GLEE_C_DEFINED_glDrawBuffersARB
#define GLEE_C_DEFINED_glDrawBuffersARB
void __stdcall GLee_Lazy_glDrawBuffersARB(GLsizei n, const GLenum * bufs) {if (GLeeInit()) glDrawBuffersARB(n, bufs);}
GLEEPFNGLDRAWBUFFERSARBPROC GLeeFuncPtr_glDrawBuffersARB=GLee_Lazy_glDrawBuffersARB;
#endif
#endif
/* GL_ARB_texture_rectangle */
#ifdef __GLEE_GL_ARB_texture_rectangle
#endif
/* GL_ARB_color_buffer_float */
#ifdef __GLEE_GL_ARB_color_buffer_float
#ifndef GLEE_C_DEFINED_glClampColorARB
#define GLEE_C_DEFINED_glClampColorARB
void __stdcall GLee_Lazy_glClampColorARB(GLenum target, GLenum clamp) {if (GLeeInit()) glClampColorARB(target, clamp);}
GLEEPFNGLCLAMPCOLORARBPROC GLeeFuncPtr_glClampColorARB=GLee_Lazy_glClampColorARB;
#endif
#endif
/* GL_ARB_half_float_pixel */
#ifdef __GLEE_GL_ARB_half_float_pixel
#endif
/* GL_ARB_texture_float */
#ifdef __GLEE_GL_ARB_texture_float
#endif
/* GL_ARB_pixel_buffer_object */
#ifdef __GLEE_GL_ARB_pixel_buffer_object
#endif
/* GL_ARB_depth_buffer_float */
#ifdef __GLEE_GL_ARB_depth_buffer_float
#endif
/* GL_ARB_draw_instanced */
#ifdef __GLEE_GL_ARB_draw_instanced
#ifndef GLEE_C_DEFINED_glDrawArraysInstancedARB
#define GLEE_C_DEFINED_glDrawArraysInstancedARB
void __stdcall GLee_Lazy_glDrawArraysInstancedARB(GLenum mode, GLint first, GLsizei count, GLsizei primcount) {if (GLeeInit()) glDrawArraysInstancedARB(mode, first, count, primcount);}
GLEEPFNGLDRAWARRAYSINSTANCEDARBPROC GLeeFuncPtr_glDrawArraysInstancedARB=GLee_Lazy_glDrawArraysInstancedARB;
#endif
#ifndef GLEE_C_DEFINED_glDrawElementsInstancedARB
#define GLEE_C_DEFINED_glDrawElementsInstancedARB
void __stdcall GLee_Lazy_glDrawElementsInstancedARB(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices, GLsizei primcount) {if (GLeeInit()) glDrawElementsInstancedARB(mode, count, type, indices, primcount);}
GLEEPFNGLDRAWELEMENTSINSTANCEDARBPROC GLeeFuncPtr_glDrawElementsInstancedARB=GLee_Lazy_glDrawElementsInstancedARB;
#endif
#endif
/* GL_ARB_framebuffer_object */
#ifdef __GLEE_GL_ARB_framebuffer_object
#ifndef GLEE_C_DEFINED_glIsRenderbuffer
#define GLEE_C_DEFINED_glIsRenderbuffer
GLboolean __stdcall GLee_Lazy_glIsRenderbuffer(GLuint renderbuffer) {if (GLeeInit()) return glIsRenderbuffer(renderbuffer); return (GLboolean)0;}
GLEEPFNGLISRENDERBUFFERPROC GLeeFuncPtr_glIsRenderbuffer=GLee_Lazy_glIsRenderbuffer;
#endif
#ifndef GLEE_C_DEFINED_glBindRenderbuffer
#define GLEE_C_DEFINED_glBindRenderbuffer
void __stdcall GLee_Lazy_glBindRenderbuffer(GLenum target, GLuint renderbuffer) {if (GLeeInit()) glBindRenderbuffer(target, renderbuffer);}
GLEEPFNGLBINDRENDERBUFFERPROC GLeeFuncPtr_glBindRenderbuffer=GLee_Lazy_glBindRenderbuffer;
#endif
#ifndef GLEE_C_DEFINED_glDeleteRenderbuffers
#define GLEE_C_DEFINED_glDeleteRenderbuffers
void __stdcall GLee_Lazy_glDeleteRenderbuffers(GLsizei n, const GLuint * renderbuffers) {if (GLeeInit()) glDeleteRenderbuffers(n, renderbuffers);}
GLEEPFNGLDELETERENDERBUFFERSPROC GLeeFuncPtr_glDeleteRenderbuffers=GLee_Lazy_glDeleteRenderbuffers;
#endif
#ifndef GLEE_C_DEFINED_glGenRenderbuffers
#define GLEE_C_DEFINED_glGenRenderbuffers
void __stdcall GLee_Lazy_glGenRenderbuffers(GLsizei n, GLuint * renderbuffers) {if (GLeeInit()) glGenRenderbuffers(n, renderbuffers);}
GLEEPFNGLGENRENDERBUFFERSPROC GLeeFuncPtr_glGenRenderbuffers=GLee_Lazy_glGenRenderbuffers;
#endif
#ifndef GLEE_C_DEFINED_glRenderbufferStorage
#define GLEE_C_DEFINED_glRenderbufferStorage
void __stdcall GLee_Lazy_glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {if (GLeeInit()) glRenderbufferStorage(target, internalformat, width, height);}
GLEEPFNGLRENDERBUFFERSTORAGEPROC GLeeFuncPtr_glRenderbufferStorage=GLee_Lazy_glRenderbufferStorage;
#endif
#ifndef GLEE_C_DEFINED_glGetRenderbufferParameteriv
#define GLEE_C_DEFINED_glGetRenderbufferParameteriv
void __stdcall GLee_Lazy_glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetRenderbufferParameteriv(target, pname, params);}
GLEEPFNGLGETRENDERBUFFERPARAMETERIVPROC GLeeFuncPtr_glGetRenderbufferParameteriv=GLee_Lazy_glGetRenderbufferParameteriv;
#endif
#ifndef GLEE_C_DEFINED_glIsFramebuffer
#define GLEE_C_DEFINED_glIsFramebuffer
GLboolean __stdcall GLee_Lazy_glIsFramebuffer(GLuint framebuffer) {if (GLeeInit()) return glIsFramebuffer(framebuffer); return (GLboolean)0;}
GLEEPFNGLISFRAMEBUFFERPROC GLeeFuncPtr_glIsFramebuffer=GLee_Lazy_glIsFramebuffer;
#endif
#ifndef GLEE_C_DEFINED_glBindFramebuffer
#define GLEE_C_DEFINED_glBindFramebuffer
void __stdcall GLee_Lazy_glBindFramebuffer(GLenum target, GLuint framebuffer) {if (GLeeInit()) glBindFramebuffer(target, framebuffer);}
GLEEPFNGLBINDFRAMEBUFFERPROC GLeeFuncPtr_glBindFramebuffer=GLee_Lazy_glBindFramebuffer;
#endif
#ifndef GLEE_C_DEFINED_glDeleteFramebuffers
#define GLEE_C_DEFINED_glDeleteFramebuffers
void __stdcall GLee_Lazy_glDeleteFramebuffers(GLsizei n, const GLuint * framebuffers) {if (GLeeInit()) glDeleteFramebuffers(n, framebuffers);}
GLEEPFNGLDELETEFRAMEBUFFERSPROC GLeeFuncPtr_glDeleteFramebuffers=GLee_Lazy_glDeleteFramebuffers;
#endif
#ifndef GLEE_C_DEFINED_glGenFramebuffers
#define GLEE_C_DEFINED_glGenFramebuffers
void __stdcall GLee_Lazy_glGenFramebuffers(GLsizei n, GLuint * framebuffers) {if (GLeeInit()) glGenFramebuffers(n, framebuffers);}
GLEEPFNGLGENFRAMEBUFFERSPROC GLeeFuncPtr_glGenFramebuffers=GLee_Lazy_glGenFramebuffers;
#endif
#ifndef GLEE_C_DEFINED_glCheckFramebufferStatus
#define GLEE_C_DEFINED_glCheckFramebufferStatus
GLenum __stdcall GLee_Lazy_glCheckFramebufferStatus(GLenum target) {if (GLeeInit()) return glCheckFramebufferStatus(target); return (GLenum)0;}
GLEEPFNGLCHECKFRAMEBUFFERSTATUSPROC GLeeFuncPtr_glCheckFramebufferStatus=GLee_Lazy_glCheckFramebufferStatus;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferTexture1D
#define GLEE_C_DEFINED_glFramebufferTexture1D
void __stdcall GLee_Lazy_glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {if (GLeeInit()) glFramebufferTexture1D(target, attachment, textarget, texture, level);}
GLEEPFNGLFRAMEBUFFERTEXTURE1DPROC GLeeFuncPtr_glFramebufferTexture1D=GLee_Lazy_glFramebufferTexture1D;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferTexture2D
#define GLEE_C_DEFINED_glFramebufferTexture2D
void __stdcall GLee_Lazy_glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {if (GLeeInit()) glFramebufferTexture2D(target, attachment, textarget, texture, level);}
GLEEPFNGLFRAMEBUFFERTEXTURE2DPROC GLeeFuncPtr_glFramebufferTexture2D=GLee_Lazy_glFramebufferTexture2D;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferTexture3D
#define GLEE_C_DEFINED_glFramebufferTexture3D
void __stdcall GLee_Lazy_glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) {if (GLeeInit()) glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);}
GLEEPFNGLFRAMEBUFFERTEXTURE3DPROC GLeeFuncPtr_glFramebufferTexture3D=GLee_Lazy_glFramebufferTexture3D;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferRenderbuffer
#define GLEE_C_DEFINED_glFramebufferRenderbuffer
void __stdcall GLee_Lazy_glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) {if (GLeeInit()) glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);}
GLEEPFNGLFRAMEBUFFERRENDERBUFFERPROC GLeeFuncPtr_glFramebufferRenderbuffer=GLee_Lazy_glFramebufferRenderbuffer;
#endif
#ifndef GLEE_C_DEFINED_glGetFramebufferAttachmentParameteriv
#define GLEE_C_DEFINED_glGetFramebufferAttachmentParameteriv
void __stdcall GLee_Lazy_glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint * params) {if (GLeeInit()) glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);}
GLEEPFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC GLeeFuncPtr_glGetFramebufferAttachmentParameteriv=GLee_Lazy_glGetFramebufferAttachmentParameteriv;
#endif
#ifndef GLEE_C_DEFINED_glGenerateMipmap
#define GLEE_C_DEFINED_glGenerateMipmap
void __stdcall GLee_Lazy_glGenerateMipmap(GLenum target) {if (GLeeInit()) glGenerateMipmap(target);}
GLEEPFNGLGENERATEMIPMAPPROC GLeeFuncPtr_glGenerateMipmap=GLee_Lazy_glGenerateMipmap;
#endif
#ifndef GLEE_C_DEFINED_glBlitFramebuffer
#define GLEE_C_DEFINED_glBlitFramebuffer
void __stdcall GLee_Lazy_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) {if (GLeeInit()) glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);}
GLEEPFNGLBLITFRAMEBUFFERPROC GLeeFuncPtr_glBlitFramebuffer=GLee_Lazy_glBlitFramebuffer;
#endif
#ifndef GLEE_C_DEFINED_glRenderbufferStorageMultisample
#define GLEE_C_DEFINED_glRenderbufferStorageMultisample
void __stdcall GLee_Lazy_glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) {if (GLeeInit()) glRenderbufferStorageMultisample(target, samples, internalformat, width, height);}
GLEEPFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC GLeeFuncPtr_glRenderbufferStorageMultisample=GLee_Lazy_glRenderbufferStorageMultisample;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferTextureLayer
#define GLEE_C_DEFINED_glFramebufferTextureLayer
void __stdcall GLee_Lazy_glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) {if (GLeeInit()) glFramebufferTextureLayer(target, attachment, texture, level, layer);}
GLEEPFNGLFRAMEBUFFERTEXTURELAYERPROC GLeeFuncPtr_glFramebufferTextureLayer=GLee_Lazy_glFramebufferTextureLayer;
#endif
#endif
/* GL_ARB_framebuffer_sRGB */
#ifdef __GLEE_GL_ARB_framebuffer_sRGB
#endif
/* GL_ARB_geometry_shader4 */
#ifdef __GLEE_GL_ARB_geometry_shader4
#ifndef GLEE_C_DEFINED_glProgramParameteriARB
#define GLEE_C_DEFINED_glProgramParameteriARB
void __stdcall GLee_Lazy_glProgramParameteriARB(GLuint program, GLenum pname, GLint value) {if (GLeeInit()) glProgramParameteriARB(program, pname, value);}
GLEEPFNGLPROGRAMPARAMETERIARBPROC GLeeFuncPtr_glProgramParameteriARB=GLee_Lazy_glProgramParameteriARB;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferTextureARB
#define GLEE_C_DEFINED_glFramebufferTextureARB
void __stdcall GLee_Lazy_glFramebufferTextureARB(GLenum target, GLenum attachment, GLuint texture, GLint level) {if (GLeeInit()) glFramebufferTextureARB(target, attachment, texture, level);}
GLEEPFNGLFRAMEBUFFERTEXTUREARBPROC GLeeFuncPtr_glFramebufferTextureARB=GLee_Lazy_glFramebufferTextureARB;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferTextureLayerARB
#define GLEE_C_DEFINED_glFramebufferTextureLayerARB
void __stdcall GLee_Lazy_glFramebufferTextureLayerARB(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) {if (GLeeInit()) glFramebufferTextureLayerARB(target, attachment, texture, level, layer);}
GLEEPFNGLFRAMEBUFFERTEXTURELAYERARBPROC GLeeFuncPtr_glFramebufferTextureLayerARB=GLee_Lazy_glFramebufferTextureLayerARB;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferTextureFaceARB
#define GLEE_C_DEFINED_glFramebufferTextureFaceARB
void __stdcall GLee_Lazy_glFramebufferTextureFaceARB(GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face) {if (GLeeInit()) glFramebufferTextureFaceARB(target, attachment, texture, level, face);}
GLEEPFNGLFRAMEBUFFERTEXTUREFACEARBPROC GLeeFuncPtr_glFramebufferTextureFaceARB=GLee_Lazy_glFramebufferTextureFaceARB;
#endif
#endif
/* GL_ARB_half_float_vertex */
#ifdef __GLEE_GL_ARB_half_float_vertex
#endif
/* GL_ARB_instanced_arrays */
#ifdef __GLEE_GL_ARB_instanced_arrays
#ifndef GLEE_C_DEFINED_glVertexAttribDivisor
#define GLEE_C_DEFINED_glVertexAttribDivisor
void __stdcall GLee_Lazy_glVertexAttribDivisor(GLuint index, GLuint divisor) {if (GLeeInit()) glVertexAttribDivisor(index, divisor);}
GLEEPFNGLVERTEXATTRIBDIVISORPROC GLeeFuncPtr_glVertexAttribDivisor=GLee_Lazy_glVertexAttribDivisor;
#endif
#endif
/* GL_ARB_map_buffer_range */
#ifdef __GLEE_GL_ARB_map_buffer_range
#ifndef GLEE_C_DEFINED_glMapBufferRange
#define GLEE_C_DEFINED_glMapBufferRange
void __stdcall GLee_Lazy_glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) {if (GLeeInit()) glMapBufferRange(target, offset, length, access);}
GLEEPFNGLMAPBUFFERRANGEPROC GLeeFuncPtr_glMapBufferRange=GLee_Lazy_glMapBufferRange;
#endif
#ifndef GLEE_C_DEFINED_glFlushMappedBufferRange
#define GLEE_C_DEFINED_glFlushMappedBufferRange
void __stdcall GLee_Lazy_glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) {if (GLeeInit()) glFlushMappedBufferRange(target, offset, length);}
GLEEPFNGLFLUSHMAPPEDBUFFERRANGEPROC GLeeFuncPtr_glFlushMappedBufferRange=GLee_Lazy_glFlushMappedBufferRange;
#endif
#endif
/* GL_ARB_texture_buffer_object */
#ifdef __GLEE_GL_ARB_texture_buffer_object
#ifndef GLEE_C_DEFINED_glTexBufferARB
#define GLEE_C_DEFINED_glTexBufferARB
void __stdcall GLee_Lazy_glTexBufferARB(GLenum target, GLenum internalformat, GLuint buffer) {if (GLeeInit()) glTexBufferARB(target, internalformat, buffer);}
GLEEPFNGLTEXBUFFERARBPROC GLeeFuncPtr_glTexBufferARB=GLee_Lazy_glTexBufferARB;
#endif
#endif
/* GL_ARB_texture_compression_rgtc */
#ifdef __GLEE_GL_ARB_texture_compression_rgtc
#endif
/* GL_ARB_texture_rg */
#ifdef __GLEE_GL_ARB_texture_rg
#endif
/* GL_ARB_vertex_array_object */
#ifdef __GLEE_GL_ARB_vertex_array_object
#ifndef GLEE_C_DEFINED_glBindVertexArray
#define GLEE_C_DEFINED_glBindVertexArray
void __stdcall GLee_Lazy_glBindVertexArray(GLuint array) {if (GLeeInit()) glBindVertexArray(array);}
GLEEPFNGLBINDVERTEXARRAYPROC GLeeFuncPtr_glBindVertexArray=GLee_Lazy_glBindVertexArray;
#endif
#ifndef GLEE_C_DEFINED_glDeleteVertexArrays
#define GLEE_C_DEFINED_glDeleteVertexArrays
void __stdcall GLee_Lazy_glDeleteVertexArrays(GLsizei n, const GLuint * arrays) {if (GLeeInit()) glDeleteVertexArrays(n, arrays);}
GLEEPFNGLDELETEVERTEXARRAYSPROC GLeeFuncPtr_glDeleteVertexArrays=GLee_Lazy_glDeleteVertexArrays;
#endif
#ifndef GLEE_C_DEFINED_glGenVertexArrays
#define GLEE_C_DEFINED_glGenVertexArrays
void __stdcall GLee_Lazy_glGenVertexArrays(GLsizei n, GLuint * arrays) {if (GLeeInit()) glGenVertexArrays(n, arrays);}
GLEEPFNGLGENVERTEXARRAYSPROC GLeeFuncPtr_glGenVertexArrays=GLee_Lazy_glGenVertexArrays;
#endif
#ifndef GLEE_C_DEFINED_glIsVertexArray
#define GLEE_C_DEFINED_glIsVertexArray
GLboolean __stdcall GLee_Lazy_glIsVertexArray(GLuint array) {if (GLeeInit()) return glIsVertexArray(array); return (GLboolean)0;}
GLEEPFNGLISVERTEXARRAYPROC GLeeFuncPtr_glIsVertexArray=GLee_Lazy_glIsVertexArray;
#endif
#endif
/* GL_EXT_abgr */
#ifdef __GLEE_GL_EXT_abgr
#endif
/* GL_EXT_blend_color */
#ifdef __GLEE_GL_EXT_blend_color
#ifndef GLEE_C_DEFINED_glBlendColorEXT
#define GLEE_C_DEFINED_glBlendColorEXT
void __stdcall GLee_Lazy_glBlendColorEXT(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {if (GLeeInit()) glBlendColorEXT(red, green, blue, alpha);}
GLEEPFNGLBLENDCOLOREXTPROC GLeeFuncPtr_glBlendColorEXT=GLee_Lazy_glBlendColorEXT;
#endif
#endif
/* GL_EXT_polygon_offset */
#ifdef __GLEE_GL_EXT_polygon_offset
#ifndef GLEE_C_DEFINED_glPolygonOffsetEXT
#define GLEE_C_DEFINED_glPolygonOffsetEXT
void __stdcall GLee_Lazy_glPolygonOffsetEXT(GLfloat factor, GLfloat bias) {if (GLeeInit()) glPolygonOffsetEXT(factor, bias);}
GLEEPFNGLPOLYGONOFFSETEXTPROC GLeeFuncPtr_glPolygonOffsetEXT=GLee_Lazy_glPolygonOffsetEXT;
#endif
#endif
/* GL_EXT_texture */
#ifdef __GLEE_GL_EXT_texture
#endif
/* GL_EXT_texture3D */
#ifdef __GLEE_GL_EXT_texture3D
#ifndef GLEE_C_DEFINED_glTexImage3DEXT
#define GLEE_C_DEFINED_glTexImage3DEXT
void __stdcall GLee_Lazy_glTexImage3DEXT(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glTexImage3DEXT(target, level, internalformat, width, height, depth, border, format, type, pixels);}
GLEEPFNGLTEXIMAGE3DEXTPROC GLeeFuncPtr_glTexImage3DEXT=GLee_Lazy_glTexImage3DEXT;
#endif
#ifndef GLEE_C_DEFINED_glTexSubImage3DEXT
#define GLEE_C_DEFINED_glTexSubImage3DEXT
void __stdcall GLee_Lazy_glTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glTexSubImage3DEXT(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);}
GLEEPFNGLTEXSUBIMAGE3DEXTPROC GLeeFuncPtr_glTexSubImage3DEXT=GLee_Lazy_glTexSubImage3DEXT;
#endif
#endif
/* GL_SGIS_texture_filter4 */
#ifdef __GLEE_GL_SGIS_texture_filter4
#ifndef GLEE_C_DEFINED_glGetTexFilterFuncSGIS
#define GLEE_C_DEFINED_glGetTexFilterFuncSGIS
void __stdcall GLee_Lazy_glGetTexFilterFuncSGIS(GLenum target, GLenum filter, GLfloat * weights) {if (GLeeInit()) glGetTexFilterFuncSGIS(target, filter, weights);}
GLEEPFNGLGETTEXFILTERFUNCSGISPROC GLeeFuncPtr_glGetTexFilterFuncSGIS=GLee_Lazy_glGetTexFilterFuncSGIS;
#endif
#ifndef GLEE_C_DEFINED_glTexFilterFuncSGIS
#define GLEE_C_DEFINED_glTexFilterFuncSGIS
void __stdcall GLee_Lazy_glTexFilterFuncSGIS(GLenum target, GLenum filter, GLsizei n, const GLfloat * weights) {if (GLeeInit()) glTexFilterFuncSGIS(target, filter, n, weights);}
GLEEPFNGLTEXFILTERFUNCSGISPROC GLeeFuncPtr_glTexFilterFuncSGIS=GLee_Lazy_glTexFilterFuncSGIS;
#endif
#endif
/* GL_EXT_subtexture */
#ifdef __GLEE_GL_EXT_subtexture
#ifndef GLEE_C_DEFINED_glTexSubImage1DEXT
#define GLEE_C_DEFINED_glTexSubImage1DEXT
void __stdcall GLee_Lazy_glTexSubImage1DEXT(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glTexSubImage1DEXT(target, level, xoffset, width, format, type, pixels);}
GLEEPFNGLTEXSUBIMAGE1DEXTPROC GLeeFuncPtr_glTexSubImage1DEXT=GLee_Lazy_glTexSubImage1DEXT;
#endif
#ifndef GLEE_C_DEFINED_glTexSubImage2DEXT
#define GLEE_C_DEFINED_glTexSubImage2DEXT
void __stdcall GLee_Lazy_glTexSubImage2DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glTexSubImage2DEXT(target, level, xoffset, yoffset, width, height, format, type, pixels);}
GLEEPFNGLTEXSUBIMAGE2DEXTPROC GLeeFuncPtr_glTexSubImage2DEXT=GLee_Lazy_glTexSubImage2DEXT;
#endif
#endif
/* GL_EXT_copy_texture */
#ifdef __GLEE_GL_EXT_copy_texture
#ifndef GLEE_C_DEFINED_glCopyTexImage1DEXT
#define GLEE_C_DEFINED_glCopyTexImage1DEXT
void __stdcall GLee_Lazy_glCopyTexImage1DEXT(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) {if (GLeeInit()) glCopyTexImage1DEXT(target, level, internalformat, x, y, width, border);}
GLEEPFNGLCOPYTEXIMAGE1DEXTPROC GLeeFuncPtr_glCopyTexImage1DEXT=GLee_Lazy_glCopyTexImage1DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCopyTexImage2DEXT
#define GLEE_C_DEFINED_glCopyTexImage2DEXT
void __stdcall GLee_Lazy_glCopyTexImage2DEXT(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {if (GLeeInit()) glCopyTexImage2DEXT(target, level, internalformat, x, y, width, height, border);}
GLEEPFNGLCOPYTEXIMAGE2DEXTPROC GLeeFuncPtr_glCopyTexImage2DEXT=GLee_Lazy_glCopyTexImage2DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCopyTexSubImage1DEXT
#define GLEE_C_DEFINED_glCopyTexSubImage1DEXT
void __stdcall GLee_Lazy_glCopyTexSubImage1DEXT(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) {if (GLeeInit()) glCopyTexSubImage1DEXT(target, level, xoffset, x, y, width);}
GLEEPFNGLCOPYTEXSUBIMAGE1DEXTPROC GLeeFuncPtr_glCopyTexSubImage1DEXT=GLee_Lazy_glCopyTexSubImage1DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCopyTexSubImage2DEXT
#define GLEE_C_DEFINED_glCopyTexSubImage2DEXT
void __stdcall GLee_Lazy_glCopyTexSubImage2DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {if (GLeeInit()) glCopyTexSubImage2DEXT(target, level, xoffset, yoffset, x, y, width, height);}
GLEEPFNGLCOPYTEXSUBIMAGE2DEXTPROC GLeeFuncPtr_glCopyTexSubImage2DEXT=GLee_Lazy_glCopyTexSubImage2DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCopyTexSubImage3DEXT
#define GLEE_C_DEFINED_glCopyTexSubImage3DEXT
void __stdcall GLee_Lazy_glCopyTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) {if (GLeeInit()) glCopyTexSubImage3DEXT(target, level, xoffset, yoffset, zoffset, x, y, width, height);}
GLEEPFNGLCOPYTEXSUBIMAGE3DEXTPROC GLeeFuncPtr_glCopyTexSubImage3DEXT=GLee_Lazy_glCopyTexSubImage3DEXT;
#endif
#endif
/* GL_EXT_histogram */
#ifdef __GLEE_GL_EXT_histogram
#ifndef GLEE_C_DEFINED_glGetHistogramEXT
#define GLEE_C_DEFINED_glGetHistogramEXT
void __stdcall GLee_Lazy_glGetHistogramEXT(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values) {if (GLeeInit()) glGetHistogramEXT(target, reset, format, type, values);}
GLEEPFNGLGETHISTOGRAMEXTPROC GLeeFuncPtr_glGetHistogramEXT=GLee_Lazy_glGetHistogramEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetHistogramParameterfvEXT
#define GLEE_C_DEFINED_glGetHistogramParameterfvEXT
void __stdcall GLee_Lazy_glGetHistogramParameterfvEXT(GLenum target, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetHistogramParameterfvEXT(target, pname, params);}
GLEEPFNGLGETHISTOGRAMPARAMETERFVEXTPROC GLeeFuncPtr_glGetHistogramParameterfvEXT=GLee_Lazy_glGetHistogramParameterfvEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetHistogramParameterivEXT
#define GLEE_C_DEFINED_glGetHistogramParameterivEXT
void __stdcall GLee_Lazy_glGetHistogramParameterivEXT(GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetHistogramParameterivEXT(target, pname, params);}
GLEEPFNGLGETHISTOGRAMPARAMETERIVEXTPROC GLeeFuncPtr_glGetHistogramParameterivEXT=GLee_Lazy_glGetHistogramParameterivEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetMinmaxEXT
#define GLEE_C_DEFINED_glGetMinmaxEXT
void __stdcall GLee_Lazy_glGetMinmaxEXT(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values) {if (GLeeInit()) glGetMinmaxEXT(target, reset, format, type, values);}
GLEEPFNGLGETMINMAXEXTPROC GLeeFuncPtr_glGetMinmaxEXT=GLee_Lazy_glGetMinmaxEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetMinmaxParameterfvEXT
#define GLEE_C_DEFINED_glGetMinmaxParameterfvEXT
void __stdcall GLee_Lazy_glGetMinmaxParameterfvEXT(GLenum target, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetMinmaxParameterfvEXT(target, pname, params);}
GLEEPFNGLGETMINMAXPARAMETERFVEXTPROC GLeeFuncPtr_glGetMinmaxParameterfvEXT=GLee_Lazy_glGetMinmaxParameterfvEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetMinmaxParameterivEXT
#define GLEE_C_DEFINED_glGetMinmaxParameterivEXT
void __stdcall GLee_Lazy_glGetMinmaxParameterivEXT(GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetMinmaxParameterivEXT(target, pname, params);}
GLEEPFNGLGETMINMAXPARAMETERIVEXTPROC GLeeFuncPtr_glGetMinmaxParameterivEXT=GLee_Lazy_glGetMinmaxParameterivEXT;
#endif
#ifndef GLEE_C_DEFINED_glHistogramEXT
#define GLEE_C_DEFINED_glHistogramEXT
void __stdcall GLee_Lazy_glHistogramEXT(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink) {if (GLeeInit()) glHistogramEXT(target, width, internalformat, sink);}
GLEEPFNGLHISTOGRAMEXTPROC GLeeFuncPtr_glHistogramEXT=GLee_Lazy_glHistogramEXT;
#endif
#ifndef GLEE_C_DEFINED_glMinmaxEXT
#define GLEE_C_DEFINED_glMinmaxEXT
void __stdcall GLee_Lazy_glMinmaxEXT(GLenum target, GLenum internalformat, GLboolean sink) {if (GLeeInit()) glMinmaxEXT(target, internalformat, sink);}
GLEEPFNGLMINMAXEXTPROC GLeeFuncPtr_glMinmaxEXT=GLee_Lazy_glMinmaxEXT;
#endif
#ifndef GLEE_C_DEFINED_glResetHistogramEXT
#define GLEE_C_DEFINED_glResetHistogramEXT
void __stdcall GLee_Lazy_glResetHistogramEXT(GLenum target) {if (GLeeInit()) glResetHistogramEXT(target);}
GLEEPFNGLRESETHISTOGRAMEXTPROC GLeeFuncPtr_glResetHistogramEXT=GLee_Lazy_glResetHistogramEXT;
#endif
#ifndef GLEE_C_DEFINED_glResetMinmaxEXT
#define GLEE_C_DEFINED_glResetMinmaxEXT
void __stdcall GLee_Lazy_glResetMinmaxEXT(GLenum target) {if (GLeeInit()) glResetMinmaxEXT(target);}
GLEEPFNGLRESETMINMAXEXTPROC GLeeFuncPtr_glResetMinmaxEXT=GLee_Lazy_glResetMinmaxEXT;
#endif
#endif
/* GL_EXT_convolution */
#ifdef __GLEE_GL_EXT_convolution
#ifndef GLEE_C_DEFINED_glConvolutionFilter1DEXT
#define GLEE_C_DEFINED_glConvolutionFilter1DEXT
void __stdcall GLee_Lazy_glConvolutionFilter1DEXT(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image) {if (GLeeInit()) glConvolutionFilter1DEXT(target, internalformat, width, format, type, image);}
GLEEPFNGLCONVOLUTIONFILTER1DEXTPROC GLeeFuncPtr_glConvolutionFilter1DEXT=GLee_Lazy_glConvolutionFilter1DEXT;
#endif
#ifndef GLEE_C_DEFINED_glConvolutionFilter2DEXT
#define GLEE_C_DEFINED_glConvolutionFilter2DEXT
void __stdcall GLee_Lazy_glConvolutionFilter2DEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image) {if (GLeeInit()) glConvolutionFilter2DEXT(target, internalformat, width, height, format, type, image);}
GLEEPFNGLCONVOLUTIONFILTER2DEXTPROC GLeeFuncPtr_glConvolutionFilter2DEXT=GLee_Lazy_glConvolutionFilter2DEXT;
#endif
#ifndef GLEE_C_DEFINED_glConvolutionParameterfEXT
#define GLEE_C_DEFINED_glConvolutionParameterfEXT
void __stdcall GLee_Lazy_glConvolutionParameterfEXT(GLenum target, GLenum pname, GLfloat params) {if (GLeeInit()) glConvolutionParameterfEXT(target, pname, params);}
GLEEPFNGLCONVOLUTIONPARAMETERFEXTPROC GLeeFuncPtr_glConvolutionParameterfEXT=GLee_Lazy_glConvolutionParameterfEXT;
#endif
#ifndef GLEE_C_DEFINED_glConvolutionParameterfvEXT
#define GLEE_C_DEFINED_glConvolutionParameterfvEXT
void __stdcall GLee_Lazy_glConvolutionParameterfvEXT(GLenum target, GLenum pname, const GLfloat * params) {if (GLeeInit()) glConvolutionParameterfvEXT(target, pname, params);}
GLEEPFNGLCONVOLUTIONPARAMETERFVEXTPROC GLeeFuncPtr_glConvolutionParameterfvEXT=GLee_Lazy_glConvolutionParameterfvEXT;
#endif
#ifndef GLEE_C_DEFINED_glConvolutionParameteriEXT
#define GLEE_C_DEFINED_glConvolutionParameteriEXT
void __stdcall GLee_Lazy_glConvolutionParameteriEXT(GLenum target, GLenum pname, GLint params) {if (GLeeInit()) glConvolutionParameteriEXT(target, pname, params);}
GLEEPFNGLCONVOLUTIONPARAMETERIEXTPROC GLeeFuncPtr_glConvolutionParameteriEXT=GLee_Lazy_glConvolutionParameteriEXT;
#endif
#ifndef GLEE_C_DEFINED_glConvolutionParameterivEXT
#define GLEE_C_DEFINED_glConvolutionParameterivEXT
void __stdcall GLee_Lazy_glConvolutionParameterivEXT(GLenum target, GLenum pname, const GLint * params) {if (GLeeInit()) glConvolutionParameterivEXT(target, pname, params);}
GLEEPFNGLCONVOLUTIONPARAMETERIVEXTPROC GLeeFuncPtr_glConvolutionParameterivEXT=GLee_Lazy_glConvolutionParameterivEXT;
#endif
#ifndef GLEE_C_DEFINED_glCopyConvolutionFilter1DEXT
#define GLEE_C_DEFINED_glCopyConvolutionFilter1DEXT
void __stdcall GLee_Lazy_glCopyConvolutionFilter1DEXT(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) {if (GLeeInit()) glCopyConvolutionFilter1DEXT(target, internalformat, x, y, width);}
GLEEPFNGLCOPYCONVOLUTIONFILTER1DEXTPROC GLeeFuncPtr_glCopyConvolutionFilter1DEXT=GLee_Lazy_glCopyConvolutionFilter1DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCopyConvolutionFilter2DEXT
#define GLEE_C_DEFINED_glCopyConvolutionFilter2DEXT
void __stdcall GLee_Lazy_glCopyConvolutionFilter2DEXT(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height) {if (GLeeInit()) glCopyConvolutionFilter2DEXT(target, internalformat, x, y, width, height);}
GLEEPFNGLCOPYCONVOLUTIONFILTER2DEXTPROC GLeeFuncPtr_glCopyConvolutionFilter2DEXT=GLee_Lazy_glCopyConvolutionFilter2DEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetConvolutionFilterEXT
#define GLEE_C_DEFINED_glGetConvolutionFilterEXT
void __stdcall GLee_Lazy_glGetConvolutionFilterEXT(GLenum target, GLenum format, GLenum type, GLvoid * image) {if (GLeeInit()) glGetConvolutionFilterEXT(target, format, type, image);}
GLEEPFNGLGETCONVOLUTIONFILTEREXTPROC GLeeFuncPtr_glGetConvolutionFilterEXT=GLee_Lazy_glGetConvolutionFilterEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetConvolutionParameterfvEXT
#define GLEE_C_DEFINED_glGetConvolutionParameterfvEXT
void __stdcall GLee_Lazy_glGetConvolutionParameterfvEXT(GLenum target, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetConvolutionParameterfvEXT(target, pname, params);}
GLEEPFNGLGETCONVOLUTIONPARAMETERFVEXTPROC GLeeFuncPtr_glGetConvolutionParameterfvEXT=GLee_Lazy_glGetConvolutionParameterfvEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetConvolutionParameterivEXT
#define GLEE_C_DEFINED_glGetConvolutionParameterivEXT
void __stdcall GLee_Lazy_glGetConvolutionParameterivEXT(GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetConvolutionParameterivEXT(target, pname, params);}
GLEEPFNGLGETCONVOLUTIONPARAMETERIVEXTPROC GLeeFuncPtr_glGetConvolutionParameterivEXT=GLee_Lazy_glGetConvolutionParameterivEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetSeparableFilterEXT
#define GLEE_C_DEFINED_glGetSeparableFilterEXT
void __stdcall GLee_Lazy_glGetSeparableFilterEXT(GLenum target, GLenum format, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span) {if (GLeeInit()) glGetSeparableFilterEXT(target, format, type, row, column, span);}
GLEEPFNGLGETSEPARABLEFILTEREXTPROC GLeeFuncPtr_glGetSeparableFilterEXT=GLee_Lazy_glGetSeparableFilterEXT;
#endif
#ifndef GLEE_C_DEFINED_glSeparableFilter2DEXT
#define GLEE_C_DEFINED_glSeparableFilter2DEXT
void __stdcall GLee_Lazy_glSeparableFilter2DEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * row, const GLvoid * column) {if (GLeeInit()) glSeparableFilter2DEXT(target, internalformat, width, height, format, type, row, column);}
GLEEPFNGLSEPARABLEFILTER2DEXTPROC GLeeFuncPtr_glSeparableFilter2DEXT=GLee_Lazy_glSeparableFilter2DEXT;
#endif
#endif
/* GL_SGI_color_matrix */
#ifdef __GLEE_GL_SGI_color_matrix
#endif
/* GL_SGI_color_table */
#ifdef __GLEE_GL_SGI_color_table
#ifndef GLEE_C_DEFINED_glColorTableSGI
#define GLEE_C_DEFINED_glColorTableSGI
void __stdcall GLee_Lazy_glColorTableSGI(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table) {if (GLeeInit()) glColorTableSGI(target, internalformat, width, format, type, table);}
GLEEPFNGLCOLORTABLESGIPROC GLeeFuncPtr_glColorTableSGI=GLee_Lazy_glColorTableSGI;
#endif
#ifndef GLEE_C_DEFINED_glColorTableParameterfvSGI
#define GLEE_C_DEFINED_glColorTableParameterfvSGI
void __stdcall GLee_Lazy_glColorTableParameterfvSGI(GLenum target, GLenum pname, const GLfloat * params) {if (GLeeInit()) glColorTableParameterfvSGI(target, pname, params);}
GLEEPFNGLCOLORTABLEPARAMETERFVSGIPROC GLeeFuncPtr_glColorTableParameterfvSGI=GLee_Lazy_glColorTableParameterfvSGI;
#endif
#ifndef GLEE_C_DEFINED_glColorTableParameterivSGI
#define GLEE_C_DEFINED_glColorTableParameterivSGI
void __stdcall GLee_Lazy_glColorTableParameterivSGI(GLenum target, GLenum pname, const GLint * params) {if (GLeeInit()) glColorTableParameterivSGI(target, pname, params);}
GLEEPFNGLCOLORTABLEPARAMETERIVSGIPROC GLeeFuncPtr_glColorTableParameterivSGI=GLee_Lazy_glColorTableParameterivSGI;
#endif
#ifndef GLEE_C_DEFINED_glCopyColorTableSGI
#define GLEE_C_DEFINED_glCopyColorTableSGI
void __stdcall GLee_Lazy_glCopyColorTableSGI(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width) {if (GLeeInit()) glCopyColorTableSGI(target, internalformat, x, y, width);}
GLEEPFNGLCOPYCOLORTABLESGIPROC GLeeFuncPtr_glCopyColorTableSGI=GLee_Lazy_glCopyColorTableSGI;
#endif
#ifndef GLEE_C_DEFINED_glGetColorTableSGI
#define GLEE_C_DEFINED_glGetColorTableSGI
void __stdcall GLee_Lazy_glGetColorTableSGI(GLenum target, GLenum format, GLenum type, GLvoid * table) {if (GLeeInit()) glGetColorTableSGI(target, format, type, table);}
GLEEPFNGLGETCOLORTABLESGIPROC GLeeFuncPtr_glGetColorTableSGI=GLee_Lazy_glGetColorTableSGI;
#endif
#ifndef GLEE_C_DEFINED_glGetColorTableParameterfvSGI
#define GLEE_C_DEFINED_glGetColorTableParameterfvSGI
void __stdcall GLee_Lazy_glGetColorTableParameterfvSGI(GLenum target, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetColorTableParameterfvSGI(target, pname, params);}
GLEEPFNGLGETCOLORTABLEPARAMETERFVSGIPROC GLeeFuncPtr_glGetColorTableParameterfvSGI=GLee_Lazy_glGetColorTableParameterfvSGI;
#endif
#ifndef GLEE_C_DEFINED_glGetColorTableParameterivSGI
#define GLEE_C_DEFINED_glGetColorTableParameterivSGI
void __stdcall GLee_Lazy_glGetColorTableParameterivSGI(GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetColorTableParameterivSGI(target, pname, params);}
GLEEPFNGLGETCOLORTABLEPARAMETERIVSGIPROC GLeeFuncPtr_glGetColorTableParameterivSGI=GLee_Lazy_glGetColorTableParameterivSGI;
#endif
#endif
/* GL_SGIS_pixel_texture */
#ifdef __GLEE_GL_SGIS_pixel_texture
#ifndef GLEE_C_DEFINED_glPixelTexGenParameteriSGIS
#define GLEE_C_DEFINED_glPixelTexGenParameteriSGIS
void __stdcall GLee_Lazy_glPixelTexGenParameteriSGIS(GLenum pname, GLint param) {if (GLeeInit()) glPixelTexGenParameteriSGIS(pname, param);}
GLEEPFNGLPIXELTEXGENPARAMETERISGISPROC GLeeFuncPtr_glPixelTexGenParameteriSGIS=GLee_Lazy_glPixelTexGenParameteriSGIS;
#endif
#ifndef GLEE_C_DEFINED_glPixelTexGenParameterivSGIS
#define GLEE_C_DEFINED_glPixelTexGenParameterivSGIS
void __stdcall GLee_Lazy_glPixelTexGenParameterivSGIS(GLenum pname, const GLint * params) {if (GLeeInit()) glPixelTexGenParameterivSGIS(pname, params);}
GLEEPFNGLPIXELTEXGENPARAMETERIVSGISPROC GLeeFuncPtr_glPixelTexGenParameterivSGIS=GLee_Lazy_glPixelTexGenParameterivSGIS;
#endif
#ifndef GLEE_C_DEFINED_glPixelTexGenParameterfSGIS
#define GLEE_C_DEFINED_glPixelTexGenParameterfSGIS
void __stdcall GLee_Lazy_glPixelTexGenParameterfSGIS(GLenum pname, GLfloat param) {if (GLeeInit()) glPixelTexGenParameterfSGIS(pname, param);}
GLEEPFNGLPIXELTEXGENPARAMETERFSGISPROC GLeeFuncPtr_glPixelTexGenParameterfSGIS=GLee_Lazy_glPixelTexGenParameterfSGIS;
#endif
#ifndef GLEE_C_DEFINED_glPixelTexGenParameterfvSGIS
#define GLEE_C_DEFINED_glPixelTexGenParameterfvSGIS
void __stdcall GLee_Lazy_glPixelTexGenParameterfvSGIS(GLenum pname, const GLfloat * params) {if (GLeeInit()) glPixelTexGenParameterfvSGIS(pname, params);}
GLEEPFNGLPIXELTEXGENPARAMETERFVSGISPROC GLeeFuncPtr_glPixelTexGenParameterfvSGIS=GLee_Lazy_glPixelTexGenParameterfvSGIS;
#endif
#ifndef GLEE_C_DEFINED_glGetPixelTexGenParameterivSGIS
#define GLEE_C_DEFINED_glGetPixelTexGenParameterivSGIS
void __stdcall GLee_Lazy_glGetPixelTexGenParameterivSGIS(GLenum pname, GLint * params) {if (GLeeInit()) glGetPixelTexGenParameterivSGIS(pname, params);}
GLEEPFNGLGETPIXELTEXGENPARAMETERIVSGISPROC GLeeFuncPtr_glGetPixelTexGenParameterivSGIS=GLee_Lazy_glGetPixelTexGenParameterivSGIS;
#endif
#ifndef GLEE_C_DEFINED_glGetPixelTexGenParameterfvSGIS
#define GLEE_C_DEFINED_glGetPixelTexGenParameterfvSGIS
void __stdcall GLee_Lazy_glGetPixelTexGenParameterfvSGIS(GLenum pname, GLfloat * params) {if (GLeeInit()) glGetPixelTexGenParameterfvSGIS(pname, params);}
GLEEPFNGLGETPIXELTEXGENPARAMETERFVSGISPROC GLeeFuncPtr_glGetPixelTexGenParameterfvSGIS=GLee_Lazy_glGetPixelTexGenParameterfvSGIS;
#endif
#endif
/* GL_SGIX_pixel_texture */
#ifdef __GLEE_GL_SGIX_pixel_texture
#ifndef GLEE_C_DEFINED_glPixelTexGenSGIX
#define GLEE_C_DEFINED_glPixelTexGenSGIX
void __stdcall GLee_Lazy_glPixelTexGenSGIX(GLenum mode) {if (GLeeInit()) glPixelTexGenSGIX(mode);}
GLEEPFNGLPIXELTEXGENSGIXPROC GLeeFuncPtr_glPixelTexGenSGIX=GLee_Lazy_glPixelTexGenSGIX;
#endif
#endif
/* GL_SGIS_texture4D */
#ifdef __GLEE_GL_SGIS_texture4D
#ifndef GLEE_C_DEFINED_glTexImage4DSGIS
#define GLEE_C_DEFINED_glTexImage4DSGIS
void __stdcall GLee_Lazy_glTexImage4DSGIS(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glTexImage4DSGIS(target, level, internalformat, width, height, depth, size4d, border, format, type, pixels);}
GLEEPFNGLTEXIMAGE4DSGISPROC GLeeFuncPtr_glTexImage4DSGIS=GLee_Lazy_glTexImage4DSGIS;
#endif
#ifndef GLEE_C_DEFINED_glTexSubImage4DSGIS
#define GLEE_C_DEFINED_glTexSubImage4DSGIS
void __stdcall GLee_Lazy_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 GLvoid * pixels) {if (GLeeInit()) glTexSubImage4DSGIS(target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, pixels);}
GLEEPFNGLTEXSUBIMAGE4DSGISPROC GLeeFuncPtr_glTexSubImage4DSGIS=GLee_Lazy_glTexSubImage4DSGIS;
#endif
#endif
/* GL_SGI_texture_color_table */
#ifdef __GLEE_GL_SGI_texture_color_table
#endif
/* GL_EXT_cmyka */
#ifdef __GLEE_GL_EXT_cmyka
#endif
/* GL_EXT_texture_object */
#ifdef __GLEE_GL_EXT_texture_object
#ifndef GLEE_C_DEFINED_glAreTexturesResidentEXT
#define GLEE_C_DEFINED_glAreTexturesResidentEXT
GLboolean __stdcall GLee_Lazy_glAreTexturesResidentEXT(GLsizei n, const GLuint * textures, GLboolean * residences) {if (GLeeInit()) return glAreTexturesResidentEXT(n, textures, residences); return (GLboolean)0;}
GLEEPFNGLARETEXTURESRESIDENTEXTPROC GLeeFuncPtr_glAreTexturesResidentEXT=GLee_Lazy_glAreTexturesResidentEXT;
#endif
#ifndef GLEE_C_DEFINED_glBindTextureEXT
#define GLEE_C_DEFINED_glBindTextureEXT
void __stdcall GLee_Lazy_glBindTextureEXT(GLenum target, GLuint texture) {if (GLeeInit()) glBindTextureEXT(target, texture);}
GLEEPFNGLBINDTEXTUREEXTPROC GLeeFuncPtr_glBindTextureEXT=GLee_Lazy_glBindTextureEXT;
#endif
#ifndef GLEE_C_DEFINED_glDeleteTexturesEXT
#define GLEE_C_DEFINED_glDeleteTexturesEXT
void __stdcall GLee_Lazy_glDeleteTexturesEXT(GLsizei n, const GLuint * textures) {if (GLeeInit()) glDeleteTexturesEXT(n, textures);}
GLEEPFNGLDELETETEXTURESEXTPROC GLeeFuncPtr_glDeleteTexturesEXT=GLee_Lazy_glDeleteTexturesEXT;
#endif
#ifndef GLEE_C_DEFINED_glGenTexturesEXT
#define GLEE_C_DEFINED_glGenTexturesEXT
void __stdcall GLee_Lazy_glGenTexturesEXT(GLsizei n, GLuint * textures) {if (GLeeInit()) glGenTexturesEXT(n, textures);}
GLEEPFNGLGENTEXTURESEXTPROC GLeeFuncPtr_glGenTexturesEXT=GLee_Lazy_glGenTexturesEXT;
#endif
#ifndef GLEE_C_DEFINED_glIsTextureEXT
#define GLEE_C_DEFINED_glIsTextureEXT
GLboolean __stdcall GLee_Lazy_glIsTextureEXT(GLuint texture) {if (GLeeInit()) return glIsTextureEXT(texture); return (GLboolean)0;}
GLEEPFNGLISTEXTUREEXTPROC GLeeFuncPtr_glIsTextureEXT=GLee_Lazy_glIsTextureEXT;
#endif
#ifndef GLEE_C_DEFINED_glPrioritizeTexturesEXT
#define GLEE_C_DEFINED_glPrioritizeTexturesEXT
void __stdcall GLee_Lazy_glPrioritizeTexturesEXT(GLsizei n, const GLuint * textures, const GLclampf * priorities) {if (GLeeInit()) glPrioritizeTexturesEXT(n, textures, priorities);}
GLEEPFNGLPRIORITIZETEXTURESEXTPROC GLeeFuncPtr_glPrioritizeTexturesEXT=GLee_Lazy_glPrioritizeTexturesEXT;
#endif
#endif
/* GL_SGIS_detail_texture */
#ifdef __GLEE_GL_SGIS_detail_texture
#ifndef GLEE_C_DEFINED_glDetailTexFuncSGIS
#define GLEE_C_DEFINED_glDetailTexFuncSGIS
void __stdcall GLee_Lazy_glDetailTexFuncSGIS(GLenum target, GLsizei n, const GLfloat * points) {if (GLeeInit()) glDetailTexFuncSGIS(target, n, points);}
GLEEPFNGLDETAILTEXFUNCSGISPROC GLeeFuncPtr_glDetailTexFuncSGIS=GLee_Lazy_glDetailTexFuncSGIS;
#endif
#ifndef GLEE_C_DEFINED_glGetDetailTexFuncSGIS
#define GLEE_C_DEFINED_glGetDetailTexFuncSGIS
void __stdcall GLee_Lazy_glGetDetailTexFuncSGIS(GLenum target, GLfloat * points) {if (GLeeInit()) glGetDetailTexFuncSGIS(target, points);}
GLEEPFNGLGETDETAILTEXFUNCSGISPROC GLeeFuncPtr_glGetDetailTexFuncSGIS=GLee_Lazy_glGetDetailTexFuncSGIS;
#endif
#endif
/* GL_SGIS_sharpen_texture */
#ifdef __GLEE_GL_SGIS_sharpen_texture
#ifndef GLEE_C_DEFINED_glSharpenTexFuncSGIS
#define GLEE_C_DEFINED_glSharpenTexFuncSGIS
void __stdcall GLee_Lazy_glSharpenTexFuncSGIS(GLenum target, GLsizei n, const GLfloat * points) {if (GLeeInit()) glSharpenTexFuncSGIS(target, n, points);}
GLEEPFNGLSHARPENTEXFUNCSGISPROC GLeeFuncPtr_glSharpenTexFuncSGIS=GLee_Lazy_glSharpenTexFuncSGIS;
#endif
#ifndef GLEE_C_DEFINED_glGetSharpenTexFuncSGIS
#define GLEE_C_DEFINED_glGetSharpenTexFuncSGIS
void __stdcall GLee_Lazy_glGetSharpenTexFuncSGIS(GLenum target, GLfloat * points) {if (GLeeInit()) glGetSharpenTexFuncSGIS(target, points);}
GLEEPFNGLGETSHARPENTEXFUNCSGISPROC GLeeFuncPtr_glGetSharpenTexFuncSGIS=GLee_Lazy_glGetSharpenTexFuncSGIS;
#endif
#endif
/* GL_EXT_packed_pixels */
#ifdef __GLEE_GL_EXT_packed_pixels
#endif
/* GL_SGIS_texture_lod */
#ifdef __GLEE_GL_SGIS_texture_lod
#endif
/* GL_SGIS_multisample */
#ifdef __GLEE_GL_SGIS_multisample
#ifndef GLEE_C_DEFINED_glSampleMaskSGIS
#define GLEE_C_DEFINED_glSampleMaskSGIS
void __stdcall GLee_Lazy_glSampleMaskSGIS(GLclampf value, GLboolean invert) {if (GLeeInit()) glSampleMaskSGIS(value, invert);}
GLEEPFNGLSAMPLEMASKSGISPROC GLeeFuncPtr_glSampleMaskSGIS=GLee_Lazy_glSampleMaskSGIS;
#endif
#ifndef GLEE_C_DEFINED_glSamplePatternSGIS
#define GLEE_C_DEFINED_glSamplePatternSGIS
void __stdcall GLee_Lazy_glSamplePatternSGIS(GLenum pattern) {if (GLeeInit()) glSamplePatternSGIS(pattern);}
GLEEPFNGLSAMPLEPATTERNSGISPROC GLeeFuncPtr_glSamplePatternSGIS=GLee_Lazy_glSamplePatternSGIS;
#endif
#endif
/* GL_EXT_rescale_normal */
#ifdef __GLEE_GL_EXT_rescale_normal
#endif
/* GL_EXT_vertex_array */
#ifdef __GLEE_GL_EXT_vertex_array
#ifndef GLEE_C_DEFINED_glArrayElementEXT
#define GLEE_C_DEFINED_glArrayElementEXT
void __stdcall GLee_Lazy_glArrayElementEXT(GLint i) {if (GLeeInit()) glArrayElementEXT(i);}
GLEEPFNGLARRAYELEMENTEXTPROC GLeeFuncPtr_glArrayElementEXT=GLee_Lazy_glArrayElementEXT;
#endif
#ifndef GLEE_C_DEFINED_glColorPointerEXT
#define GLEE_C_DEFINED_glColorPointerEXT
void __stdcall GLee_Lazy_glColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer) {if (GLeeInit()) glColorPointerEXT(size, type, stride, count, pointer);}
GLEEPFNGLCOLORPOINTEREXTPROC GLeeFuncPtr_glColorPointerEXT=GLee_Lazy_glColorPointerEXT;
#endif
#ifndef GLEE_C_DEFINED_glDrawArraysEXT
#define GLEE_C_DEFINED_glDrawArraysEXT
void __stdcall GLee_Lazy_glDrawArraysEXT(GLenum mode, GLint first, GLsizei count) {if (GLeeInit()) glDrawArraysEXT(mode, first, count);}
GLEEPFNGLDRAWARRAYSEXTPROC GLeeFuncPtr_glDrawArraysEXT=GLee_Lazy_glDrawArraysEXT;
#endif
#ifndef GLEE_C_DEFINED_glEdgeFlagPointerEXT
#define GLEE_C_DEFINED_glEdgeFlagPointerEXT
void __stdcall GLee_Lazy_glEdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean * pointer) {if (GLeeInit()) glEdgeFlagPointerEXT(stride, count, pointer);}
GLEEPFNGLEDGEFLAGPOINTEREXTPROC GLeeFuncPtr_glEdgeFlagPointerEXT=GLee_Lazy_glEdgeFlagPointerEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetPointervEXT
#define GLEE_C_DEFINED_glGetPointervEXT
void __stdcall GLee_Lazy_glGetPointervEXT(GLenum pname, GLvoid* * params) {if (GLeeInit()) glGetPointervEXT(pname, params);}
GLEEPFNGLGETPOINTERVEXTPROC GLeeFuncPtr_glGetPointervEXT=GLee_Lazy_glGetPointervEXT;
#endif
#ifndef GLEE_C_DEFINED_glIndexPointerEXT
#define GLEE_C_DEFINED_glIndexPointerEXT
void __stdcall GLee_Lazy_glIndexPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer) {if (GLeeInit()) glIndexPointerEXT(type, stride, count, pointer);}
GLEEPFNGLINDEXPOINTEREXTPROC GLeeFuncPtr_glIndexPointerEXT=GLee_Lazy_glIndexPointerEXT;
#endif
#ifndef GLEE_C_DEFINED_glNormalPointerEXT
#define GLEE_C_DEFINED_glNormalPointerEXT
void __stdcall GLee_Lazy_glNormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer) {if (GLeeInit()) glNormalPointerEXT(type, stride, count, pointer);}
GLEEPFNGLNORMALPOINTEREXTPROC GLeeFuncPtr_glNormalPointerEXT=GLee_Lazy_glNormalPointerEXT;
#endif
#ifndef GLEE_C_DEFINED_glTexCoordPointerEXT
#define GLEE_C_DEFINED_glTexCoordPointerEXT
void __stdcall GLee_Lazy_glTexCoordPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer) {if (GLeeInit()) glTexCoordPointerEXT(size, type, stride, count, pointer);}
GLEEPFNGLTEXCOORDPOINTEREXTPROC GLeeFuncPtr_glTexCoordPointerEXT=GLee_Lazy_glTexCoordPointerEXT;
#endif
#ifndef GLEE_C_DEFINED_glVertexPointerEXT
#define GLEE_C_DEFINED_glVertexPointerEXT
void __stdcall GLee_Lazy_glVertexPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer) {if (GLeeInit()) glVertexPointerEXT(size, type, stride, count, pointer);}
GLEEPFNGLVERTEXPOINTEREXTPROC GLeeFuncPtr_glVertexPointerEXT=GLee_Lazy_glVertexPointerEXT;
#endif
#endif
/* GL_EXT_misc_attribute */
#ifdef __GLEE_GL_EXT_misc_attribute
#endif
/* GL_SGIS_generate_mipmap */
#ifdef __GLEE_GL_SGIS_generate_mipmap
#endif
/* GL_SGIX_clipmap */
#ifdef __GLEE_GL_SGIX_clipmap
#endif
/* GL_SGIX_shadow */
#ifdef __GLEE_GL_SGIX_shadow
#endif
/* GL_SGIS_texture_edge_clamp */
#ifdef __GLEE_GL_SGIS_texture_edge_clamp
#endif
/* GL_SGIS_texture_border_clamp */
#ifdef __GLEE_GL_SGIS_texture_border_clamp
#endif
/* GL_EXT_blend_minmax */
#ifdef __GLEE_GL_EXT_blend_minmax
#ifndef GLEE_C_DEFINED_glBlendEquationEXT
#define GLEE_C_DEFINED_glBlendEquationEXT
void __stdcall GLee_Lazy_glBlendEquationEXT(GLenum mode) {if (GLeeInit()) glBlendEquationEXT(mode);}
GLEEPFNGLBLENDEQUATIONEXTPROC GLeeFuncPtr_glBlendEquationEXT=GLee_Lazy_glBlendEquationEXT;
#endif
#endif
/* GL_EXT_blend_subtract */
#ifdef __GLEE_GL_EXT_blend_subtract
#endif
/* GL_EXT_blend_logic_op */
#ifdef __GLEE_GL_EXT_blend_logic_op
#endif
/* GL_SGIX_interlace */
#ifdef __GLEE_GL_SGIX_interlace
#endif
/* GL_SGIX_pixel_tiles */
#ifdef __GLEE_GL_SGIX_pixel_tiles
#endif
/* GL_SGIS_texture_select */
#ifdef __GLEE_GL_SGIS_texture_select
#endif
/* GL_SGIX_sprite */
#ifdef __GLEE_GL_SGIX_sprite
#ifndef GLEE_C_DEFINED_glSpriteParameterfSGIX
#define GLEE_C_DEFINED_glSpriteParameterfSGIX
void __stdcall GLee_Lazy_glSpriteParameterfSGIX(GLenum pname, GLfloat param) {if (GLeeInit()) glSpriteParameterfSGIX(pname, param);}
GLEEPFNGLSPRITEPARAMETERFSGIXPROC GLeeFuncPtr_glSpriteParameterfSGIX=GLee_Lazy_glSpriteParameterfSGIX;
#endif
#ifndef GLEE_C_DEFINED_glSpriteParameterfvSGIX
#define GLEE_C_DEFINED_glSpriteParameterfvSGIX
void __stdcall GLee_Lazy_glSpriteParameterfvSGIX(GLenum pname, const GLfloat * params) {if (GLeeInit()) glSpriteParameterfvSGIX(pname, params);}
GLEEPFNGLSPRITEPARAMETERFVSGIXPROC GLeeFuncPtr_glSpriteParameterfvSGIX=GLee_Lazy_glSpriteParameterfvSGIX;
#endif
#ifndef GLEE_C_DEFINED_glSpriteParameteriSGIX
#define GLEE_C_DEFINED_glSpriteParameteriSGIX
void __stdcall GLee_Lazy_glSpriteParameteriSGIX(GLenum pname, GLint param) {if (GLeeInit()) glSpriteParameteriSGIX(pname, param);}
GLEEPFNGLSPRITEPARAMETERISGIXPROC GLeeFuncPtr_glSpriteParameteriSGIX=GLee_Lazy_glSpriteParameteriSGIX;
#endif
#ifndef GLEE_C_DEFINED_glSpriteParameterivSGIX
#define GLEE_C_DEFINED_glSpriteParameterivSGIX
void __stdcall GLee_Lazy_glSpriteParameterivSGIX(GLenum pname, const GLint * params) {if (GLeeInit()) glSpriteParameterivSGIX(pname, params);}
GLEEPFNGLSPRITEPARAMETERIVSGIXPROC GLeeFuncPtr_glSpriteParameterivSGIX=GLee_Lazy_glSpriteParameterivSGIX;
#endif
#endif
/* GL_SGIX_texture_multi_buffer */
#ifdef __GLEE_GL_SGIX_texture_multi_buffer
#endif
/* GL_EXT_point_parameters */
#ifdef __GLEE_GL_EXT_point_parameters
#ifndef GLEE_C_DEFINED_glPointParameterfEXT
#define GLEE_C_DEFINED_glPointParameterfEXT
void __stdcall GLee_Lazy_glPointParameterfEXT(GLenum pname, GLfloat param) {if (GLeeInit()) glPointParameterfEXT(pname, param);}
GLEEPFNGLPOINTPARAMETERFEXTPROC GLeeFuncPtr_glPointParameterfEXT=GLee_Lazy_glPointParameterfEXT;
#endif
#ifndef GLEE_C_DEFINED_glPointParameterfvEXT
#define GLEE_C_DEFINED_glPointParameterfvEXT
void __stdcall GLee_Lazy_glPointParameterfvEXT(GLenum pname, const GLfloat * params) {if (GLeeInit()) glPointParameterfvEXT(pname, params);}
GLEEPFNGLPOINTPARAMETERFVEXTPROC GLeeFuncPtr_glPointParameterfvEXT=GLee_Lazy_glPointParameterfvEXT;
#endif
#endif
/* GL_SGIS_point_parameters */
#ifdef __GLEE_GL_SGIS_point_parameters
#ifndef GLEE_C_DEFINED_glPointParameterfSGIS
#define GLEE_C_DEFINED_glPointParameterfSGIS
void __stdcall GLee_Lazy_glPointParameterfSGIS(GLenum pname, GLfloat param) {if (GLeeInit()) glPointParameterfSGIS(pname, param);}
GLEEPFNGLPOINTPARAMETERFSGISPROC GLeeFuncPtr_glPointParameterfSGIS=GLee_Lazy_glPointParameterfSGIS;
#endif
#ifndef GLEE_C_DEFINED_glPointParameterfvSGIS
#define GLEE_C_DEFINED_glPointParameterfvSGIS
void __stdcall GLee_Lazy_glPointParameterfvSGIS(GLenum pname, const GLfloat * params) {if (GLeeInit()) glPointParameterfvSGIS(pname, params);}
GLEEPFNGLPOINTPARAMETERFVSGISPROC GLeeFuncPtr_glPointParameterfvSGIS=GLee_Lazy_glPointParameterfvSGIS;
#endif
#endif
/* GL_SGIX_instruments */
#ifdef __GLEE_GL_SGIX_instruments
#ifndef GLEE_C_DEFINED_glGetInstrumentsSGIX
#define GLEE_C_DEFINED_glGetInstrumentsSGIX
GLint __stdcall GLee_Lazy_glGetInstrumentsSGIX(void) {if (GLeeInit()) return glGetInstrumentsSGIX(); return (GLint)0;}
GLEEPFNGLGETINSTRUMENTSSGIXPROC GLeeFuncPtr_glGetInstrumentsSGIX=GLee_Lazy_glGetInstrumentsSGIX;
#endif
#ifndef GLEE_C_DEFINED_glInstrumentsBufferSGIX
#define GLEE_C_DEFINED_glInstrumentsBufferSGIX
void __stdcall GLee_Lazy_glInstrumentsBufferSGIX(GLsizei size, GLint * buffer) {if (GLeeInit()) glInstrumentsBufferSGIX(size, buffer);}
GLEEPFNGLINSTRUMENTSBUFFERSGIXPROC GLeeFuncPtr_glInstrumentsBufferSGIX=GLee_Lazy_glInstrumentsBufferSGIX;
#endif
#ifndef GLEE_C_DEFINED_glPollInstrumentsSGIX
#define GLEE_C_DEFINED_glPollInstrumentsSGIX
GLint __stdcall GLee_Lazy_glPollInstrumentsSGIX(GLint * marker_p) {if (GLeeInit()) return glPollInstrumentsSGIX(marker_p); return (GLint)0;}
GLEEPFNGLPOLLINSTRUMENTSSGIXPROC GLeeFuncPtr_glPollInstrumentsSGIX=GLee_Lazy_glPollInstrumentsSGIX;
#endif
#ifndef GLEE_C_DEFINED_glReadInstrumentsSGIX
#define GLEE_C_DEFINED_glReadInstrumentsSGIX
void __stdcall GLee_Lazy_glReadInstrumentsSGIX(GLint marker) {if (GLeeInit()) glReadInstrumentsSGIX(marker);}
GLEEPFNGLREADINSTRUMENTSSGIXPROC GLeeFuncPtr_glReadInstrumentsSGIX=GLee_Lazy_glReadInstrumentsSGIX;
#endif
#ifndef GLEE_C_DEFINED_glStartInstrumentsSGIX
#define GLEE_C_DEFINED_glStartInstrumentsSGIX
void __stdcall GLee_Lazy_glStartInstrumentsSGIX(void) {if (GLeeInit()) glStartInstrumentsSGIX();}
GLEEPFNGLSTARTINSTRUMENTSSGIXPROC GLeeFuncPtr_glStartInstrumentsSGIX=GLee_Lazy_glStartInstrumentsSGIX;
#endif
#ifndef GLEE_C_DEFINED_glStopInstrumentsSGIX
#define GLEE_C_DEFINED_glStopInstrumentsSGIX
void __stdcall GLee_Lazy_glStopInstrumentsSGIX(GLint marker) {if (GLeeInit()) glStopInstrumentsSGIX(marker);}
GLEEPFNGLSTOPINSTRUMENTSSGIXPROC GLeeFuncPtr_glStopInstrumentsSGIX=GLee_Lazy_glStopInstrumentsSGIX;
#endif
#endif
/* GL_SGIX_texture_scale_bias */
#ifdef __GLEE_GL_SGIX_texture_scale_bias
#endif
/* GL_SGIX_framezoom */
#ifdef __GLEE_GL_SGIX_framezoom
#ifndef GLEE_C_DEFINED_glFrameZoomSGIX
#define GLEE_C_DEFINED_glFrameZoomSGIX
void __stdcall GLee_Lazy_glFrameZoomSGIX(GLint factor) {if (GLeeInit()) glFrameZoomSGIX(factor);}
GLEEPFNGLFRAMEZOOMSGIXPROC GLeeFuncPtr_glFrameZoomSGIX=GLee_Lazy_glFrameZoomSGIX;
#endif
#endif
/* GL_SGIX_tag_sample_buffer */
#ifdef __GLEE_GL_SGIX_tag_sample_buffer
#ifndef GLEE_C_DEFINED_glTagSampleBufferSGIX
#define GLEE_C_DEFINED_glTagSampleBufferSGIX
void __stdcall GLee_Lazy_glTagSampleBufferSGIX(void) {if (GLeeInit()) glTagSampleBufferSGIX();}
GLEEPFNGLTAGSAMPLEBUFFERSGIXPROC GLeeFuncPtr_glTagSampleBufferSGIX=GLee_Lazy_glTagSampleBufferSGIX;
#endif
#endif
/* GL_FfdMaskSGIX */
#ifdef __GLEE_GL_FfdMaskSGIX
#endif
/* GL_SGIX_polynomial_ffd */
#ifdef __GLEE_GL_SGIX_polynomial_ffd
#ifndef GLEE_C_DEFINED_glDeformationMap3dSGIX
#define GLEE_C_DEFINED_glDeformationMap3dSGIX
void __stdcall GLee_Lazy_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) {if (GLeeInit()) glDeformationMap3dSGIX(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points);}
GLEEPFNGLDEFORMATIONMAP3DSGIXPROC GLeeFuncPtr_glDeformationMap3dSGIX=GLee_Lazy_glDeformationMap3dSGIX;
#endif
#ifndef GLEE_C_DEFINED_glDeformationMap3fSGIX
#define GLEE_C_DEFINED_glDeformationMap3fSGIX
void __stdcall GLee_Lazy_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) {if (GLeeInit()) glDeformationMap3fSGIX(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points);}
GLEEPFNGLDEFORMATIONMAP3FSGIXPROC GLeeFuncPtr_glDeformationMap3fSGIX=GLee_Lazy_glDeformationMap3fSGIX;
#endif
#ifndef GLEE_C_DEFINED_glDeformSGIX
#define GLEE_C_DEFINED_glDeformSGIX
void __stdcall GLee_Lazy_glDeformSGIX(GLbitfield mask) {if (GLeeInit()) glDeformSGIX(mask);}
GLEEPFNGLDEFORMSGIXPROC GLeeFuncPtr_glDeformSGIX=GLee_Lazy_glDeformSGIX;
#endif
#ifndef GLEE_C_DEFINED_glLoadIdentityDeformationMapSGIX
#define GLEE_C_DEFINED_glLoadIdentityDeformationMapSGIX
void __stdcall GLee_Lazy_glLoadIdentityDeformationMapSGIX(GLbitfield mask) {if (GLeeInit()) glLoadIdentityDeformationMapSGIX(mask);}
GLEEPFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC GLeeFuncPtr_glLoadIdentityDeformationMapSGIX=GLee_Lazy_glLoadIdentityDeformationMapSGIX;
#endif
#endif
/* GL_SGIX_reference_plane */
#ifdef __GLEE_GL_SGIX_reference_plane
#ifndef GLEE_C_DEFINED_glReferencePlaneSGIX
#define GLEE_C_DEFINED_glReferencePlaneSGIX
void __stdcall GLee_Lazy_glReferencePlaneSGIX(const GLdouble * equation) {if (GLeeInit()) glReferencePlaneSGIX(equation);}
GLEEPFNGLREFERENCEPLANESGIXPROC GLeeFuncPtr_glReferencePlaneSGIX=GLee_Lazy_glReferencePlaneSGIX;
#endif
#endif
/* GL_SGIX_flush_raster */
#ifdef __GLEE_GL_SGIX_flush_raster
#ifndef GLEE_C_DEFINED_glFlushRasterSGIX
#define GLEE_C_DEFINED_glFlushRasterSGIX
void __stdcall GLee_Lazy_glFlushRasterSGIX(void) {if (GLeeInit()) glFlushRasterSGIX();}
GLEEPFNGLFLUSHRASTERSGIXPROC GLeeFuncPtr_glFlushRasterSGIX=GLee_Lazy_glFlushRasterSGIX;
#endif
#endif
/* GL_SGIX_depth_texture */
#ifdef __GLEE_GL_SGIX_depth_texture
#endif
/* GL_SGIS_fog_function */
#ifdef __GLEE_GL_SGIS_fog_function
#ifndef GLEE_C_DEFINED_glFogFuncSGIS
#define GLEE_C_DEFINED_glFogFuncSGIS
void __stdcall GLee_Lazy_glFogFuncSGIS(GLsizei n, const GLfloat * points) {if (GLeeInit()) glFogFuncSGIS(n, points);}
GLEEPFNGLFOGFUNCSGISPROC GLeeFuncPtr_glFogFuncSGIS=GLee_Lazy_glFogFuncSGIS;
#endif
#ifndef GLEE_C_DEFINED_glGetFogFuncSGIS
#define GLEE_C_DEFINED_glGetFogFuncSGIS
void __stdcall GLee_Lazy_glGetFogFuncSGIS(GLfloat * points) {if (GLeeInit()) glGetFogFuncSGIS(points);}
GLEEPFNGLGETFOGFUNCSGISPROC GLeeFuncPtr_glGetFogFuncSGIS=GLee_Lazy_glGetFogFuncSGIS;
#endif
#endif
/* GL_SGIX_fog_offset */
#ifdef __GLEE_GL_SGIX_fog_offset
#endif
/* GL_HP_image_transform */
#ifdef __GLEE_GL_HP_image_transform
#ifndef GLEE_C_DEFINED_glImageTransformParameteriHP
#define GLEE_C_DEFINED_glImageTransformParameteriHP
void __stdcall GLee_Lazy_glImageTransformParameteriHP(GLenum target, GLenum pname, GLint param) {if (GLeeInit()) glImageTransformParameteriHP(target, pname, param);}
GLEEPFNGLIMAGETRANSFORMPARAMETERIHPPROC GLeeFuncPtr_glImageTransformParameteriHP=GLee_Lazy_glImageTransformParameteriHP;
#endif
#ifndef GLEE_C_DEFINED_glImageTransformParameterfHP
#define GLEE_C_DEFINED_glImageTransformParameterfHP
void __stdcall GLee_Lazy_glImageTransformParameterfHP(GLenum target, GLenum pname, GLfloat param) {if (GLeeInit()) glImageTransformParameterfHP(target, pname, param);}
GLEEPFNGLIMAGETRANSFORMPARAMETERFHPPROC GLeeFuncPtr_glImageTransformParameterfHP=GLee_Lazy_glImageTransformParameterfHP;
#endif
#ifndef GLEE_C_DEFINED_glImageTransformParameterivHP
#define GLEE_C_DEFINED_glImageTransformParameterivHP
void __stdcall GLee_Lazy_glImageTransformParameterivHP(GLenum target, GLenum pname, const GLint * params) {if (GLeeInit()) glImageTransformParameterivHP(target, pname, params);}
GLEEPFNGLIMAGETRANSFORMPARAMETERIVHPPROC GLeeFuncPtr_glImageTransformParameterivHP=GLee_Lazy_glImageTransformParameterivHP;
#endif
#ifndef GLEE_C_DEFINED_glImageTransformParameterfvHP
#define GLEE_C_DEFINED_glImageTransformParameterfvHP
void __stdcall GLee_Lazy_glImageTransformParameterfvHP(GLenum target, GLenum pname, const GLfloat * params) {if (GLeeInit()) glImageTransformParameterfvHP(target, pname, params);}
GLEEPFNGLIMAGETRANSFORMPARAMETERFVHPPROC GLeeFuncPtr_glImageTransformParameterfvHP=GLee_Lazy_glImageTransformParameterfvHP;
#endif
#ifndef GLEE_C_DEFINED_glGetImageTransformParameterivHP
#define GLEE_C_DEFINED_glGetImageTransformParameterivHP
void __stdcall GLee_Lazy_glGetImageTransformParameterivHP(GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetImageTransformParameterivHP(target, pname, params);}
GLEEPFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC GLeeFuncPtr_glGetImageTransformParameterivHP=GLee_Lazy_glGetImageTransformParameterivHP;
#endif
#ifndef GLEE_C_DEFINED_glGetImageTransformParameterfvHP
#define GLEE_C_DEFINED_glGetImageTransformParameterfvHP
void __stdcall GLee_Lazy_glGetImageTransformParameterfvHP(GLenum target, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetImageTransformParameterfvHP(target, pname, params);}
GLEEPFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC GLeeFuncPtr_glGetImageTransformParameterfvHP=GLee_Lazy_glGetImageTransformParameterfvHP;
#endif
#endif
/* GL_HP_convolution_border_modes */
#ifdef __GLEE_GL_HP_convolution_border_modes
#endif
/* GL_INGR_palette_buffer */
#ifdef __GLEE_GL_INGR_palette_buffer
#endif
/* GL_SGIX_texture_add_env */
#ifdef __GLEE_GL_SGIX_texture_add_env
#endif
/* GL_EXT_color_subtable */
#ifdef __GLEE_GL_EXT_color_subtable
#ifndef GLEE_C_DEFINED_glColorSubTableEXT
#define GLEE_C_DEFINED_glColorSubTableEXT
void __stdcall GLee_Lazy_glColorSubTableEXT(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data) {if (GLeeInit()) glColorSubTableEXT(target, start, count, format, type, data);}
GLEEPFNGLCOLORSUBTABLEEXTPROC GLeeFuncPtr_glColorSubTableEXT=GLee_Lazy_glColorSubTableEXT;
#endif
#ifndef GLEE_C_DEFINED_glCopyColorSubTableEXT
#define GLEE_C_DEFINED_glCopyColorSubTableEXT
void __stdcall GLee_Lazy_glCopyColorSubTableEXT(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width) {if (GLeeInit()) glCopyColorSubTableEXT(target, start, x, y, width);}
GLEEPFNGLCOPYCOLORSUBTABLEEXTPROC GLeeFuncPtr_glCopyColorSubTableEXT=GLee_Lazy_glCopyColorSubTableEXT;
#endif
#endif
/* GL_PGI_vertex_hints */
#ifdef __GLEE_GL_PGI_vertex_hints
#endif
/* GL_PGI_misc_hints */
#ifdef __GLEE_GL_PGI_misc_hints
#ifndef GLEE_C_DEFINED_glHintPGI
#define GLEE_C_DEFINED_glHintPGI
void __stdcall GLee_Lazy_glHintPGI(GLenum target, GLint mode) {if (GLeeInit()) glHintPGI(target, mode);}
GLEEPFNGLHINTPGIPROC GLeeFuncPtr_glHintPGI=GLee_Lazy_glHintPGI;
#endif
#endif
/* GL_EXT_paletted_texture */
#ifdef __GLEE_GL_EXT_paletted_texture
#ifndef GLEE_C_DEFINED_glColorTableEXT
#define GLEE_C_DEFINED_glColorTableEXT
void __stdcall GLee_Lazy_glColorTableEXT(GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid * table) {if (GLeeInit()) glColorTableEXT(target, internalFormat, width, format, type, table);}
GLEEPFNGLCOLORTABLEEXTPROC GLeeFuncPtr_glColorTableEXT=GLee_Lazy_glColorTableEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetColorTableEXT
#define GLEE_C_DEFINED_glGetColorTableEXT
void __stdcall GLee_Lazy_glGetColorTableEXT(GLenum target, GLenum format, GLenum type, GLvoid * data) {if (GLeeInit()) glGetColorTableEXT(target, format, type, data);}
GLEEPFNGLGETCOLORTABLEEXTPROC GLeeFuncPtr_glGetColorTableEXT=GLee_Lazy_glGetColorTableEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetColorTableParameterivEXT
#define GLEE_C_DEFINED_glGetColorTableParameterivEXT
void __stdcall GLee_Lazy_glGetColorTableParameterivEXT(GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetColorTableParameterivEXT(target, pname, params);}
GLEEPFNGLGETCOLORTABLEPARAMETERIVEXTPROC GLeeFuncPtr_glGetColorTableParameterivEXT=GLee_Lazy_glGetColorTableParameterivEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetColorTableParameterfvEXT
#define GLEE_C_DEFINED_glGetColorTableParameterfvEXT
void __stdcall GLee_Lazy_glGetColorTableParameterfvEXT(GLenum target, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetColorTableParameterfvEXT(target, pname, params);}
GLEEPFNGLGETCOLORTABLEPARAMETERFVEXTPROC GLeeFuncPtr_glGetColorTableParameterfvEXT=GLee_Lazy_glGetColorTableParameterfvEXT;
#endif
#endif
/* GL_EXT_clip_volume_hint */
#ifdef __GLEE_GL_EXT_clip_volume_hint
#endif
/* GL_SGIX_list_priority */
#ifdef __GLEE_GL_SGIX_list_priority
#ifndef GLEE_C_DEFINED_glGetListParameterfvSGIX
#define GLEE_C_DEFINED_glGetListParameterfvSGIX
void __stdcall GLee_Lazy_glGetListParameterfvSGIX(GLuint list, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetListParameterfvSGIX(list, pname, params);}
GLEEPFNGLGETLISTPARAMETERFVSGIXPROC GLeeFuncPtr_glGetListParameterfvSGIX=GLee_Lazy_glGetListParameterfvSGIX;
#endif
#ifndef GLEE_C_DEFINED_glGetListParameterivSGIX
#define GLEE_C_DEFINED_glGetListParameterivSGIX
void __stdcall GLee_Lazy_glGetListParameterivSGIX(GLuint list, GLenum pname, GLint * params) {if (GLeeInit()) glGetListParameterivSGIX(list, pname, params);}
GLEEPFNGLGETLISTPARAMETERIVSGIXPROC GLeeFuncPtr_glGetListParameterivSGIX=GLee_Lazy_glGetListParameterivSGIX;
#endif
#ifndef GLEE_C_DEFINED_glListParameterfSGIX
#define GLEE_C_DEFINED_glListParameterfSGIX
void __stdcall GLee_Lazy_glListParameterfSGIX(GLuint list, GLenum pname, GLfloat param) {if (GLeeInit()) glListParameterfSGIX(list, pname, param);}
GLEEPFNGLLISTPARAMETERFSGIXPROC GLeeFuncPtr_glListParameterfSGIX=GLee_Lazy_glListParameterfSGIX;
#endif
#ifndef GLEE_C_DEFINED_glListParameterfvSGIX
#define GLEE_C_DEFINED_glListParameterfvSGIX
void __stdcall GLee_Lazy_glListParameterfvSGIX(GLuint list, GLenum pname, const GLfloat * params) {if (GLeeInit()) glListParameterfvSGIX(list, pname, params);}
GLEEPFNGLLISTPARAMETERFVSGIXPROC GLeeFuncPtr_glListParameterfvSGIX=GLee_Lazy_glListParameterfvSGIX;
#endif
#ifndef GLEE_C_DEFINED_glListParameteriSGIX
#define GLEE_C_DEFINED_glListParameteriSGIX
void __stdcall GLee_Lazy_glListParameteriSGIX(GLuint list, GLenum pname, GLint param) {if (GLeeInit()) glListParameteriSGIX(list, pname, param);}
GLEEPFNGLLISTPARAMETERISGIXPROC GLeeFuncPtr_glListParameteriSGIX=GLee_Lazy_glListParameteriSGIX;
#endif
#ifndef GLEE_C_DEFINED_glListParameterivSGIX
#define GLEE_C_DEFINED_glListParameterivSGIX
void __stdcall GLee_Lazy_glListParameterivSGIX(GLuint list, GLenum pname, const GLint * params) {if (GLeeInit()) glListParameterivSGIX(list, pname, params);}
GLEEPFNGLLISTPARAMETERIVSGIXPROC GLeeFuncPtr_glListParameterivSGIX=GLee_Lazy_glListParameterivSGIX;
#endif
#endif
/* GL_SGIX_ir_instrument1 */
#ifdef __GLEE_GL_SGIX_ir_instrument1
#endif
/* GL_SGIX_calligraphic_fragment */
#ifdef __GLEE_GL_SGIX_calligraphic_fragment
#endif
/* GL_SGIX_texture_lod_bias */
#ifdef __GLEE_GL_SGIX_texture_lod_bias
#endif
/* GL_SGIX_shadow_ambient */
#ifdef __GLEE_GL_SGIX_shadow_ambient
#endif
/* GL_EXT_index_texture */
#ifdef __GLEE_GL_EXT_index_texture
#endif
/* GL_EXT_index_material */
#ifdef __GLEE_GL_EXT_index_material
#ifndef GLEE_C_DEFINED_glIndexMaterialEXT
#define GLEE_C_DEFINED_glIndexMaterialEXT
void __stdcall GLee_Lazy_glIndexMaterialEXT(GLenum face, GLenum mode) {if (GLeeInit()) glIndexMaterialEXT(face, mode);}
GLEEPFNGLINDEXMATERIALEXTPROC GLeeFuncPtr_glIndexMaterialEXT=GLee_Lazy_glIndexMaterialEXT;
#endif
#endif
/* GL_EXT_index_func */
#ifdef __GLEE_GL_EXT_index_func
#ifndef GLEE_C_DEFINED_glIndexFuncEXT
#define GLEE_C_DEFINED_glIndexFuncEXT
void __stdcall GLee_Lazy_glIndexFuncEXT(GLenum func, GLclampf ref) {if (GLeeInit()) glIndexFuncEXT(func, ref);}
GLEEPFNGLINDEXFUNCEXTPROC GLeeFuncPtr_glIndexFuncEXT=GLee_Lazy_glIndexFuncEXT;
#endif
#endif
/* GL_EXT_index_array_formats */
#ifdef __GLEE_GL_EXT_index_array_formats
#endif
/* GL_EXT_compiled_vertex_array */
#ifdef __GLEE_GL_EXT_compiled_vertex_array
#ifndef GLEE_C_DEFINED_glLockArraysEXT
#define GLEE_C_DEFINED_glLockArraysEXT
void __stdcall GLee_Lazy_glLockArraysEXT(GLint first, GLsizei count) {if (GLeeInit()) glLockArraysEXT(first, count);}
GLEEPFNGLLOCKARRAYSEXTPROC GLeeFuncPtr_glLockArraysEXT=GLee_Lazy_glLockArraysEXT;
#endif
#ifndef GLEE_C_DEFINED_glUnlockArraysEXT
#define GLEE_C_DEFINED_glUnlockArraysEXT
void __stdcall GLee_Lazy_glUnlockArraysEXT(void) {if (GLeeInit()) glUnlockArraysEXT();}
GLEEPFNGLUNLOCKARRAYSEXTPROC GLeeFuncPtr_glUnlockArraysEXT=GLee_Lazy_glUnlockArraysEXT;
#endif
#endif
/* GL_EXT_cull_vertex */
#ifdef __GLEE_GL_EXT_cull_vertex
#ifndef GLEE_C_DEFINED_glCullParameterdvEXT
#define GLEE_C_DEFINED_glCullParameterdvEXT
void __stdcall GLee_Lazy_glCullParameterdvEXT(GLenum pname, GLdouble * params) {if (GLeeInit()) glCullParameterdvEXT(pname, params);}
GLEEPFNGLCULLPARAMETERDVEXTPROC GLeeFuncPtr_glCullParameterdvEXT=GLee_Lazy_glCullParameterdvEXT;
#endif
#ifndef GLEE_C_DEFINED_glCullParameterfvEXT
#define GLEE_C_DEFINED_glCullParameterfvEXT
void __stdcall GLee_Lazy_glCullParameterfvEXT(GLenum pname, GLfloat * params) {if (GLeeInit()) glCullParameterfvEXT(pname, params);}
GLEEPFNGLCULLPARAMETERFVEXTPROC GLeeFuncPtr_glCullParameterfvEXT=GLee_Lazy_glCullParameterfvEXT;
#endif
#endif
/* GL_SGIX_ycrcb */
#ifdef __GLEE_GL_SGIX_ycrcb
#endif
/* GL_SGIX_fragment_lighting */
#ifdef __GLEE_GL_SGIX_fragment_lighting
#ifndef GLEE_C_DEFINED_glFragmentColorMaterialSGIX
#define GLEE_C_DEFINED_glFragmentColorMaterialSGIX
void __stdcall GLee_Lazy_glFragmentColorMaterialSGIX(GLenum face, GLenum mode) {if (GLeeInit()) glFragmentColorMaterialSGIX(face, mode);}
GLEEPFNGLFRAGMENTCOLORMATERIALSGIXPROC GLeeFuncPtr_glFragmentColorMaterialSGIX=GLee_Lazy_glFragmentColorMaterialSGIX;
#endif
#ifndef GLEE_C_DEFINED_glFragmentLightfSGIX
#define GLEE_C_DEFINED_glFragmentLightfSGIX
void __stdcall GLee_Lazy_glFragmentLightfSGIX(GLenum light, GLenum pname, GLfloat param) {if (GLeeInit()) glFragmentLightfSGIX(light, pname, param);}
GLEEPFNGLFRAGMENTLIGHTFSGIXPROC GLeeFuncPtr_glFragmentLightfSGIX=GLee_Lazy_glFragmentLightfSGIX;
#endif
#ifndef GLEE_C_DEFINED_glFragmentLightfvSGIX
#define GLEE_C_DEFINED_glFragmentLightfvSGIX
void __stdcall GLee_Lazy_glFragmentLightfvSGIX(GLenum light, GLenum pname, const GLfloat * params) {if (GLeeInit()) glFragmentLightfvSGIX(light, pname, params);}
GLEEPFNGLFRAGMENTLIGHTFVSGIXPROC GLeeFuncPtr_glFragmentLightfvSGIX=GLee_Lazy_glFragmentLightfvSGIX;
#endif
#ifndef GLEE_C_DEFINED_glFragmentLightiSGIX
#define GLEE_C_DEFINED_glFragmentLightiSGIX
void __stdcall GLee_Lazy_glFragmentLightiSGIX(GLenum light, GLenum pname, GLint param) {if (GLeeInit()) glFragmentLightiSGIX(light, pname, param);}
GLEEPFNGLFRAGMENTLIGHTISGIXPROC GLeeFuncPtr_glFragmentLightiSGIX=GLee_Lazy_glFragmentLightiSGIX;
#endif
#ifndef GLEE_C_DEFINED_glFragmentLightivSGIX
#define GLEE_C_DEFINED_glFragmentLightivSGIX
void __stdcall GLee_Lazy_glFragmentLightivSGIX(GLenum light, GLenum pname, const GLint * params) {if (GLeeInit()) glFragmentLightivSGIX(light, pname, params);}
GLEEPFNGLFRAGMENTLIGHTIVSGIXPROC GLeeFuncPtr_glFragmentLightivSGIX=GLee_Lazy_glFragmentLightivSGIX;
#endif
#ifndef GLEE_C_DEFINED_glFragmentLightModelfSGIX
#define GLEE_C_DEFINED_glFragmentLightModelfSGIX
void __stdcall GLee_Lazy_glFragmentLightModelfSGIX(GLenum pname, GLfloat param) {if (GLeeInit()) glFragmentLightModelfSGIX(pname, param);}
GLEEPFNGLFRAGMENTLIGHTMODELFSGIXPROC GLeeFuncPtr_glFragmentLightModelfSGIX=GLee_Lazy_glFragmentLightModelfSGIX;
#endif
#ifndef GLEE_C_DEFINED_glFragmentLightModelfvSGIX
#define GLEE_C_DEFINED_glFragmentLightModelfvSGIX
void __stdcall GLee_Lazy_glFragmentLightModelfvSGIX(GLenum pname, const GLfloat * params) {if (GLeeInit()) glFragmentLightModelfvSGIX(pname, params);}
GLEEPFNGLFRAGMENTLIGHTMODELFVSGIXPROC GLeeFuncPtr_glFragmentLightModelfvSGIX=GLee_Lazy_glFragmentLightModelfvSGIX;
#endif
#ifndef GLEE_C_DEFINED_glFragmentLightModeliSGIX
#define GLEE_C_DEFINED_glFragmentLightModeliSGIX
void __stdcall GLee_Lazy_glFragmentLightModeliSGIX(GLenum pname, GLint param) {if (GLeeInit()) glFragmentLightModeliSGIX(pname, param);}
GLEEPFNGLFRAGMENTLIGHTMODELISGIXPROC GLeeFuncPtr_glFragmentLightModeliSGIX=GLee_Lazy_glFragmentLightModeliSGIX;
#endif
#ifndef GLEE_C_DEFINED_glFragmentLightModelivSGIX
#define GLEE_C_DEFINED_glFragmentLightModelivSGIX
void __stdcall GLee_Lazy_glFragmentLightModelivSGIX(GLenum pname, const GLint * params) {if (GLeeInit()) glFragmentLightModelivSGIX(pname, params);}
GLEEPFNGLFRAGMENTLIGHTMODELIVSGIXPROC GLeeFuncPtr_glFragmentLightModelivSGIX=GLee_Lazy_glFragmentLightModelivSGIX;
#endif
#ifndef GLEE_C_DEFINED_glFragmentMaterialfSGIX
#define GLEE_C_DEFINED_glFragmentMaterialfSGIX
void __stdcall GLee_Lazy_glFragmentMaterialfSGIX(GLenum face, GLenum pname, GLfloat param) {if (GLeeInit()) glFragmentMaterialfSGIX(face, pname, param);}
GLEEPFNGLFRAGMENTMATERIALFSGIXPROC GLeeFuncPtr_glFragmentMaterialfSGIX=GLee_Lazy_glFragmentMaterialfSGIX;
#endif
#ifndef GLEE_C_DEFINED_glFragmentMaterialfvSGIX
#define GLEE_C_DEFINED_glFragmentMaterialfvSGIX
void __stdcall GLee_Lazy_glFragmentMaterialfvSGIX(GLenum face, GLenum pname, const GLfloat * params) {if (GLeeInit()) glFragmentMaterialfvSGIX(face, pname, params);}
GLEEPFNGLFRAGMENTMATERIALFVSGIXPROC GLeeFuncPtr_glFragmentMaterialfvSGIX=GLee_Lazy_glFragmentMaterialfvSGIX;
#endif
#ifndef GLEE_C_DEFINED_glFragmentMaterialiSGIX
#define GLEE_C_DEFINED_glFragmentMaterialiSGIX
void __stdcall GLee_Lazy_glFragmentMaterialiSGIX(GLenum face, GLenum pname, GLint param) {if (GLeeInit()) glFragmentMaterialiSGIX(face, pname, param);}
GLEEPFNGLFRAGMENTMATERIALISGIXPROC GLeeFuncPtr_glFragmentMaterialiSGIX=GLee_Lazy_glFragmentMaterialiSGIX;
#endif
#ifndef GLEE_C_DEFINED_glFragmentMaterialivSGIX
#define GLEE_C_DEFINED_glFragmentMaterialivSGIX
void __stdcall GLee_Lazy_glFragmentMaterialivSGIX(GLenum face, GLenum pname, const GLint * params) {if (GLeeInit()) glFragmentMaterialivSGIX(face, pname, params);}
GLEEPFNGLFRAGMENTMATERIALIVSGIXPROC GLeeFuncPtr_glFragmentMaterialivSGIX=GLee_Lazy_glFragmentMaterialivSGIX;
#endif
#ifndef GLEE_C_DEFINED_glGetFragmentLightfvSGIX
#define GLEE_C_DEFINED_glGetFragmentLightfvSGIX
void __stdcall GLee_Lazy_glGetFragmentLightfvSGIX(GLenum light, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetFragmentLightfvSGIX(light, pname, params);}
GLEEPFNGLGETFRAGMENTLIGHTFVSGIXPROC GLeeFuncPtr_glGetFragmentLightfvSGIX=GLee_Lazy_glGetFragmentLightfvSGIX;
#endif
#ifndef GLEE_C_DEFINED_glGetFragmentLightivSGIX
#define GLEE_C_DEFINED_glGetFragmentLightivSGIX
void __stdcall GLee_Lazy_glGetFragmentLightivSGIX(GLenum light, GLenum pname, GLint * params) {if (GLeeInit()) glGetFragmentLightivSGIX(light, pname, params);}
GLEEPFNGLGETFRAGMENTLIGHTIVSGIXPROC GLeeFuncPtr_glGetFragmentLightivSGIX=GLee_Lazy_glGetFragmentLightivSGIX;
#endif
#ifndef GLEE_C_DEFINED_glGetFragmentMaterialfvSGIX
#define GLEE_C_DEFINED_glGetFragmentMaterialfvSGIX
void __stdcall GLee_Lazy_glGetFragmentMaterialfvSGIX(GLenum face, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetFragmentMaterialfvSGIX(face, pname, params);}
GLEEPFNGLGETFRAGMENTMATERIALFVSGIXPROC GLeeFuncPtr_glGetFragmentMaterialfvSGIX=GLee_Lazy_glGetFragmentMaterialfvSGIX;
#endif
#ifndef GLEE_C_DEFINED_glGetFragmentMaterialivSGIX
#define GLEE_C_DEFINED_glGetFragmentMaterialivSGIX
void __stdcall GLee_Lazy_glGetFragmentMaterialivSGIX(GLenum face, GLenum pname, GLint * params) {if (GLeeInit()) glGetFragmentMaterialivSGIX(face, pname, params);}
GLEEPFNGLGETFRAGMENTMATERIALIVSGIXPROC GLeeFuncPtr_glGetFragmentMaterialivSGIX=GLee_Lazy_glGetFragmentMaterialivSGIX;
#endif
#ifndef GLEE_C_DEFINED_glLightEnviSGIX
#define GLEE_C_DEFINED_glLightEnviSGIX
void __stdcall GLee_Lazy_glLightEnviSGIX(GLenum pname, GLint param) {if (GLeeInit()) glLightEnviSGIX(pname, param);}
GLEEPFNGLLIGHTENVISGIXPROC GLeeFuncPtr_glLightEnviSGIX=GLee_Lazy_glLightEnviSGIX;
#endif
#endif
/* GL_IBM_rasterpos_clip */
#ifdef __GLEE_GL_IBM_rasterpos_clip
#endif
/* GL_HP_texture_lighting */
#ifdef __GLEE_GL_HP_texture_lighting
#endif
/* GL_EXT_draw_range_elements */
#ifdef __GLEE_GL_EXT_draw_range_elements
#ifndef GLEE_C_DEFINED_glDrawRangeElementsEXT
#define GLEE_C_DEFINED_glDrawRangeElementsEXT
void __stdcall GLee_Lazy_glDrawRangeElementsEXT(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices) {if (GLeeInit()) glDrawRangeElementsEXT(mode, start, end, count, type, indices);}
GLEEPFNGLDRAWRANGEELEMENTSEXTPROC GLeeFuncPtr_glDrawRangeElementsEXT=GLee_Lazy_glDrawRangeElementsEXT;
#endif
#endif
/* GL_WIN_phong_shading */
#ifdef __GLEE_GL_WIN_phong_shading
#endif
/* GL_WIN_specular_fog */
#ifdef __GLEE_GL_WIN_specular_fog
#endif
/* GL_EXT_light_texture */
#ifdef __GLEE_GL_EXT_light_texture
#ifndef GLEE_C_DEFINED_glApplyTextureEXT
#define GLEE_C_DEFINED_glApplyTextureEXT
void __stdcall GLee_Lazy_glApplyTextureEXT(GLenum mode) {if (GLeeInit()) glApplyTextureEXT(mode);}
GLEEPFNGLAPPLYTEXTUREEXTPROC GLeeFuncPtr_glApplyTextureEXT=GLee_Lazy_glApplyTextureEXT;
#endif
#ifndef GLEE_C_DEFINED_glTextureLightEXT
#define GLEE_C_DEFINED_glTextureLightEXT
void __stdcall GLee_Lazy_glTextureLightEXT(GLenum pname) {if (GLeeInit()) glTextureLightEXT(pname);}
GLEEPFNGLTEXTURELIGHTEXTPROC GLeeFuncPtr_glTextureLightEXT=GLee_Lazy_glTextureLightEXT;
#endif
#ifndef GLEE_C_DEFINED_glTextureMaterialEXT
#define GLEE_C_DEFINED_glTextureMaterialEXT
void __stdcall GLee_Lazy_glTextureMaterialEXT(GLenum face, GLenum mode) {if (GLeeInit()) glTextureMaterialEXT(face, mode);}
GLEEPFNGLTEXTUREMATERIALEXTPROC GLeeFuncPtr_glTextureMaterialEXT=GLee_Lazy_glTextureMaterialEXT;
#endif
#endif
/* GL_SGIX_blend_alpha_minmax */
#ifdef __GLEE_GL_SGIX_blend_alpha_minmax
#endif
/* GL_SGIX_impact_pixel_texture */
#ifdef __GLEE_GL_SGIX_impact_pixel_texture
#endif
/* GL_EXT_bgra */
#ifdef __GLEE_GL_EXT_bgra
#endif
/* GL_SGIX_async */
#ifdef __GLEE_GL_SGIX_async
#ifndef GLEE_C_DEFINED_glAsyncMarkerSGIX
#define GLEE_C_DEFINED_glAsyncMarkerSGIX
void __stdcall GLee_Lazy_glAsyncMarkerSGIX(GLuint marker) {if (GLeeInit()) glAsyncMarkerSGIX(marker);}
GLEEPFNGLASYNCMARKERSGIXPROC GLeeFuncPtr_glAsyncMarkerSGIX=GLee_Lazy_glAsyncMarkerSGIX;
#endif
#ifndef GLEE_C_DEFINED_glFinishAsyncSGIX
#define GLEE_C_DEFINED_glFinishAsyncSGIX
GLint __stdcall GLee_Lazy_glFinishAsyncSGIX(GLuint * markerp) {if (GLeeInit()) return glFinishAsyncSGIX(markerp); return (GLint)0;}
GLEEPFNGLFINISHASYNCSGIXPROC GLeeFuncPtr_glFinishAsyncSGIX=GLee_Lazy_glFinishAsyncSGIX;
#endif
#ifndef GLEE_C_DEFINED_glPollAsyncSGIX
#define GLEE_C_DEFINED_glPollAsyncSGIX
GLint __stdcall GLee_Lazy_glPollAsyncSGIX(GLuint * markerp) {if (GLeeInit()) return glPollAsyncSGIX(markerp); return (GLint)0;}
GLEEPFNGLPOLLASYNCSGIXPROC GLeeFuncPtr_glPollAsyncSGIX=GLee_Lazy_glPollAsyncSGIX;
#endif
#ifndef GLEE_C_DEFINED_glGenAsyncMarkersSGIX
#define GLEE_C_DEFINED_glGenAsyncMarkersSGIX
GLuint __stdcall GLee_Lazy_glGenAsyncMarkersSGIX(GLsizei range) {if (GLeeInit()) return glGenAsyncMarkersSGIX(range); return (GLuint)0;}
GLEEPFNGLGENASYNCMARKERSSGIXPROC GLeeFuncPtr_glGenAsyncMarkersSGIX=GLee_Lazy_glGenAsyncMarkersSGIX;
#endif
#ifndef GLEE_C_DEFINED_glDeleteAsyncMarkersSGIX
#define GLEE_C_DEFINED_glDeleteAsyncMarkersSGIX
void __stdcall GLee_Lazy_glDeleteAsyncMarkersSGIX(GLuint marker, GLsizei range) {if (GLeeInit()) glDeleteAsyncMarkersSGIX(marker, range);}
GLEEPFNGLDELETEASYNCMARKERSSGIXPROC GLeeFuncPtr_glDeleteAsyncMarkersSGIX=GLee_Lazy_glDeleteAsyncMarkersSGIX;
#endif
#ifndef GLEE_C_DEFINED_glIsAsyncMarkerSGIX
#define GLEE_C_DEFINED_glIsAsyncMarkerSGIX
GLboolean __stdcall GLee_Lazy_glIsAsyncMarkerSGIX(GLuint marker) {if (GLeeInit()) return glIsAsyncMarkerSGIX(marker); return (GLboolean)0;}
GLEEPFNGLISASYNCMARKERSGIXPROC GLeeFuncPtr_glIsAsyncMarkerSGIX=GLee_Lazy_glIsAsyncMarkerSGIX;
#endif
#endif
/* GL_SGIX_async_pixel */
#ifdef __GLEE_GL_SGIX_async_pixel
#endif
/* GL_SGIX_async_histogram */
#ifdef __GLEE_GL_SGIX_async_histogram
#endif
/* GL_INTEL_texture_scissor */
#ifdef __GLEE_GL_INTEL_texture_scissor
#endif
/* GL_INTEL_parallel_arrays */
#ifdef __GLEE_GL_INTEL_parallel_arrays
#ifndef GLEE_C_DEFINED_glVertexPointervINTEL
#define GLEE_C_DEFINED_glVertexPointervINTEL
void __stdcall GLee_Lazy_glVertexPointervINTEL(GLint size, GLenum type, const GLvoid* * pointer) {if (GLeeInit()) glVertexPointervINTEL(size, type, pointer);}
GLEEPFNGLVERTEXPOINTERVINTELPROC GLeeFuncPtr_glVertexPointervINTEL=GLee_Lazy_glVertexPointervINTEL;
#endif
#ifndef GLEE_C_DEFINED_glNormalPointervINTEL
#define GLEE_C_DEFINED_glNormalPointervINTEL
void __stdcall GLee_Lazy_glNormalPointervINTEL(GLenum type, const GLvoid* * pointer) {if (GLeeInit()) glNormalPointervINTEL(type, pointer);}
GLEEPFNGLNORMALPOINTERVINTELPROC GLeeFuncPtr_glNormalPointervINTEL=GLee_Lazy_glNormalPointervINTEL;
#endif
#ifndef GLEE_C_DEFINED_glColorPointervINTEL
#define GLEE_C_DEFINED_glColorPointervINTEL
void __stdcall GLee_Lazy_glColorPointervINTEL(GLint size, GLenum type, const GLvoid* * pointer) {if (GLeeInit()) glColorPointervINTEL(size, type, pointer);}
GLEEPFNGLCOLORPOINTERVINTELPROC GLeeFuncPtr_glColorPointervINTEL=GLee_Lazy_glColorPointervINTEL;
#endif
#ifndef GLEE_C_DEFINED_glTexCoordPointervINTEL
#define GLEE_C_DEFINED_glTexCoordPointervINTEL
void __stdcall GLee_Lazy_glTexCoordPointervINTEL(GLint size, GLenum type, const GLvoid* * pointer) {if (GLeeInit()) glTexCoordPointervINTEL(size, type, pointer);}
GLEEPFNGLTEXCOORDPOINTERVINTELPROC GLeeFuncPtr_glTexCoordPointervINTEL=GLee_Lazy_glTexCoordPointervINTEL;
#endif
#endif
/* GL_HP_occlusion_test */
#ifdef __GLEE_GL_HP_occlusion_test
#endif
/* GL_EXT_pixel_transform */
#ifdef __GLEE_GL_EXT_pixel_transform
#ifndef GLEE_C_DEFINED_glPixelTransformParameteriEXT
#define GLEE_C_DEFINED_glPixelTransformParameteriEXT
void __stdcall GLee_Lazy_glPixelTransformParameteriEXT(GLenum target, GLenum pname, GLint param) {if (GLeeInit()) glPixelTransformParameteriEXT(target, pname, param);}
GLEEPFNGLPIXELTRANSFORMPARAMETERIEXTPROC GLeeFuncPtr_glPixelTransformParameteriEXT=GLee_Lazy_glPixelTransformParameteriEXT;
#endif
#ifndef GLEE_C_DEFINED_glPixelTransformParameterfEXT
#define GLEE_C_DEFINED_glPixelTransformParameterfEXT
void __stdcall GLee_Lazy_glPixelTransformParameterfEXT(GLenum target, GLenum pname, GLfloat param) {if (GLeeInit()) glPixelTransformParameterfEXT(target, pname, param);}
GLEEPFNGLPIXELTRANSFORMPARAMETERFEXTPROC GLeeFuncPtr_glPixelTransformParameterfEXT=GLee_Lazy_glPixelTransformParameterfEXT;
#endif
#ifndef GLEE_C_DEFINED_glPixelTransformParameterivEXT
#define GLEE_C_DEFINED_glPixelTransformParameterivEXT
void __stdcall GLee_Lazy_glPixelTransformParameterivEXT(GLenum target, GLenum pname, const GLint * params) {if (GLeeInit()) glPixelTransformParameterivEXT(target, pname, params);}
GLEEPFNGLPIXELTRANSFORMPARAMETERIVEXTPROC GLeeFuncPtr_glPixelTransformParameterivEXT=GLee_Lazy_glPixelTransformParameterivEXT;
#endif
#ifndef GLEE_C_DEFINED_glPixelTransformParameterfvEXT
#define GLEE_C_DEFINED_glPixelTransformParameterfvEXT
void __stdcall GLee_Lazy_glPixelTransformParameterfvEXT(GLenum target, GLenum pname, const GLfloat * params) {if (GLeeInit()) glPixelTransformParameterfvEXT(target, pname, params);}
GLEEPFNGLPIXELTRANSFORMPARAMETERFVEXTPROC GLeeFuncPtr_glPixelTransformParameterfvEXT=GLee_Lazy_glPixelTransformParameterfvEXT;
#endif
#endif
/* GL_EXT_pixel_transform_color_table */
#ifdef __GLEE_GL_EXT_pixel_transform_color_table
#endif
/* GL_EXT_shared_texture_palette */
#ifdef __GLEE_GL_EXT_shared_texture_palette
#endif
/* GL_EXT_separate_specular_color */
#ifdef __GLEE_GL_EXT_separate_specular_color
#endif
/* GL_EXT_secondary_color */
#ifdef __GLEE_GL_EXT_secondary_color
#ifndef GLEE_C_DEFINED_glSecondaryColor3bEXT
#define GLEE_C_DEFINED_glSecondaryColor3bEXT
void __stdcall GLee_Lazy_glSecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue) {if (GLeeInit()) glSecondaryColor3bEXT(red, green, blue);}
GLEEPFNGLSECONDARYCOLOR3BEXTPROC GLeeFuncPtr_glSecondaryColor3bEXT=GLee_Lazy_glSecondaryColor3bEXT;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3bvEXT
#define GLEE_C_DEFINED_glSecondaryColor3bvEXT
void __stdcall GLee_Lazy_glSecondaryColor3bvEXT(const GLbyte * v) {if (GLeeInit()) glSecondaryColor3bvEXT(v);}
GLEEPFNGLSECONDARYCOLOR3BVEXTPROC GLeeFuncPtr_glSecondaryColor3bvEXT=GLee_Lazy_glSecondaryColor3bvEXT;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3dEXT
#define GLEE_C_DEFINED_glSecondaryColor3dEXT
void __stdcall GLee_Lazy_glSecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue) {if (GLeeInit()) glSecondaryColor3dEXT(red, green, blue);}
GLEEPFNGLSECONDARYCOLOR3DEXTPROC GLeeFuncPtr_glSecondaryColor3dEXT=GLee_Lazy_glSecondaryColor3dEXT;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3dvEXT
#define GLEE_C_DEFINED_glSecondaryColor3dvEXT
void __stdcall GLee_Lazy_glSecondaryColor3dvEXT(const GLdouble * v) {if (GLeeInit()) glSecondaryColor3dvEXT(v);}
GLEEPFNGLSECONDARYCOLOR3DVEXTPROC GLeeFuncPtr_glSecondaryColor3dvEXT=GLee_Lazy_glSecondaryColor3dvEXT;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3fEXT
#define GLEE_C_DEFINED_glSecondaryColor3fEXT
void __stdcall GLee_Lazy_glSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue) {if (GLeeInit()) glSecondaryColor3fEXT(red, green, blue);}
GLEEPFNGLSECONDARYCOLOR3FEXTPROC GLeeFuncPtr_glSecondaryColor3fEXT=GLee_Lazy_glSecondaryColor3fEXT;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3fvEXT
#define GLEE_C_DEFINED_glSecondaryColor3fvEXT
void __stdcall GLee_Lazy_glSecondaryColor3fvEXT(const GLfloat * v) {if (GLeeInit()) glSecondaryColor3fvEXT(v);}
GLEEPFNGLSECONDARYCOLOR3FVEXTPROC GLeeFuncPtr_glSecondaryColor3fvEXT=GLee_Lazy_glSecondaryColor3fvEXT;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3iEXT
#define GLEE_C_DEFINED_glSecondaryColor3iEXT
void __stdcall GLee_Lazy_glSecondaryColor3iEXT(GLint red, GLint green, GLint blue) {if (GLeeInit()) glSecondaryColor3iEXT(red, green, blue);}
GLEEPFNGLSECONDARYCOLOR3IEXTPROC GLeeFuncPtr_glSecondaryColor3iEXT=GLee_Lazy_glSecondaryColor3iEXT;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3ivEXT
#define GLEE_C_DEFINED_glSecondaryColor3ivEXT
void __stdcall GLee_Lazy_glSecondaryColor3ivEXT(const GLint * v) {if (GLeeInit()) glSecondaryColor3ivEXT(v);}
GLEEPFNGLSECONDARYCOLOR3IVEXTPROC GLeeFuncPtr_glSecondaryColor3ivEXT=GLee_Lazy_glSecondaryColor3ivEXT;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3sEXT
#define GLEE_C_DEFINED_glSecondaryColor3sEXT
void __stdcall GLee_Lazy_glSecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue) {if (GLeeInit()) glSecondaryColor3sEXT(red, green, blue);}
GLEEPFNGLSECONDARYCOLOR3SEXTPROC GLeeFuncPtr_glSecondaryColor3sEXT=GLee_Lazy_glSecondaryColor3sEXT;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3svEXT
#define GLEE_C_DEFINED_glSecondaryColor3svEXT
void __stdcall GLee_Lazy_glSecondaryColor3svEXT(const GLshort * v) {if (GLeeInit()) glSecondaryColor3svEXT(v);}
GLEEPFNGLSECONDARYCOLOR3SVEXTPROC GLeeFuncPtr_glSecondaryColor3svEXT=GLee_Lazy_glSecondaryColor3svEXT;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3ubEXT
#define GLEE_C_DEFINED_glSecondaryColor3ubEXT
void __stdcall GLee_Lazy_glSecondaryColor3ubEXT(GLubyte red, GLubyte green, GLubyte blue) {if (GLeeInit()) glSecondaryColor3ubEXT(red, green, blue);}
GLEEPFNGLSECONDARYCOLOR3UBEXTPROC GLeeFuncPtr_glSecondaryColor3ubEXT=GLee_Lazy_glSecondaryColor3ubEXT;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3ubvEXT
#define GLEE_C_DEFINED_glSecondaryColor3ubvEXT
void __stdcall GLee_Lazy_glSecondaryColor3ubvEXT(const GLubyte * v) {if (GLeeInit()) glSecondaryColor3ubvEXT(v);}
GLEEPFNGLSECONDARYCOLOR3UBVEXTPROC GLeeFuncPtr_glSecondaryColor3ubvEXT=GLee_Lazy_glSecondaryColor3ubvEXT;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3uiEXT
#define GLEE_C_DEFINED_glSecondaryColor3uiEXT
void __stdcall GLee_Lazy_glSecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue) {if (GLeeInit()) glSecondaryColor3uiEXT(red, green, blue);}
GLEEPFNGLSECONDARYCOLOR3UIEXTPROC GLeeFuncPtr_glSecondaryColor3uiEXT=GLee_Lazy_glSecondaryColor3uiEXT;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3uivEXT
#define GLEE_C_DEFINED_glSecondaryColor3uivEXT
void __stdcall GLee_Lazy_glSecondaryColor3uivEXT(const GLuint * v) {if (GLeeInit()) glSecondaryColor3uivEXT(v);}
GLEEPFNGLSECONDARYCOLOR3UIVEXTPROC GLeeFuncPtr_glSecondaryColor3uivEXT=GLee_Lazy_glSecondaryColor3uivEXT;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3usEXT
#define GLEE_C_DEFINED_glSecondaryColor3usEXT
void __stdcall GLee_Lazy_glSecondaryColor3usEXT(GLushort red, GLushort green, GLushort blue) {if (GLeeInit()) glSecondaryColor3usEXT(red, green, blue);}
GLEEPFNGLSECONDARYCOLOR3USEXTPROC GLeeFuncPtr_glSecondaryColor3usEXT=GLee_Lazy_glSecondaryColor3usEXT;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3usvEXT
#define GLEE_C_DEFINED_glSecondaryColor3usvEXT
void __stdcall GLee_Lazy_glSecondaryColor3usvEXT(const GLushort * v) {if (GLeeInit()) glSecondaryColor3usvEXT(v);}
GLEEPFNGLSECONDARYCOLOR3USVEXTPROC GLeeFuncPtr_glSecondaryColor3usvEXT=GLee_Lazy_glSecondaryColor3usvEXT;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColorPointerEXT
#define GLEE_C_DEFINED_glSecondaryColorPointerEXT
void __stdcall GLee_Lazy_glSecondaryColorPointerEXT(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer) {if (GLeeInit()) glSecondaryColorPointerEXT(size, type, stride, pointer);}
GLEEPFNGLSECONDARYCOLORPOINTEREXTPROC GLeeFuncPtr_glSecondaryColorPointerEXT=GLee_Lazy_glSecondaryColorPointerEXT;
#endif
#endif
/* GL_EXT_texture_perturb_normal */
#ifdef __GLEE_GL_EXT_texture_perturb_normal
#ifndef GLEE_C_DEFINED_glTextureNormalEXT
#define GLEE_C_DEFINED_glTextureNormalEXT
void __stdcall GLee_Lazy_glTextureNormalEXT(GLenum mode) {if (GLeeInit()) glTextureNormalEXT(mode);}
GLEEPFNGLTEXTURENORMALEXTPROC GLeeFuncPtr_glTextureNormalEXT=GLee_Lazy_glTextureNormalEXT;
#endif
#endif
/* GL_EXT_multi_draw_arrays */
#ifdef __GLEE_GL_EXT_multi_draw_arrays
#ifndef GLEE_C_DEFINED_glMultiDrawArraysEXT
#define GLEE_C_DEFINED_glMultiDrawArraysEXT
void __stdcall GLee_Lazy_glMultiDrawArraysEXT(GLenum mode, GLint * first, GLsizei * count, GLsizei primcount) {if (GLeeInit()) glMultiDrawArraysEXT(mode, first, count, primcount);}
GLEEPFNGLMULTIDRAWARRAYSEXTPROC GLeeFuncPtr_glMultiDrawArraysEXT=GLee_Lazy_glMultiDrawArraysEXT;
#endif
#ifndef GLEE_C_DEFINED_glMultiDrawElementsEXT
#define GLEE_C_DEFINED_glMultiDrawElementsEXT
void __stdcall GLee_Lazy_glMultiDrawElementsEXT(GLenum mode, const GLsizei * count, GLenum type, const GLvoid* * indices, GLsizei primcount) {if (GLeeInit()) glMultiDrawElementsEXT(mode, count, type, indices, primcount);}
GLEEPFNGLMULTIDRAWELEMENTSEXTPROC GLeeFuncPtr_glMultiDrawElementsEXT=GLee_Lazy_glMultiDrawElementsEXT;
#endif
#endif
/* GL_EXT_fog_coord */
#ifdef __GLEE_GL_EXT_fog_coord
#ifndef GLEE_C_DEFINED_glFogCoordfEXT
#define GLEE_C_DEFINED_glFogCoordfEXT
void __stdcall GLee_Lazy_glFogCoordfEXT(GLfloat coord) {if (GLeeInit()) glFogCoordfEXT(coord);}
GLEEPFNGLFOGCOORDFEXTPROC GLeeFuncPtr_glFogCoordfEXT=GLee_Lazy_glFogCoordfEXT;
#endif
#ifndef GLEE_C_DEFINED_glFogCoordfvEXT
#define GLEE_C_DEFINED_glFogCoordfvEXT
void __stdcall GLee_Lazy_glFogCoordfvEXT(const GLfloat * coord) {if (GLeeInit()) glFogCoordfvEXT(coord);}
GLEEPFNGLFOGCOORDFVEXTPROC GLeeFuncPtr_glFogCoordfvEXT=GLee_Lazy_glFogCoordfvEXT;
#endif
#ifndef GLEE_C_DEFINED_glFogCoorddEXT
#define GLEE_C_DEFINED_glFogCoorddEXT
void __stdcall GLee_Lazy_glFogCoorddEXT(GLdouble coord) {if (GLeeInit()) glFogCoorddEXT(coord);}
GLEEPFNGLFOGCOORDDEXTPROC GLeeFuncPtr_glFogCoorddEXT=GLee_Lazy_glFogCoorddEXT;
#endif
#ifndef GLEE_C_DEFINED_glFogCoorddvEXT
#define GLEE_C_DEFINED_glFogCoorddvEXT
void __stdcall GLee_Lazy_glFogCoorddvEXT(const GLdouble * coord) {if (GLeeInit()) glFogCoorddvEXT(coord);}
GLEEPFNGLFOGCOORDDVEXTPROC GLeeFuncPtr_glFogCoorddvEXT=GLee_Lazy_glFogCoorddvEXT;
#endif
#ifndef GLEE_C_DEFINED_glFogCoordPointerEXT
#define GLEE_C_DEFINED_glFogCoordPointerEXT
void __stdcall GLee_Lazy_glFogCoordPointerEXT(GLenum type, GLsizei stride, const GLvoid * pointer) {if (GLeeInit()) glFogCoordPointerEXT(type, stride, pointer);}
GLEEPFNGLFOGCOORDPOINTEREXTPROC GLeeFuncPtr_glFogCoordPointerEXT=GLee_Lazy_glFogCoordPointerEXT;
#endif
#endif
/* GL_REND_screen_coordinates */
#ifdef __GLEE_GL_REND_screen_coordinates
#endif
/* GL_EXT_coordinate_frame */
#ifdef __GLEE_GL_EXT_coordinate_frame
#ifndef GLEE_C_DEFINED_glTangent3bEXT
#define GLEE_C_DEFINED_glTangent3bEXT
void __stdcall GLee_Lazy_glTangent3bEXT(GLbyte tx, GLbyte ty, GLbyte tz) {if (GLeeInit()) glTangent3bEXT(tx, ty, tz);}
GLEEPFNGLTANGENT3BEXTPROC GLeeFuncPtr_glTangent3bEXT=GLee_Lazy_glTangent3bEXT;
#endif
#ifndef GLEE_C_DEFINED_glTangent3bvEXT
#define GLEE_C_DEFINED_glTangent3bvEXT
void __stdcall GLee_Lazy_glTangent3bvEXT(const GLbyte * v) {if (GLeeInit()) glTangent3bvEXT(v);}
GLEEPFNGLTANGENT3BVEXTPROC GLeeFuncPtr_glTangent3bvEXT=GLee_Lazy_glTangent3bvEXT;
#endif
#ifndef GLEE_C_DEFINED_glTangent3dEXT
#define GLEE_C_DEFINED_glTangent3dEXT
void __stdcall GLee_Lazy_glTangent3dEXT(GLdouble tx, GLdouble ty, GLdouble tz) {if (GLeeInit()) glTangent3dEXT(tx, ty, tz);}
GLEEPFNGLTANGENT3DEXTPROC GLeeFuncPtr_glTangent3dEXT=GLee_Lazy_glTangent3dEXT;
#endif
#ifndef GLEE_C_DEFINED_glTangent3dvEXT
#define GLEE_C_DEFINED_glTangent3dvEXT
void __stdcall GLee_Lazy_glTangent3dvEXT(const GLdouble * v) {if (GLeeInit()) glTangent3dvEXT(v);}
GLEEPFNGLTANGENT3DVEXTPROC GLeeFuncPtr_glTangent3dvEXT=GLee_Lazy_glTangent3dvEXT;
#endif
#ifndef GLEE_C_DEFINED_glTangent3fEXT
#define GLEE_C_DEFINED_glTangent3fEXT
void __stdcall GLee_Lazy_glTangent3fEXT(GLfloat tx, GLfloat ty, GLfloat tz) {if (GLeeInit()) glTangent3fEXT(tx, ty, tz);}
GLEEPFNGLTANGENT3FEXTPROC GLeeFuncPtr_glTangent3fEXT=GLee_Lazy_glTangent3fEXT;
#endif
#ifndef GLEE_C_DEFINED_glTangent3fvEXT
#define GLEE_C_DEFINED_glTangent3fvEXT
void __stdcall GLee_Lazy_glTangent3fvEXT(const GLfloat * v) {if (GLeeInit()) glTangent3fvEXT(v);}
GLEEPFNGLTANGENT3FVEXTPROC GLeeFuncPtr_glTangent3fvEXT=GLee_Lazy_glTangent3fvEXT;
#endif
#ifndef GLEE_C_DEFINED_glTangent3iEXT
#define GLEE_C_DEFINED_glTangent3iEXT
void __stdcall GLee_Lazy_glTangent3iEXT(GLint tx, GLint ty, GLint tz) {if (GLeeInit()) glTangent3iEXT(tx, ty, tz);}
GLEEPFNGLTANGENT3IEXTPROC GLeeFuncPtr_glTangent3iEXT=GLee_Lazy_glTangent3iEXT;
#endif
#ifndef GLEE_C_DEFINED_glTangent3ivEXT
#define GLEE_C_DEFINED_glTangent3ivEXT
void __stdcall GLee_Lazy_glTangent3ivEXT(const GLint * v) {if (GLeeInit()) glTangent3ivEXT(v);}
GLEEPFNGLTANGENT3IVEXTPROC GLeeFuncPtr_glTangent3ivEXT=GLee_Lazy_glTangent3ivEXT;
#endif
#ifndef GLEE_C_DEFINED_glTangent3sEXT
#define GLEE_C_DEFINED_glTangent3sEXT
void __stdcall GLee_Lazy_glTangent3sEXT(GLshort tx, GLshort ty, GLshort tz) {if (GLeeInit()) glTangent3sEXT(tx, ty, tz);}
GLEEPFNGLTANGENT3SEXTPROC GLeeFuncPtr_glTangent3sEXT=GLee_Lazy_glTangent3sEXT;
#endif
#ifndef GLEE_C_DEFINED_glTangent3svEXT
#define GLEE_C_DEFINED_glTangent3svEXT
void __stdcall GLee_Lazy_glTangent3svEXT(const GLshort * v) {if (GLeeInit()) glTangent3svEXT(v);}
GLEEPFNGLTANGENT3SVEXTPROC GLeeFuncPtr_glTangent3svEXT=GLee_Lazy_glTangent3svEXT;
#endif
#ifndef GLEE_C_DEFINED_glBinormal3bEXT
#define GLEE_C_DEFINED_glBinormal3bEXT
void __stdcall GLee_Lazy_glBinormal3bEXT(GLbyte bx, GLbyte by, GLbyte bz) {if (GLeeInit()) glBinormal3bEXT(bx, by, bz);}
GLEEPFNGLBINORMAL3BEXTPROC GLeeFuncPtr_glBinormal3bEXT=GLee_Lazy_glBinormal3bEXT;
#endif
#ifndef GLEE_C_DEFINED_glBinormal3bvEXT
#define GLEE_C_DEFINED_glBinormal3bvEXT
void __stdcall GLee_Lazy_glBinormal3bvEXT(const GLbyte * v) {if (GLeeInit()) glBinormal3bvEXT(v);}
GLEEPFNGLBINORMAL3BVEXTPROC GLeeFuncPtr_glBinormal3bvEXT=GLee_Lazy_glBinormal3bvEXT;
#endif
#ifndef GLEE_C_DEFINED_glBinormal3dEXT
#define GLEE_C_DEFINED_glBinormal3dEXT
void __stdcall GLee_Lazy_glBinormal3dEXT(GLdouble bx, GLdouble by, GLdouble bz) {if (GLeeInit()) glBinormal3dEXT(bx, by, bz);}
GLEEPFNGLBINORMAL3DEXTPROC GLeeFuncPtr_glBinormal3dEXT=GLee_Lazy_glBinormal3dEXT;
#endif
#ifndef GLEE_C_DEFINED_glBinormal3dvEXT
#define GLEE_C_DEFINED_glBinormal3dvEXT
void __stdcall GLee_Lazy_glBinormal3dvEXT(const GLdouble * v) {if (GLeeInit()) glBinormal3dvEXT(v);}
GLEEPFNGLBINORMAL3DVEXTPROC GLeeFuncPtr_glBinormal3dvEXT=GLee_Lazy_glBinormal3dvEXT;
#endif
#ifndef GLEE_C_DEFINED_glBinormal3fEXT
#define GLEE_C_DEFINED_glBinormal3fEXT
void __stdcall GLee_Lazy_glBinormal3fEXT(GLfloat bx, GLfloat by, GLfloat bz) {if (GLeeInit()) glBinormal3fEXT(bx, by, bz);}
GLEEPFNGLBINORMAL3FEXTPROC GLeeFuncPtr_glBinormal3fEXT=GLee_Lazy_glBinormal3fEXT;
#endif
#ifndef GLEE_C_DEFINED_glBinormal3fvEXT
#define GLEE_C_DEFINED_glBinormal3fvEXT
void __stdcall GLee_Lazy_glBinormal3fvEXT(const GLfloat * v) {if (GLeeInit()) glBinormal3fvEXT(v);}
GLEEPFNGLBINORMAL3FVEXTPROC GLeeFuncPtr_glBinormal3fvEXT=GLee_Lazy_glBinormal3fvEXT;
#endif
#ifndef GLEE_C_DEFINED_glBinormal3iEXT
#define GLEE_C_DEFINED_glBinormal3iEXT
void __stdcall GLee_Lazy_glBinormal3iEXT(GLint bx, GLint by, GLint bz) {if (GLeeInit()) glBinormal3iEXT(bx, by, bz);}
GLEEPFNGLBINORMAL3IEXTPROC GLeeFuncPtr_glBinormal3iEXT=GLee_Lazy_glBinormal3iEXT;
#endif
#ifndef GLEE_C_DEFINED_glBinormal3ivEXT
#define GLEE_C_DEFINED_glBinormal3ivEXT
void __stdcall GLee_Lazy_glBinormal3ivEXT(const GLint * v) {if (GLeeInit()) glBinormal3ivEXT(v);}
GLEEPFNGLBINORMAL3IVEXTPROC GLeeFuncPtr_glBinormal3ivEXT=GLee_Lazy_glBinormal3ivEXT;
#endif
#ifndef GLEE_C_DEFINED_glBinormal3sEXT
#define GLEE_C_DEFINED_glBinormal3sEXT
void __stdcall GLee_Lazy_glBinormal3sEXT(GLshort bx, GLshort by, GLshort bz) {if (GLeeInit()) glBinormal3sEXT(bx, by, bz);}
GLEEPFNGLBINORMAL3SEXTPROC GLeeFuncPtr_glBinormal3sEXT=GLee_Lazy_glBinormal3sEXT;
#endif
#ifndef GLEE_C_DEFINED_glBinormal3svEXT
#define GLEE_C_DEFINED_glBinormal3svEXT
void __stdcall GLee_Lazy_glBinormal3svEXT(const GLshort * v) {if (GLeeInit()) glBinormal3svEXT(v);}
GLEEPFNGLBINORMAL3SVEXTPROC GLeeFuncPtr_glBinormal3svEXT=GLee_Lazy_glBinormal3svEXT;
#endif
#ifndef GLEE_C_DEFINED_glTangentPointerEXT
#define GLEE_C_DEFINED_glTangentPointerEXT
void __stdcall GLee_Lazy_glTangentPointerEXT(GLenum type, GLsizei stride, const GLvoid * pointer) {if (GLeeInit()) glTangentPointerEXT(type, stride, pointer);}
GLEEPFNGLTANGENTPOINTEREXTPROC GLeeFuncPtr_glTangentPointerEXT=GLee_Lazy_glTangentPointerEXT;
#endif
#ifndef GLEE_C_DEFINED_glBinormalPointerEXT
#define GLEE_C_DEFINED_glBinormalPointerEXT
void __stdcall GLee_Lazy_glBinormalPointerEXT(GLenum type, GLsizei stride, const GLvoid * pointer) {if (GLeeInit()) glBinormalPointerEXT(type, stride, pointer);}
GLEEPFNGLBINORMALPOINTEREXTPROC GLeeFuncPtr_glBinormalPointerEXT=GLee_Lazy_glBinormalPointerEXT;
#endif
#endif
/* GL_EXT_texture_env_combine */
#ifdef __GLEE_GL_EXT_texture_env_combine
#endif
/* GL_APPLE_specular_vector */
#ifdef __GLEE_GL_APPLE_specular_vector
#endif
/* GL_APPLE_transform_hint */
#ifdef __GLEE_GL_APPLE_transform_hint
#endif
/* GL_SGIX_fog_scale */
#ifdef __GLEE_GL_SGIX_fog_scale
#endif
/* GL_SUNX_constant_data */
#ifdef __GLEE_GL_SUNX_constant_data
#ifndef GLEE_C_DEFINED_glFinishTextureSUNX
#define GLEE_C_DEFINED_glFinishTextureSUNX
void __stdcall GLee_Lazy_glFinishTextureSUNX(void) {if (GLeeInit()) glFinishTextureSUNX();}
GLEEPFNGLFINISHTEXTURESUNXPROC GLeeFuncPtr_glFinishTextureSUNX=GLee_Lazy_glFinishTextureSUNX;
#endif
#endif
/* GL_SUN_global_alpha */
#ifdef __GLEE_GL_SUN_global_alpha
#ifndef GLEE_C_DEFINED_glGlobalAlphaFactorbSUN
#define GLEE_C_DEFINED_glGlobalAlphaFactorbSUN
void __stdcall GLee_Lazy_glGlobalAlphaFactorbSUN(GLbyte factor) {if (GLeeInit()) glGlobalAlphaFactorbSUN(factor);}
GLEEPFNGLGLOBALALPHAFACTORBSUNPROC GLeeFuncPtr_glGlobalAlphaFactorbSUN=GLee_Lazy_glGlobalAlphaFactorbSUN;
#endif
#ifndef GLEE_C_DEFINED_glGlobalAlphaFactorsSUN
#define GLEE_C_DEFINED_glGlobalAlphaFactorsSUN
void __stdcall GLee_Lazy_glGlobalAlphaFactorsSUN(GLshort factor) {if (GLeeInit()) glGlobalAlphaFactorsSUN(factor);}
GLEEPFNGLGLOBALALPHAFACTORSSUNPROC GLeeFuncPtr_glGlobalAlphaFactorsSUN=GLee_Lazy_glGlobalAlphaFactorsSUN;
#endif
#ifndef GLEE_C_DEFINED_glGlobalAlphaFactoriSUN
#define GLEE_C_DEFINED_glGlobalAlphaFactoriSUN
void __stdcall GLee_Lazy_glGlobalAlphaFactoriSUN(GLint factor) {if (GLeeInit()) glGlobalAlphaFactoriSUN(factor);}
GLEEPFNGLGLOBALALPHAFACTORISUNPROC GLeeFuncPtr_glGlobalAlphaFactoriSUN=GLee_Lazy_glGlobalAlphaFactoriSUN;
#endif
#ifndef GLEE_C_DEFINED_glGlobalAlphaFactorfSUN
#define GLEE_C_DEFINED_glGlobalAlphaFactorfSUN
void __stdcall GLee_Lazy_glGlobalAlphaFactorfSUN(GLfloat factor) {if (GLeeInit()) glGlobalAlphaFactorfSUN(factor);}
GLEEPFNGLGLOBALALPHAFACTORFSUNPROC GLeeFuncPtr_glGlobalAlphaFactorfSUN=GLee_Lazy_glGlobalAlphaFactorfSUN;
#endif
#ifndef GLEE_C_DEFINED_glGlobalAlphaFactordSUN
#define GLEE_C_DEFINED_glGlobalAlphaFactordSUN
void __stdcall GLee_Lazy_glGlobalAlphaFactordSUN(GLdouble factor) {if (GLeeInit()) glGlobalAlphaFactordSUN(factor);}
GLEEPFNGLGLOBALALPHAFACTORDSUNPROC GLeeFuncPtr_glGlobalAlphaFactordSUN=GLee_Lazy_glGlobalAlphaFactordSUN;
#endif
#ifndef GLEE_C_DEFINED_glGlobalAlphaFactorubSUN
#define GLEE_C_DEFINED_glGlobalAlphaFactorubSUN
void __stdcall GLee_Lazy_glGlobalAlphaFactorubSUN(GLubyte factor) {if (GLeeInit()) glGlobalAlphaFactorubSUN(factor);}
GLEEPFNGLGLOBALALPHAFACTORUBSUNPROC GLeeFuncPtr_glGlobalAlphaFactorubSUN=GLee_Lazy_glGlobalAlphaFactorubSUN;
#endif
#ifndef GLEE_C_DEFINED_glGlobalAlphaFactorusSUN
#define GLEE_C_DEFINED_glGlobalAlphaFactorusSUN
void __stdcall GLee_Lazy_glGlobalAlphaFactorusSUN(GLushort factor) {if (GLeeInit()) glGlobalAlphaFactorusSUN(factor);}
GLEEPFNGLGLOBALALPHAFACTORUSSUNPROC GLeeFuncPtr_glGlobalAlphaFactorusSUN=GLee_Lazy_glGlobalAlphaFactorusSUN;
#endif
#ifndef GLEE_C_DEFINED_glGlobalAlphaFactoruiSUN
#define GLEE_C_DEFINED_glGlobalAlphaFactoruiSUN
void __stdcall GLee_Lazy_glGlobalAlphaFactoruiSUN(GLuint factor) {if (GLeeInit()) glGlobalAlphaFactoruiSUN(factor);}
GLEEPFNGLGLOBALALPHAFACTORUISUNPROC GLeeFuncPtr_glGlobalAlphaFactoruiSUN=GLee_Lazy_glGlobalAlphaFactoruiSUN;
#endif
#endif
/* GL_SUN_triangle_list */
#ifdef __GLEE_GL_SUN_triangle_list
#ifndef GLEE_C_DEFINED_glReplacementCodeuiSUN
#define GLEE_C_DEFINED_glReplacementCodeuiSUN
void __stdcall GLee_Lazy_glReplacementCodeuiSUN(GLuint code) {if (GLeeInit()) glReplacementCodeuiSUN(code);}
GLEEPFNGLREPLACEMENTCODEUISUNPROC GLeeFuncPtr_glReplacementCodeuiSUN=GLee_Lazy_glReplacementCodeuiSUN;
#endif
#ifndef GLEE_C_DEFINED_glReplacementCodeusSUN
#define GLEE_C_DEFINED_glReplacementCodeusSUN
void __stdcall GLee_Lazy_glReplacementCodeusSUN(GLushort code) {if (GLeeInit()) glReplacementCodeusSUN(code);}
GLEEPFNGLREPLACEMENTCODEUSSUNPROC GLeeFuncPtr_glReplacementCodeusSUN=GLee_Lazy_glReplacementCodeusSUN;
#endif
#ifndef GLEE_C_DEFINED_glReplacementCodeubSUN
#define GLEE_C_DEFINED_glReplacementCodeubSUN
void __stdcall GLee_Lazy_glReplacementCodeubSUN(GLubyte code) {if (GLeeInit()) glReplacementCodeubSUN(code);}
GLEEPFNGLREPLACEMENTCODEUBSUNPROC GLeeFuncPtr_glReplacementCodeubSUN=GLee_Lazy_glReplacementCodeubSUN;
#endif
#ifndef GLEE_C_DEFINED_glReplacementCodeuivSUN
#define GLEE_C_DEFINED_glReplacementCodeuivSUN
void __stdcall GLee_Lazy_glReplacementCodeuivSUN(const GLuint * code) {if (GLeeInit()) glReplacementCodeuivSUN(code);}
GLEEPFNGLREPLACEMENTCODEUIVSUNPROC GLeeFuncPtr_glReplacementCodeuivSUN=GLee_Lazy_glReplacementCodeuivSUN;
#endif
#ifndef GLEE_C_DEFINED_glReplacementCodeusvSUN
#define GLEE_C_DEFINED_glReplacementCodeusvSUN
void __stdcall GLee_Lazy_glReplacementCodeusvSUN(const GLushort * code) {if (GLeeInit()) glReplacementCodeusvSUN(code);}
GLEEPFNGLREPLACEMENTCODEUSVSUNPROC GLeeFuncPtr_glReplacementCodeusvSUN=GLee_Lazy_glReplacementCodeusvSUN;
#endif
#ifndef GLEE_C_DEFINED_glReplacementCodeubvSUN
#define GLEE_C_DEFINED_glReplacementCodeubvSUN
void __stdcall GLee_Lazy_glReplacementCodeubvSUN(const GLubyte * code) {if (GLeeInit()) glReplacementCodeubvSUN(code);}
GLEEPFNGLREPLACEMENTCODEUBVSUNPROC GLeeFuncPtr_glReplacementCodeubvSUN=GLee_Lazy_glReplacementCodeubvSUN;
#endif
#ifndef GLEE_C_DEFINED_glReplacementCodePointerSUN
#define GLEE_C_DEFINED_glReplacementCodePointerSUN
void __stdcall GLee_Lazy_glReplacementCodePointerSUN(GLenum type, GLsizei stride, const GLvoid* * pointer) {if (GLeeInit()) glReplacementCodePointerSUN(type, stride, pointer);}
GLEEPFNGLREPLACEMENTCODEPOINTERSUNPROC GLeeFuncPtr_glReplacementCodePointerSUN=GLee_Lazy_glReplacementCodePointerSUN;
#endif
#endif
/* GL_SUN_vertex */
#ifdef __GLEE_GL_SUN_vertex
#ifndef GLEE_C_DEFINED_glColor4ubVertex2fSUN
#define GLEE_C_DEFINED_glColor4ubVertex2fSUN
void __stdcall GLee_Lazy_glColor4ubVertex2fSUN(GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y) {if (GLeeInit()) glColor4ubVertex2fSUN(r, g, b, a, x, y);}
GLEEPFNGLCOLOR4UBVERTEX2FSUNPROC GLeeFuncPtr_glColor4ubVertex2fSUN=GLee_Lazy_glColor4ubVertex2fSUN;
#endif
#ifndef GLEE_C_DEFINED_glColor4ubVertex2fvSUN
#define GLEE_C_DEFINED_glColor4ubVertex2fvSUN
void __stdcall GLee_Lazy_glColor4ubVertex2fvSUN(const GLubyte * c, const GLfloat * v) {if (GLeeInit()) glColor4ubVertex2fvSUN(c, v);}
GLEEPFNGLCOLOR4UBVERTEX2FVSUNPROC GLeeFuncPtr_glColor4ubVertex2fvSUN=GLee_Lazy_glColor4ubVertex2fvSUN;
#endif
#ifndef GLEE_C_DEFINED_glColor4ubVertex3fSUN
#define GLEE_C_DEFINED_glColor4ubVertex3fSUN
void __stdcall GLee_Lazy_glColor4ubVertex3fSUN(GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glColor4ubVertex3fSUN(r, g, b, a, x, y, z);}
GLEEPFNGLCOLOR4UBVERTEX3FSUNPROC GLeeFuncPtr_glColor4ubVertex3fSUN=GLee_Lazy_glColor4ubVertex3fSUN;
#endif
#ifndef GLEE_C_DEFINED_glColor4ubVertex3fvSUN
#define GLEE_C_DEFINED_glColor4ubVertex3fvSUN
void __stdcall GLee_Lazy_glColor4ubVertex3fvSUN(const GLubyte * c, const GLfloat * v) {if (GLeeInit()) glColor4ubVertex3fvSUN(c, v);}
GLEEPFNGLCOLOR4UBVERTEX3FVSUNPROC GLeeFuncPtr_glColor4ubVertex3fvSUN=GLee_Lazy_glColor4ubVertex3fvSUN;
#endif
#ifndef GLEE_C_DEFINED_glColor3fVertex3fSUN
#define GLEE_C_DEFINED_glColor3fVertex3fSUN
void __stdcall GLee_Lazy_glColor3fVertex3fSUN(GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glColor3fVertex3fSUN(r, g, b, x, y, z);}
GLEEPFNGLCOLOR3FVERTEX3FSUNPROC GLeeFuncPtr_glColor3fVertex3fSUN=GLee_Lazy_glColor3fVertex3fSUN;
#endif
#ifndef GLEE_C_DEFINED_glColor3fVertex3fvSUN
#define GLEE_C_DEFINED_glColor3fVertex3fvSUN
void __stdcall GLee_Lazy_glColor3fVertex3fvSUN(const GLfloat * c, const GLfloat * v) {if (GLeeInit()) glColor3fVertex3fvSUN(c, v);}
GLEEPFNGLCOLOR3FVERTEX3FVSUNPROC GLeeFuncPtr_glColor3fVertex3fvSUN=GLee_Lazy_glColor3fVertex3fvSUN;
#endif
#ifndef GLEE_C_DEFINED_glNormal3fVertex3fSUN
#define GLEE_C_DEFINED_glNormal3fVertex3fSUN
void __stdcall GLee_Lazy_glNormal3fVertex3fSUN(GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glNormal3fVertex3fSUN(nx, ny, nz, x, y, z);}
GLEEPFNGLNORMAL3FVERTEX3FSUNPROC GLeeFuncPtr_glNormal3fVertex3fSUN=GLee_Lazy_glNormal3fVertex3fSUN;
#endif
#ifndef GLEE_C_DEFINED_glNormal3fVertex3fvSUN
#define GLEE_C_DEFINED_glNormal3fVertex3fvSUN
void __stdcall GLee_Lazy_glNormal3fVertex3fvSUN(const GLfloat * n, const GLfloat * v) {if (GLeeInit()) glNormal3fVertex3fvSUN(n, v);}
GLEEPFNGLNORMAL3FVERTEX3FVSUNPROC GLeeFuncPtr_glNormal3fVertex3fvSUN=GLee_Lazy_glNormal3fVertex3fvSUN;
#endif
#ifndef GLEE_C_DEFINED_glColor4fNormal3fVertex3fSUN
#define GLEE_C_DEFINED_glColor4fNormal3fVertex3fSUN
void __stdcall GLee_Lazy_glColor4fNormal3fVertex3fSUN(GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glColor4fNormal3fVertex3fSUN(r, g, b, a, nx, ny, nz, x, y, z);}
GLEEPFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC GLeeFuncPtr_glColor4fNormal3fVertex3fSUN=GLee_Lazy_glColor4fNormal3fVertex3fSUN;
#endif
#ifndef GLEE_C_DEFINED_glColor4fNormal3fVertex3fvSUN
#define GLEE_C_DEFINED_glColor4fNormal3fVertex3fvSUN
void __stdcall GLee_Lazy_glColor4fNormal3fVertex3fvSUN(const GLfloat * c, const GLfloat * n, const GLfloat * v) {if (GLeeInit()) glColor4fNormal3fVertex3fvSUN(c, n, v);}
GLEEPFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC GLeeFuncPtr_glColor4fNormal3fVertex3fvSUN=GLee_Lazy_glColor4fNormal3fVertex3fvSUN;
#endif
#ifndef GLEE_C_DEFINED_glTexCoord2fVertex3fSUN
#define GLEE_C_DEFINED_glTexCoord2fVertex3fSUN
void __stdcall GLee_Lazy_glTexCoord2fVertex3fSUN(GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glTexCoord2fVertex3fSUN(s, t, x, y, z);}
GLEEPFNGLTEXCOORD2FVERTEX3FSUNPROC GLeeFuncPtr_glTexCoord2fVertex3fSUN=GLee_Lazy_glTexCoord2fVertex3fSUN;
#endif
#ifndef GLEE_C_DEFINED_glTexCoord2fVertex3fvSUN
#define GLEE_C_DEFINED_glTexCoord2fVertex3fvSUN
void __stdcall GLee_Lazy_glTexCoord2fVertex3fvSUN(const GLfloat * tc, const GLfloat * v) {if (GLeeInit()) glTexCoord2fVertex3fvSUN(tc, v);}
GLEEPFNGLTEXCOORD2FVERTEX3FVSUNPROC GLeeFuncPtr_glTexCoord2fVertex3fvSUN=GLee_Lazy_glTexCoord2fVertex3fvSUN;
#endif
#ifndef GLEE_C_DEFINED_glTexCoord4fVertex4fSUN
#define GLEE_C_DEFINED_glTexCoord4fVertex4fSUN
void __stdcall GLee_Lazy_glTexCoord4fVertex4fSUN(GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {if (GLeeInit()) glTexCoord4fVertex4fSUN(s, t, p, q, x, y, z, w);}
GLEEPFNGLTEXCOORD4FVERTEX4FSUNPROC GLeeFuncPtr_glTexCoord4fVertex4fSUN=GLee_Lazy_glTexCoord4fVertex4fSUN;
#endif
#ifndef GLEE_C_DEFINED_glTexCoord4fVertex4fvSUN
#define GLEE_C_DEFINED_glTexCoord4fVertex4fvSUN
void __stdcall GLee_Lazy_glTexCoord4fVertex4fvSUN(const GLfloat * tc, const GLfloat * v) {if (GLeeInit()) glTexCoord4fVertex4fvSUN(tc, v);}
GLEEPFNGLTEXCOORD4FVERTEX4FVSUNPROC GLeeFuncPtr_glTexCoord4fVertex4fvSUN=GLee_Lazy_glTexCoord4fVertex4fvSUN;
#endif
#ifndef GLEE_C_DEFINED_glTexCoord2fColor4ubVertex3fSUN
#define GLEE_C_DEFINED_glTexCoord2fColor4ubVertex3fSUN
void __stdcall GLee_Lazy_glTexCoord2fColor4ubVertex3fSUN(GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glTexCoord2fColor4ubVertex3fSUN(s, t, r, g, b, a, x, y, z);}
GLEEPFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC GLeeFuncPtr_glTexCoord2fColor4ubVertex3fSUN=GLee_Lazy_glTexCoord2fColor4ubVertex3fSUN;
#endif
#ifndef GLEE_C_DEFINED_glTexCoord2fColor4ubVertex3fvSUN
#define GLEE_C_DEFINED_glTexCoord2fColor4ubVertex3fvSUN
void __stdcall GLee_Lazy_glTexCoord2fColor4ubVertex3fvSUN(const GLfloat * tc, const GLubyte * c, const GLfloat * v) {if (GLeeInit()) glTexCoord2fColor4ubVertex3fvSUN(tc, c, v);}
GLEEPFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC GLeeFuncPtr_glTexCoord2fColor4ubVertex3fvSUN=GLee_Lazy_glTexCoord2fColor4ubVertex3fvSUN;
#endif
#ifndef GLEE_C_DEFINED_glTexCoord2fColor3fVertex3fSUN
#define GLEE_C_DEFINED_glTexCoord2fColor3fVertex3fSUN
void __stdcall GLee_Lazy_glTexCoord2fColor3fVertex3fSUN(GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glTexCoord2fColor3fVertex3fSUN(s, t, r, g, b, x, y, z);}
GLEEPFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC GLeeFuncPtr_glTexCoord2fColor3fVertex3fSUN=GLee_Lazy_glTexCoord2fColor3fVertex3fSUN;
#endif
#ifndef GLEE_C_DEFINED_glTexCoord2fColor3fVertex3fvSUN
#define GLEE_C_DEFINED_glTexCoord2fColor3fVertex3fvSUN
void __stdcall GLee_Lazy_glTexCoord2fColor3fVertex3fvSUN(const GLfloat * tc, const GLfloat * c, const GLfloat * v) {if (GLeeInit()) glTexCoord2fColor3fVertex3fvSUN(tc, c, v);}
GLEEPFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC GLeeFuncPtr_glTexCoord2fColor3fVertex3fvSUN=GLee_Lazy_glTexCoord2fColor3fVertex3fvSUN;
#endif
#ifndef GLEE_C_DEFINED_glTexCoord2fNormal3fVertex3fSUN
#define GLEE_C_DEFINED_glTexCoord2fNormal3fVertex3fSUN
void __stdcall GLee_Lazy_glTexCoord2fNormal3fVertex3fSUN(GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glTexCoord2fNormal3fVertex3fSUN(s, t, nx, ny, nz, x, y, z);}
GLEEPFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC GLeeFuncPtr_glTexCoord2fNormal3fVertex3fSUN=GLee_Lazy_glTexCoord2fNormal3fVertex3fSUN;
#endif
#ifndef GLEE_C_DEFINED_glTexCoord2fNormal3fVertex3fvSUN
#define GLEE_C_DEFINED_glTexCoord2fNormal3fVertex3fvSUN
void __stdcall GLee_Lazy_glTexCoord2fNormal3fVertex3fvSUN(const GLfloat * tc, const GLfloat * n, const GLfloat * v) {if (GLeeInit()) glTexCoord2fNormal3fVertex3fvSUN(tc, n, v);}
GLEEPFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC GLeeFuncPtr_glTexCoord2fNormal3fVertex3fvSUN=GLee_Lazy_glTexCoord2fNormal3fVertex3fvSUN;
#endif
#ifndef GLEE_C_DEFINED_glTexCoord2fColor4fNormal3fVertex3fSUN
#define GLEE_C_DEFINED_glTexCoord2fColor4fNormal3fVertex3fSUN
void __stdcall GLee_Lazy_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) {if (GLeeInit()) glTexCoord2fColor4fNormal3fVertex3fSUN(s, t, r, g, b, a, nx, ny, nz, x, y, z);}
GLEEPFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC GLeeFuncPtr_glTexCoord2fColor4fNormal3fVertex3fSUN=GLee_Lazy_glTexCoord2fColor4fNormal3fVertex3fSUN;
#endif
#ifndef GLEE_C_DEFINED_glTexCoord2fColor4fNormal3fVertex3fvSUN
#define GLEE_C_DEFINED_glTexCoord2fColor4fNormal3fVertex3fvSUN
void __stdcall GLee_Lazy_glTexCoord2fColor4fNormal3fVertex3fvSUN(const GLfloat * tc, const GLfloat * c, const GLfloat * n, const GLfloat * v) {if (GLeeInit()) glTexCoord2fColor4fNormal3fVertex3fvSUN(tc, c, n, v);}
GLEEPFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC GLeeFuncPtr_glTexCoord2fColor4fNormal3fVertex3fvSUN=GLee_Lazy_glTexCoord2fColor4fNormal3fVertex3fvSUN;
#endif
#ifndef GLEE_C_DEFINED_glTexCoord4fColor4fNormal3fVertex4fSUN
#define GLEE_C_DEFINED_glTexCoord4fColor4fNormal3fVertex4fSUN
void __stdcall GLee_Lazy_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) {if (GLeeInit()) glTexCoord4fColor4fNormal3fVertex4fSUN(s, t, p, q, r, g, b, a, nx, ny, nz, x, y, z, w);}
GLEEPFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC GLeeFuncPtr_glTexCoord4fColor4fNormal3fVertex4fSUN=GLee_Lazy_glTexCoord4fColor4fNormal3fVertex4fSUN;
#endif
#ifndef GLEE_C_DEFINED_glTexCoord4fColor4fNormal3fVertex4fvSUN
#define GLEE_C_DEFINED_glTexCoord4fColor4fNormal3fVertex4fvSUN
void __stdcall GLee_Lazy_glTexCoord4fColor4fNormal3fVertex4fvSUN(const GLfloat * tc, const GLfloat * c, const GLfloat * n, const GLfloat * v) {if (GLeeInit()) glTexCoord4fColor4fNormal3fVertex4fvSUN(tc, c, n, v);}
GLEEPFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC GLeeFuncPtr_glTexCoord4fColor4fNormal3fVertex4fvSUN=GLee_Lazy_glTexCoord4fColor4fNormal3fVertex4fvSUN;
#endif
#ifndef GLEE_C_DEFINED_glReplacementCodeuiVertex3fSUN
#define GLEE_C_DEFINED_glReplacementCodeuiVertex3fSUN
void __stdcall GLee_Lazy_glReplacementCodeuiVertex3fSUN(GLuint rc, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glReplacementCodeuiVertex3fSUN(rc, x, y, z);}
GLEEPFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC GLeeFuncPtr_glReplacementCodeuiVertex3fSUN=GLee_Lazy_glReplacementCodeuiVertex3fSUN;
#endif
#ifndef GLEE_C_DEFINED_glReplacementCodeuiVertex3fvSUN
#define GLEE_C_DEFINED_glReplacementCodeuiVertex3fvSUN
void __stdcall GLee_Lazy_glReplacementCodeuiVertex3fvSUN(const GLuint * rc, const GLfloat * v) {if (GLeeInit()) glReplacementCodeuiVertex3fvSUN(rc, v);}
GLEEPFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC GLeeFuncPtr_glReplacementCodeuiVertex3fvSUN=GLee_Lazy_glReplacementCodeuiVertex3fvSUN;
#endif
#ifndef GLEE_C_DEFINED_glReplacementCodeuiColor4ubVertex3fSUN
#define GLEE_C_DEFINED_glReplacementCodeuiColor4ubVertex3fSUN
void __stdcall GLee_Lazy_glReplacementCodeuiColor4ubVertex3fSUN(GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glReplacementCodeuiColor4ubVertex3fSUN(rc, r, g, b, a, x, y, z);}
GLEEPFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC GLeeFuncPtr_glReplacementCodeuiColor4ubVertex3fSUN=GLee_Lazy_glReplacementCodeuiColor4ubVertex3fSUN;
#endif
#ifndef GLEE_C_DEFINED_glReplacementCodeuiColor4ubVertex3fvSUN
#define GLEE_C_DEFINED_glReplacementCodeuiColor4ubVertex3fvSUN
void __stdcall GLee_Lazy_glReplacementCodeuiColor4ubVertex3fvSUN(const GLuint * rc, const GLubyte * c, const GLfloat * v) {if (GLeeInit()) glReplacementCodeuiColor4ubVertex3fvSUN(rc, c, v);}
GLEEPFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC GLeeFuncPtr_glReplacementCodeuiColor4ubVertex3fvSUN=GLee_Lazy_glReplacementCodeuiColor4ubVertex3fvSUN;
#endif
#ifndef GLEE_C_DEFINED_glReplacementCodeuiColor3fVertex3fSUN
#define GLEE_C_DEFINED_glReplacementCodeuiColor3fVertex3fSUN
void __stdcall GLee_Lazy_glReplacementCodeuiColor3fVertex3fSUN(GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glReplacementCodeuiColor3fVertex3fSUN(rc, r, g, b, x, y, z);}
GLEEPFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC GLeeFuncPtr_glReplacementCodeuiColor3fVertex3fSUN=GLee_Lazy_glReplacementCodeuiColor3fVertex3fSUN;
#endif
#ifndef GLEE_C_DEFINED_glReplacementCodeuiColor3fVertex3fvSUN
#define GLEE_C_DEFINED_glReplacementCodeuiColor3fVertex3fvSUN
void __stdcall GLee_Lazy_glReplacementCodeuiColor3fVertex3fvSUN(const GLuint * rc, const GLfloat * c, const GLfloat * v) {if (GLeeInit()) glReplacementCodeuiColor3fVertex3fvSUN(rc, c, v);}
GLEEPFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC GLeeFuncPtr_glReplacementCodeuiColor3fVertex3fvSUN=GLee_Lazy_glReplacementCodeuiColor3fVertex3fvSUN;
#endif
#ifndef GLEE_C_DEFINED_glReplacementCodeuiNormal3fVertex3fSUN
#define GLEE_C_DEFINED_glReplacementCodeuiNormal3fVertex3fSUN
void __stdcall GLee_Lazy_glReplacementCodeuiNormal3fVertex3fSUN(GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glReplacementCodeuiNormal3fVertex3fSUN(rc, nx, ny, nz, x, y, z);}
GLEEPFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC GLeeFuncPtr_glReplacementCodeuiNormal3fVertex3fSUN=GLee_Lazy_glReplacementCodeuiNormal3fVertex3fSUN;
#endif
#ifndef GLEE_C_DEFINED_glReplacementCodeuiNormal3fVertex3fvSUN
#define GLEE_C_DEFINED_glReplacementCodeuiNormal3fVertex3fvSUN
void __stdcall GLee_Lazy_glReplacementCodeuiNormal3fVertex3fvSUN(const GLuint * rc, const GLfloat * n, const GLfloat * v) {if (GLeeInit()) glReplacementCodeuiNormal3fVertex3fvSUN(rc, n, v);}
GLEEPFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC GLeeFuncPtr_glReplacementCodeuiNormal3fVertex3fvSUN=GLee_Lazy_glReplacementCodeuiNormal3fVertex3fvSUN;
#endif
#ifndef GLEE_C_DEFINED_glReplacementCodeuiColor4fNormal3fVertex3fSUN
#define GLEE_C_DEFINED_glReplacementCodeuiColor4fNormal3fVertex3fSUN
void __stdcall GLee_Lazy_glReplacementCodeuiColor4fNormal3fVertex3fSUN(GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glReplacementCodeuiColor4fNormal3fVertex3fSUN(rc, r, g, b, a, nx, ny, nz, x, y, z);}
GLEEPFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC GLeeFuncPtr_glReplacementCodeuiColor4fNormal3fVertex3fSUN=GLee_Lazy_glReplacementCodeuiColor4fNormal3fVertex3fSUN;
#endif
#ifndef GLEE_C_DEFINED_glReplacementCodeuiColor4fNormal3fVertex3fvSUN
#define GLEE_C_DEFINED_glReplacementCodeuiColor4fNormal3fVertex3fvSUN
void __stdcall GLee_Lazy_glReplacementCodeuiColor4fNormal3fVertex3fvSUN(const GLuint * rc, const GLfloat * c, const GLfloat * n, const GLfloat * v) {if (GLeeInit()) glReplacementCodeuiColor4fNormal3fVertex3fvSUN(rc, c, n, v);}
GLEEPFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC GLeeFuncPtr_glReplacementCodeuiColor4fNormal3fVertex3fvSUN=GLee_Lazy_glReplacementCodeuiColor4fNormal3fVertex3fvSUN;
#endif
#ifndef GLEE_C_DEFINED_glReplacementCodeuiTexCoord2fVertex3fSUN
#define GLEE_C_DEFINED_glReplacementCodeuiTexCoord2fVertex3fSUN
void __stdcall GLee_Lazy_glReplacementCodeuiTexCoord2fVertex3fSUN(GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glReplacementCodeuiTexCoord2fVertex3fSUN(rc, s, t, x, y, z);}
GLEEPFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC GLeeFuncPtr_glReplacementCodeuiTexCoord2fVertex3fSUN=GLee_Lazy_glReplacementCodeuiTexCoord2fVertex3fSUN;
#endif
#ifndef GLEE_C_DEFINED_glReplacementCodeuiTexCoord2fVertex3fvSUN
#define GLEE_C_DEFINED_glReplacementCodeuiTexCoord2fVertex3fvSUN
void __stdcall GLee_Lazy_glReplacementCodeuiTexCoord2fVertex3fvSUN(const GLuint * rc, const GLfloat * tc, const GLfloat * v) {if (GLeeInit()) glReplacementCodeuiTexCoord2fVertex3fvSUN(rc, tc, v);}
GLEEPFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC GLeeFuncPtr_glReplacementCodeuiTexCoord2fVertex3fvSUN=GLee_Lazy_glReplacementCodeuiTexCoord2fVertex3fvSUN;
#endif
#ifndef GLEE_C_DEFINED_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN
#define GLEE_C_DEFINED_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN
void __stdcall GLee_Lazy_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(rc, s, t, nx, ny, nz, x, y, z);}
GLEEPFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC GLeeFuncPtr_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN=GLee_Lazy_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN;
#endif
#ifndef GLEE_C_DEFINED_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN
#define GLEE_C_DEFINED_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN
void __stdcall GLee_Lazy_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(const GLuint * rc, const GLfloat * tc, const GLfloat * n, const GLfloat * v) {if (GLeeInit()) glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(rc, tc, n, v);}
GLEEPFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC GLeeFuncPtr_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN=GLee_Lazy_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN;
#endif
#ifndef GLEE_C_DEFINED_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN
#define GLEE_C_DEFINED_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN
void __stdcall GLee_Lazy_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) {if (GLeeInit()) glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(rc, s, t, r, g, b, a, nx, ny, nz, x, y, z);}
GLEEPFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC GLeeFuncPtr_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN=GLee_Lazy_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN;
#endif
#ifndef GLEE_C_DEFINED_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN
#define GLEE_C_DEFINED_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN
void __stdcall GLee_Lazy_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(const GLuint * rc, const GLfloat * tc, const GLfloat * c, const GLfloat * n, const GLfloat * v) {if (GLeeInit()) glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(rc, tc, c, n, v);}
GLEEPFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC GLeeFuncPtr_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN=GLee_Lazy_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN;
#endif
#endif
/* GL_EXT_blend_func_separate */
#ifdef __GLEE_GL_EXT_blend_func_separate
#ifndef GLEE_C_DEFINED_glBlendFuncSeparateEXT
#define GLEE_C_DEFINED_glBlendFuncSeparateEXT
void __stdcall GLee_Lazy_glBlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) {if (GLeeInit()) glBlendFuncSeparateEXT(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);}
GLEEPFNGLBLENDFUNCSEPARATEEXTPROC GLeeFuncPtr_glBlendFuncSeparateEXT=GLee_Lazy_glBlendFuncSeparateEXT;
#endif
#endif
/* GL_INGR_color_clamp */
#ifdef __GLEE_GL_INGR_color_clamp
#endif
/* GL_INGR_interlace_read */
#ifdef __GLEE_GL_INGR_interlace_read
#endif
/* GL_EXT_stencil_wrap */
#ifdef __GLEE_GL_EXT_stencil_wrap
#endif
/* GL_EXT_422_pixels */
#ifdef __GLEE_GL_EXT_422_pixels
#endif
/* GL_NV_texgen_reflection */
#ifdef __GLEE_GL_NV_texgen_reflection
#endif
/* GL_EXT_texture_cube_map */
#ifdef __GLEE_GL_EXT_texture_cube_map
#endif
/* GL_SUN_convolution_border_modes */
#ifdef __GLEE_GL_SUN_convolution_border_modes
#endif
/* GL_EXT_texture_env_add */
#ifdef __GLEE_GL_EXT_texture_env_add
#endif
/* GL_EXT_texture_lod_bias */
#ifdef __GLEE_GL_EXT_texture_lod_bias
#endif
/* GL_EXT_texture_filter_anisotropic */
#ifdef __GLEE_GL_EXT_texture_filter_anisotropic
#endif
/* GL_EXT_vertex_weighting */
#ifdef __GLEE_GL_EXT_vertex_weighting
#ifndef GLEE_C_DEFINED_glVertexWeightfEXT
#define GLEE_C_DEFINED_glVertexWeightfEXT
void __stdcall GLee_Lazy_glVertexWeightfEXT(GLfloat weight) {if (GLeeInit()) glVertexWeightfEXT(weight);}
GLEEPFNGLVERTEXWEIGHTFEXTPROC GLeeFuncPtr_glVertexWeightfEXT=GLee_Lazy_glVertexWeightfEXT;
#endif
#ifndef GLEE_C_DEFINED_glVertexWeightfvEXT
#define GLEE_C_DEFINED_glVertexWeightfvEXT
void __stdcall GLee_Lazy_glVertexWeightfvEXT(const GLfloat * weight) {if (GLeeInit()) glVertexWeightfvEXT(weight);}
GLEEPFNGLVERTEXWEIGHTFVEXTPROC GLeeFuncPtr_glVertexWeightfvEXT=GLee_Lazy_glVertexWeightfvEXT;
#endif
#ifndef GLEE_C_DEFINED_glVertexWeightPointerEXT
#define GLEE_C_DEFINED_glVertexWeightPointerEXT
void __stdcall GLee_Lazy_glVertexWeightPointerEXT(GLsizei size, GLenum type, GLsizei stride, const GLvoid * pointer) {if (GLeeInit()) glVertexWeightPointerEXT(size, type, stride, pointer);}
GLEEPFNGLVERTEXWEIGHTPOINTEREXTPROC GLeeFuncPtr_glVertexWeightPointerEXT=GLee_Lazy_glVertexWeightPointerEXT;
#endif
#endif
/* GL_NV_light_max_exponent */
#ifdef __GLEE_GL_NV_light_max_exponent
#endif
/* GL_NV_vertex_array_range */
#ifdef __GLEE_GL_NV_vertex_array_range
#ifndef GLEE_C_DEFINED_glFlushVertexArrayRangeNV
#define GLEE_C_DEFINED_glFlushVertexArrayRangeNV
void __stdcall GLee_Lazy_glFlushVertexArrayRangeNV(void) {if (GLeeInit()) glFlushVertexArrayRangeNV();}
GLEEPFNGLFLUSHVERTEXARRAYRANGENVPROC GLeeFuncPtr_glFlushVertexArrayRangeNV=GLee_Lazy_glFlushVertexArrayRangeNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexArrayRangeNV
#define GLEE_C_DEFINED_glVertexArrayRangeNV
void __stdcall GLee_Lazy_glVertexArrayRangeNV(GLsizei length, const GLvoid * pointer) {if (GLeeInit()) glVertexArrayRangeNV(length, pointer);}
GLEEPFNGLVERTEXARRAYRANGENVPROC GLeeFuncPtr_glVertexArrayRangeNV=GLee_Lazy_glVertexArrayRangeNV;
#endif
#endif
/* GL_NV_register_combiners */
#ifdef __GLEE_GL_NV_register_combiners
#ifndef GLEE_C_DEFINED_glCombinerParameterfvNV
#define GLEE_C_DEFINED_glCombinerParameterfvNV
void __stdcall GLee_Lazy_glCombinerParameterfvNV(GLenum pname, const GLfloat * params) {if (GLeeInit()) glCombinerParameterfvNV(pname, params);}
GLEEPFNGLCOMBINERPARAMETERFVNVPROC GLeeFuncPtr_glCombinerParameterfvNV=GLee_Lazy_glCombinerParameterfvNV;
#endif
#ifndef GLEE_C_DEFINED_glCombinerParameterfNV
#define GLEE_C_DEFINED_glCombinerParameterfNV
void __stdcall GLee_Lazy_glCombinerParameterfNV(GLenum pname, GLfloat param) {if (GLeeInit()) glCombinerParameterfNV(pname, param);}
GLEEPFNGLCOMBINERPARAMETERFNVPROC GLeeFuncPtr_glCombinerParameterfNV=GLee_Lazy_glCombinerParameterfNV;
#endif
#ifndef GLEE_C_DEFINED_glCombinerParameterivNV
#define GLEE_C_DEFINED_glCombinerParameterivNV
void __stdcall GLee_Lazy_glCombinerParameterivNV(GLenum pname, const GLint * params) {if (GLeeInit()) glCombinerParameterivNV(pname, params);}
GLEEPFNGLCOMBINERPARAMETERIVNVPROC GLeeFuncPtr_glCombinerParameterivNV=GLee_Lazy_glCombinerParameterivNV;
#endif
#ifndef GLEE_C_DEFINED_glCombinerParameteriNV
#define GLEE_C_DEFINED_glCombinerParameteriNV
void __stdcall GLee_Lazy_glCombinerParameteriNV(GLenum pname, GLint param) {if (GLeeInit()) glCombinerParameteriNV(pname, param);}
GLEEPFNGLCOMBINERPARAMETERINVPROC GLeeFuncPtr_glCombinerParameteriNV=GLee_Lazy_glCombinerParameteriNV;
#endif
#ifndef GLEE_C_DEFINED_glCombinerInputNV
#define GLEE_C_DEFINED_glCombinerInputNV
void __stdcall GLee_Lazy_glCombinerInputNV(GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage) {if (GLeeInit()) glCombinerInputNV(stage, portion, variable, input, mapping, componentUsage);}
GLEEPFNGLCOMBINERINPUTNVPROC GLeeFuncPtr_glCombinerInputNV=GLee_Lazy_glCombinerInputNV;
#endif
#ifndef GLEE_C_DEFINED_glCombinerOutputNV
#define GLEE_C_DEFINED_glCombinerOutputNV
void __stdcall GLee_Lazy_glCombinerOutputNV(GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum) {if (GLeeInit()) glCombinerOutputNV(stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum);}
GLEEPFNGLCOMBINEROUTPUTNVPROC GLeeFuncPtr_glCombinerOutputNV=GLee_Lazy_glCombinerOutputNV;
#endif
#ifndef GLEE_C_DEFINED_glFinalCombinerInputNV
#define GLEE_C_DEFINED_glFinalCombinerInputNV
void __stdcall GLee_Lazy_glFinalCombinerInputNV(GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage) {if (GLeeInit()) glFinalCombinerInputNV(variable, input, mapping, componentUsage);}
GLEEPFNGLFINALCOMBINERINPUTNVPROC GLeeFuncPtr_glFinalCombinerInputNV=GLee_Lazy_glFinalCombinerInputNV;
#endif
#ifndef GLEE_C_DEFINED_glGetCombinerInputParameterfvNV
#define GLEE_C_DEFINED_glGetCombinerInputParameterfvNV
void __stdcall GLee_Lazy_glGetCombinerInputParameterfvNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetCombinerInputParameterfvNV(stage, portion, variable, pname, params);}
GLEEPFNGLGETCOMBINERINPUTPARAMETERFVNVPROC GLeeFuncPtr_glGetCombinerInputParameterfvNV=GLee_Lazy_glGetCombinerInputParameterfvNV;
#endif
#ifndef GLEE_C_DEFINED_glGetCombinerInputParameterivNV
#define GLEE_C_DEFINED_glGetCombinerInputParameterivNV
void __stdcall GLee_Lazy_glGetCombinerInputParameterivNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint * params) {if (GLeeInit()) glGetCombinerInputParameterivNV(stage, portion, variable, pname, params);}
GLEEPFNGLGETCOMBINERINPUTPARAMETERIVNVPROC GLeeFuncPtr_glGetCombinerInputParameterivNV=GLee_Lazy_glGetCombinerInputParameterivNV;
#endif
#ifndef GLEE_C_DEFINED_glGetCombinerOutputParameterfvNV
#define GLEE_C_DEFINED_glGetCombinerOutputParameterfvNV
void __stdcall GLee_Lazy_glGetCombinerOutputParameterfvNV(GLenum stage, GLenum portion, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetCombinerOutputParameterfvNV(stage, portion, pname, params);}
GLEEPFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC GLeeFuncPtr_glGetCombinerOutputParameterfvNV=GLee_Lazy_glGetCombinerOutputParameterfvNV;
#endif
#ifndef GLEE_C_DEFINED_glGetCombinerOutputParameterivNV
#define GLEE_C_DEFINED_glGetCombinerOutputParameterivNV
void __stdcall GLee_Lazy_glGetCombinerOutputParameterivNV(GLenum stage, GLenum portion, GLenum pname, GLint * params) {if (GLeeInit()) glGetCombinerOutputParameterivNV(stage, portion, pname, params);}
GLEEPFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC GLeeFuncPtr_glGetCombinerOutputParameterivNV=GLee_Lazy_glGetCombinerOutputParameterivNV;
#endif
#ifndef GLEE_C_DEFINED_glGetFinalCombinerInputParameterfvNV
#define GLEE_C_DEFINED_glGetFinalCombinerInputParameterfvNV
void __stdcall GLee_Lazy_glGetFinalCombinerInputParameterfvNV(GLenum variable, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetFinalCombinerInputParameterfvNV(variable, pname, params);}
GLEEPFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC GLeeFuncPtr_glGetFinalCombinerInputParameterfvNV=GLee_Lazy_glGetFinalCombinerInputParameterfvNV;
#endif
#ifndef GLEE_C_DEFINED_glGetFinalCombinerInputParameterivNV
#define GLEE_C_DEFINED_glGetFinalCombinerInputParameterivNV
void __stdcall GLee_Lazy_glGetFinalCombinerInputParameterivNV(GLenum variable, GLenum pname, GLint * params) {if (GLeeInit()) glGetFinalCombinerInputParameterivNV(variable, pname, params);}
GLEEPFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC GLeeFuncPtr_glGetFinalCombinerInputParameterivNV=GLee_Lazy_glGetFinalCombinerInputParameterivNV;
#endif
#endif
/* GL_NV_fog_distance */
#ifdef __GLEE_GL_NV_fog_distance
#endif
/* GL_NV_texgen_emboss */
#ifdef __GLEE_GL_NV_texgen_emboss
#endif
/* GL_NV_blend_square */
#ifdef __GLEE_GL_NV_blend_square
#endif
/* GL_NV_texture_env_combine4 */
#ifdef __GLEE_GL_NV_texture_env_combine4
#endif
/* GL_MESA_resize_buffers */
#ifdef __GLEE_GL_MESA_resize_buffers
#ifndef GLEE_C_DEFINED_glResizeBuffersMESA
#define GLEE_C_DEFINED_glResizeBuffersMESA
void __stdcall GLee_Lazy_glResizeBuffersMESA(void) {if (GLeeInit()) glResizeBuffersMESA();}
GLEEPFNGLRESIZEBUFFERSMESAPROC GLeeFuncPtr_glResizeBuffersMESA=GLee_Lazy_glResizeBuffersMESA;
#endif
#endif
/* GL_MESA_window_pos */
#ifdef __GLEE_GL_MESA_window_pos
#ifndef GLEE_C_DEFINED_glWindowPos2dMESA
#define GLEE_C_DEFINED_glWindowPos2dMESA
void __stdcall GLee_Lazy_glWindowPos2dMESA(GLdouble x, GLdouble y) {if (GLeeInit()) glWindowPos2dMESA(x, y);}
GLEEPFNGLWINDOWPOS2DMESAPROC GLeeFuncPtr_glWindowPos2dMESA=GLee_Lazy_glWindowPos2dMESA;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2dvMESA
#define GLEE_C_DEFINED_glWindowPos2dvMESA
void __stdcall GLee_Lazy_glWindowPos2dvMESA(const GLdouble * v) {if (GLeeInit()) glWindowPos2dvMESA(v);}
GLEEPFNGLWINDOWPOS2DVMESAPROC GLeeFuncPtr_glWindowPos2dvMESA=GLee_Lazy_glWindowPos2dvMESA;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2fMESA
#define GLEE_C_DEFINED_glWindowPos2fMESA
void __stdcall GLee_Lazy_glWindowPos2fMESA(GLfloat x, GLfloat y) {if (GLeeInit()) glWindowPos2fMESA(x, y);}
GLEEPFNGLWINDOWPOS2FMESAPROC GLeeFuncPtr_glWindowPos2fMESA=GLee_Lazy_glWindowPos2fMESA;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2fvMESA
#define GLEE_C_DEFINED_glWindowPos2fvMESA
void __stdcall GLee_Lazy_glWindowPos2fvMESA(const GLfloat * v) {if (GLeeInit()) glWindowPos2fvMESA(v);}
GLEEPFNGLWINDOWPOS2FVMESAPROC GLeeFuncPtr_glWindowPos2fvMESA=GLee_Lazy_glWindowPos2fvMESA;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2iMESA
#define GLEE_C_DEFINED_glWindowPos2iMESA
void __stdcall GLee_Lazy_glWindowPos2iMESA(GLint x, GLint y) {if (GLeeInit()) glWindowPos2iMESA(x, y);}
GLEEPFNGLWINDOWPOS2IMESAPROC GLeeFuncPtr_glWindowPos2iMESA=GLee_Lazy_glWindowPos2iMESA;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2ivMESA
#define GLEE_C_DEFINED_glWindowPos2ivMESA
void __stdcall GLee_Lazy_glWindowPos2ivMESA(const GLint * v) {if (GLeeInit()) glWindowPos2ivMESA(v);}
GLEEPFNGLWINDOWPOS2IVMESAPROC GLeeFuncPtr_glWindowPos2ivMESA=GLee_Lazy_glWindowPos2ivMESA;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2sMESA
#define GLEE_C_DEFINED_glWindowPos2sMESA
void __stdcall GLee_Lazy_glWindowPos2sMESA(GLshort x, GLshort y) {if (GLeeInit()) glWindowPos2sMESA(x, y);}
GLEEPFNGLWINDOWPOS2SMESAPROC GLeeFuncPtr_glWindowPos2sMESA=GLee_Lazy_glWindowPos2sMESA;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos2svMESA
#define GLEE_C_DEFINED_glWindowPos2svMESA
void __stdcall GLee_Lazy_glWindowPos2svMESA(const GLshort * v) {if (GLeeInit()) glWindowPos2svMESA(v);}
GLEEPFNGLWINDOWPOS2SVMESAPROC GLeeFuncPtr_glWindowPos2svMESA=GLee_Lazy_glWindowPos2svMESA;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3dMESA
#define GLEE_C_DEFINED_glWindowPos3dMESA
void __stdcall GLee_Lazy_glWindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z) {if (GLeeInit()) glWindowPos3dMESA(x, y, z);}
GLEEPFNGLWINDOWPOS3DMESAPROC GLeeFuncPtr_glWindowPos3dMESA=GLee_Lazy_glWindowPos3dMESA;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3dvMESA
#define GLEE_C_DEFINED_glWindowPos3dvMESA
void __stdcall GLee_Lazy_glWindowPos3dvMESA(const GLdouble * v) {if (GLeeInit()) glWindowPos3dvMESA(v);}
GLEEPFNGLWINDOWPOS3DVMESAPROC GLeeFuncPtr_glWindowPos3dvMESA=GLee_Lazy_glWindowPos3dvMESA;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3fMESA
#define GLEE_C_DEFINED_glWindowPos3fMESA
void __stdcall GLee_Lazy_glWindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glWindowPos3fMESA(x, y, z);}
GLEEPFNGLWINDOWPOS3FMESAPROC GLeeFuncPtr_glWindowPos3fMESA=GLee_Lazy_glWindowPos3fMESA;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3fvMESA
#define GLEE_C_DEFINED_glWindowPos3fvMESA
void __stdcall GLee_Lazy_glWindowPos3fvMESA(const GLfloat * v) {if (GLeeInit()) glWindowPos3fvMESA(v);}
GLEEPFNGLWINDOWPOS3FVMESAPROC GLeeFuncPtr_glWindowPos3fvMESA=GLee_Lazy_glWindowPos3fvMESA;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3iMESA
#define GLEE_C_DEFINED_glWindowPos3iMESA
void __stdcall GLee_Lazy_glWindowPos3iMESA(GLint x, GLint y, GLint z) {if (GLeeInit()) glWindowPos3iMESA(x, y, z);}
GLEEPFNGLWINDOWPOS3IMESAPROC GLeeFuncPtr_glWindowPos3iMESA=GLee_Lazy_glWindowPos3iMESA;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3ivMESA
#define GLEE_C_DEFINED_glWindowPos3ivMESA
void __stdcall GLee_Lazy_glWindowPos3ivMESA(const GLint * v) {if (GLeeInit()) glWindowPos3ivMESA(v);}
GLEEPFNGLWINDOWPOS3IVMESAPROC GLeeFuncPtr_glWindowPos3ivMESA=GLee_Lazy_glWindowPos3ivMESA;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3sMESA
#define GLEE_C_DEFINED_glWindowPos3sMESA
void __stdcall GLee_Lazy_glWindowPos3sMESA(GLshort x, GLshort y, GLshort z) {if (GLeeInit()) glWindowPos3sMESA(x, y, z);}
GLEEPFNGLWINDOWPOS3SMESAPROC GLeeFuncPtr_glWindowPos3sMESA=GLee_Lazy_glWindowPos3sMESA;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos3svMESA
#define GLEE_C_DEFINED_glWindowPos3svMESA
void __stdcall GLee_Lazy_glWindowPos3svMESA(const GLshort * v) {if (GLeeInit()) glWindowPos3svMESA(v);}
GLEEPFNGLWINDOWPOS3SVMESAPROC GLeeFuncPtr_glWindowPos3svMESA=GLee_Lazy_glWindowPos3svMESA;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos4dMESA
#define GLEE_C_DEFINED_glWindowPos4dMESA
void __stdcall GLee_Lazy_glWindowPos4dMESA(GLdouble x, GLdouble y, GLdouble z, GLdouble w) {if (GLeeInit()) glWindowPos4dMESA(x, y, z, w);}
GLEEPFNGLWINDOWPOS4DMESAPROC GLeeFuncPtr_glWindowPos4dMESA=GLee_Lazy_glWindowPos4dMESA;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos4dvMESA
#define GLEE_C_DEFINED_glWindowPos4dvMESA
void __stdcall GLee_Lazy_glWindowPos4dvMESA(const GLdouble * v) {if (GLeeInit()) glWindowPos4dvMESA(v);}
GLEEPFNGLWINDOWPOS4DVMESAPROC GLeeFuncPtr_glWindowPos4dvMESA=GLee_Lazy_glWindowPos4dvMESA;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos4fMESA
#define GLEE_C_DEFINED_glWindowPos4fMESA
void __stdcall GLee_Lazy_glWindowPos4fMESA(GLfloat x, GLfloat y, GLfloat z, GLfloat w) {if (GLeeInit()) glWindowPos4fMESA(x, y, z, w);}
GLEEPFNGLWINDOWPOS4FMESAPROC GLeeFuncPtr_glWindowPos4fMESA=GLee_Lazy_glWindowPos4fMESA;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos4fvMESA
#define GLEE_C_DEFINED_glWindowPos4fvMESA
void __stdcall GLee_Lazy_glWindowPos4fvMESA(const GLfloat * v) {if (GLeeInit()) glWindowPos4fvMESA(v);}
GLEEPFNGLWINDOWPOS4FVMESAPROC GLeeFuncPtr_glWindowPos4fvMESA=GLee_Lazy_glWindowPos4fvMESA;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos4iMESA
#define GLEE_C_DEFINED_glWindowPos4iMESA
void __stdcall GLee_Lazy_glWindowPos4iMESA(GLint x, GLint y, GLint z, GLint w) {if (GLeeInit()) glWindowPos4iMESA(x, y, z, w);}
GLEEPFNGLWINDOWPOS4IMESAPROC GLeeFuncPtr_glWindowPos4iMESA=GLee_Lazy_glWindowPos4iMESA;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos4ivMESA
#define GLEE_C_DEFINED_glWindowPos4ivMESA
void __stdcall GLee_Lazy_glWindowPos4ivMESA(const GLint * v) {if (GLeeInit()) glWindowPos4ivMESA(v);}
GLEEPFNGLWINDOWPOS4IVMESAPROC GLeeFuncPtr_glWindowPos4ivMESA=GLee_Lazy_glWindowPos4ivMESA;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos4sMESA
#define GLEE_C_DEFINED_glWindowPos4sMESA
void __stdcall GLee_Lazy_glWindowPos4sMESA(GLshort x, GLshort y, GLshort z, GLshort w) {if (GLeeInit()) glWindowPos4sMESA(x, y, z, w);}
GLEEPFNGLWINDOWPOS4SMESAPROC GLeeFuncPtr_glWindowPos4sMESA=GLee_Lazy_glWindowPos4sMESA;
#endif
#ifndef GLEE_C_DEFINED_glWindowPos4svMESA
#define GLEE_C_DEFINED_glWindowPos4svMESA
void __stdcall GLee_Lazy_glWindowPos4svMESA(const GLshort * v) {if (GLeeInit()) glWindowPos4svMESA(v);}
GLEEPFNGLWINDOWPOS4SVMESAPROC GLeeFuncPtr_glWindowPos4svMESA=GLee_Lazy_glWindowPos4svMESA;
#endif
#endif
/* GL_EXT_texture_compression_s3tc */
#ifdef __GLEE_GL_EXT_texture_compression_s3tc
#endif
/* GL_IBM_cull_vertex */
#ifdef __GLEE_GL_IBM_cull_vertex
#endif
/* GL_IBM_multimode_draw_arrays */
#ifdef __GLEE_GL_IBM_multimode_draw_arrays
#ifndef GLEE_C_DEFINED_glMultiModeDrawArraysIBM
#define GLEE_C_DEFINED_glMultiModeDrawArraysIBM
void __stdcall GLee_Lazy_glMultiModeDrawArraysIBM(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride) {if (GLeeInit()) glMultiModeDrawArraysIBM(mode, first, count, primcount, modestride);}
GLEEPFNGLMULTIMODEDRAWARRAYSIBMPROC GLeeFuncPtr_glMultiModeDrawArraysIBM=GLee_Lazy_glMultiModeDrawArraysIBM;
#endif
#ifndef GLEE_C_DEFINED_glMultiModeDrawElementsIBM
#define GLEE_C_DEFINED_glMultiModeDrawElementsIBM
void __stdcall GLee_Lazy_glMultiModeDrawElementsIBM(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid* const * indices, GLsizei primcount, GLint modestride) {if (GLeeInit()) glMultiModeDrawElementsIBM(mode, count, type, indices, primcount, modestride);}
GLEEPFNGLMULTIMODEDRAWELEMENTSIBMPROC GLeeFuncPtr_glMultiModeDrawElementsIBM=GLee_Lazy_glMultiModeDrawElementsIBM;
#endif
#endif
/* GL_IBM_vertex_array_lists */
#ifdef __GLEE_GL_IBM_vertex_array_lists
#ifndef GLEE_C_DEFINED_glColorPointerListIBM
#define GLEE_C_DEFINED_glColorPointerListIBM
void __stdcall GLee_Lazy_glColorPointerListIBM(GLint size, GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride) {if (GLeeInit()) glColorPointerListIBM(size, type, stride, pointer, ptrstride);}
GLEEPFNGLCOLORPOINTERLISTIBMPROC GLeeFuncPtr_glColorPointerListIBM=GLee_Lazy_glColorPointerListIBM;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColorPointerListIBM
#define GLEE_C_DEFINED_glSecondaryColorPointerListIBM
void __stdcall GLee_Lazy_glSecondaryColorPointerListIBM(GLint size, GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride) {if (GLeeInit()) glSecondaryColorPointerListIBM(size, type, stride, pointer, ptrstride);}
GLEEPFNGLSECONDARYCOLORPOINTERLISTIBMPROC GLeeFuncPtr_glSecondaryColorPointerListIBM=GLee_Lazy_glSecondaryColorPointerListIBM;
#endif
#ifndef GLEE_C_DEFINED_glEdgeFlagPointerListIBM
#define GLEE_C_DEFINED_glEdgeFlagPointerListIBM
void __stdcall GLee_Lazy_glEdgeFlagPointerListIBM(GLint stride, const GLboolean* * pointer, GLint ptrstride) {if (GLeeInit()) glEdgeFlagPointerListIBM(stride, pointer, ptrstride);}
GLEEPFNGLEDGEFLAGPOINTERLISTIBMPROC GLeeFuncPtr_glEdgeFlagPointerListIBM=GLee_Lazy_glEdgeFlagPointerListIBM;
#endif
#ifndef GLEE_C_DEFINED_glFogCoordPointerListIBM
#define GLEE_C_DEFINED_glFogCoordPointerListIBM
void __stdcall GLee_Lazy_glFogCoordPointerListIBM(GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride) {if (GLeeInit()) glFogCoordPointerListIBM(type, stride, pointer, ptrstride);}
GLEEPFNGLFOGCOORDPOINTERLISTIBMPROC GLeeFuncPtr_glFogCoordPointerListIBM=GLee_Lazy_glFogCoordPointerListIBM;
#endif
#ifndef GLEE_C_DEFINED_glIndexPointerListIBM
#define GLEE_C_DEFINED_glIndexPointerListIBM
void __stdcall GLee_Lazy_glIndexPointerListIBM(GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride) {if (GLeeInit()) glIndexPointerListIBM(type, stride, pointer, ptrstride);}
GLEEPFNGLINDEXPOINTERLISTIBMPROC GLeeFuncPtr_glIndexPointerListIBM=GLee_Lazy_glIndexPointerListIBM;
#endif
#ifndef GLEE_C_DEFINED_glNormalPointerListIBM
#define GLEE_C_DEFINED_glNormalPointerListIBM
void __stdcall GLee_Lazy_glNormalPointerListIBM(GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride) {if (GLeeInit()) glNormalPointerListIBM(type, stride, pointer, ptrstride);}
GLEEPFNGLNORMALPOINTERLISTIBMPROC GLeeFuncPtr_glNormalPointerListIBM=GLee_Lazy_glNormalPointerListIBM;
#endif
#ifndef GLEE_C_DEFINED_glTexCoordPointerListIBM
#define GLEE_C_DEFINED_glTexCoordPointerListIBM
void __stdcall GLee_Lazy_glTexCoordPointerListIBM(GLint size, GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride) {if (GLeeInit()) glTexCoordPointerListIBM(size, type, stride, pointer, ptrstride);}
GLEEPFNGLTEXCOORDPOINTERLISTIBMPROC GLeeFuncPtr_glTexCoordPointerListIBM=GLee_Lazy_glTexCoordPointerListIBM;
#endif
#ifndef GLEE_C_DEFINED_glVertexPointerListIBM
#define GLEE_C_DEFINED_glVertexPointerListIBM
void __stdcall GLee_Lazy_glVertexPointerListIBM(GLint size, GLenum type, GLint stride, const GLvoid* * pointer, GLint ptrstride) {if (GLeeInit()) glVertexPointerListIBM(size, type, stride, pointer, ptrstride);}
GLEEPFNGLVERTEXPOINTERLISTIBMPROC GLeeFuncPtr_glVertexPointerListIBM=GLee_Lazy_glVertexPointerListIBM;
#endif
#endif
/* GL_SGIX_subsample */
#ifdef __GLEE_GL_SGIX_subsample
#endif
/* GL_SGIX_ycrcb_subsample */
#ifdef __GLEE_GL_SGIX_ycrcb_subsample
#endif
/* GL_SGIX_ycrcba */
#ifdef __GLEE_GL_SGIX_ycrcba
#endif
/* GL_SGI_depth_pass_instrument */
#ifdef __GLEE_GL_SGI_depth_pass_instrument
#endif
/* GL_3DFX_texture_compression_FXT1 */
#ifdef __GLEE_GL_3DFX_texture_compression_FXT1
#endif
/* GL_3DFX_multisample */
#ifdef __GLEE_GL_3DFX_multisample
#endif
/* GL_3DFX_tbuffer */
#ifdef __GLEE_GL_3DFX_tbuffer
#ifndef GLEE_C_DEFINED_glTbufferMask3DFX
#define GLEE_C_DEFINED_glTbufferMask3DFX
void __stdcall GLee_Lazy_glTbufferMask3DFX(GLuint mask) {if (GLeeInit()) glTbufferMask3DFX(mask);}
GLEEPFNGLTBUFFERMASK3DFXPROC GLeeFuncPtr_glTbufferMask3DFX=GLee_Lazy_glTbufferMask3DFX;
#endif
#endif
/* GL_EXT_multisample */
#ifdef __GLEE_GL_EXT_multisample
#ifndef GLEE_C_DEFINED_glSampleMaskEXT
#define GLEE_C_DEFINED_glSampleMaskEXT
void __stdcall GLee_Lazy_glSampleMaskEXT(GLclampf value, GLboolean invert) {if (GLeeInit()) glSampleMaskEXT(value, invert);}
GLEEPFNGLSAMPLEMASKEXTPROC GLeeFuncPtr_glSampleMaskEXT=GLee_Lazy_glSampleMaskEXT;
#endif
#ifndef GLEE_C_DEFINED_glSamplePatternEXT
#define GLEE_C_DEFINED_glSamplePatternEXT
void __stdcall GLee_Lazy_glSamplePatternEXT(GLenum pattern) {if (GLeeInit()) glSamplePatternEXT(pattern);}
GLEEPFNGLSAMPLEPATTERNEXTPROC GLeeFuncPtr_glSamplePatternEXT=GLee_Lazy_glSamplePatternEXT;
#endif
#endif
/* GL_SGIX_vertex_preclip */
#ifdef __GLEE_GL_SGIX_vertex_preclip
#endif
/* GL_SGIX_convolution_accuracy */
#ifdef __GLEE_GL_SGIX_convolution_accuracy
#endif
/* GL_SGIX_resample */
#ifdef __GLEE_GL_SGIX_resample
#endif
/* GL_SGIS_point_line_texgen */
#ifdef __GLEE_GL_SGIS_point_line_texgen
#endif
/* GL_SGIS_texture_color_mask */
#ifdef __GLEE_GL_SGIS_texture_color_mask
#ifndef GLEE_C_DEFINED_glTextureColorMaskSGIS
#define GLEE_C_DEFINED_glTextureColorMaskSGIS
void __stdcall GLee_Lazy_glTextureColorMaskSGIS(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {if (GLeeInit()) glTextureColorMaskSGIS(red, green, blue, alpha);}
GLEEPFNGLTEXTURECOLORMASKSGISPROC GLeeFuncPtr_glTextureColorMaskSGIS=GLee_Lazy_glTextureColorMaskSGIS;
#endif
#endif
/* GL_EXT_texture_env_dot3 */
#ifdef __GLEE_GL_EXT_texture_env_dot3
#endif
/* GL_ATI_texture_mirror_once */
#ifdef __GLEE_GL_ATI_texture_mirror_once
#endif
/* GL_NV_fence */
#ifdef __GLEE_GL_NV_fence
#ifndef GLEE_C_DEFINED_glDeleteFencesNV
#define GLEE_C_DEFINED_glDeleteFencesNV
void __stdcall GLee_Lazy_glDeleteFencesNV(GLsizei n, const GLuint * fences) {if (GLeeInit()) glDeleteFencesNV(n, fences);}
GLEEPFNGLDELETEFENCESNVPROC GLeeFuncPtr_glDeleteFencesNV=GLee_Lazy_glDeleteFencesNV;
#endif
#ifndef GLEE_C_DEFINED_glGenFencesNV
#define GLEE_C_DEFINED_glGenFencesNV
void __stdcall GLee_Lazy_glGenFencesNV(GLsizei n, GLuint * fences) {if (GLeeInit()) glGenFencesNV(n, fences);}
GLEEPFNGLGENFENCESNVPROC GLeeFuncPtr_glGenFencesNV=GLee_Lazy_glGenFencesNV;
#endif
#ifndef GLEE_C_DEFINED_glIsFenceNV
#define GLEE_C_DEFINED_glIsFenceNV
GLboolean __stdcall GLee_Lazy_glIsFenceNV(GLuint fence) {if (GLeeInit()) return glIsFenceNV(fence); return (GLboolean)0;}
GLEEPFNGLISFENCENVPROC GLeeFuncPtr_glIsFenceNV=GLee_Lazy_glIsFenceNV;
#endif
#ifndef GLEE_C_DEFINED_glTestFenceNV
#define GLEE_C_DEFINED_glTestFenceNV
GLboolean __stdcall GLee_Lazy_glTestFenceNV(GLuint fence) {if (GLeeInit()) return glTestFenceNV(fence); return (GLboolean)0;}
GLEEPFNGLTESTFENCENVPROC GLeeFuncPtr_glTestFenceNV=GLee_Lazy_glTestFenceNV;
#endif
#ifndef GLEE_C_DEFINED_glGetFenceivNV
#define GLEE_C_DEFINED_glGetFenceivNV
void __stdcall GLee_Lazy_glGetFenceivNV(GLuint fence, GLenum pname, GLint * params) {if (GLeeInit()) glGetFenceivNV(fence, pname, params);}
GLEEPFNGLGETFENCEIVNVPROC GLeeFuncPtr_glGetFenceivNV=GLee_Lazy_glGetFenceivNV;
#endif
#ifndef GLEE_C_DEFINED_glFinishFenceNV
#define GLEE_C_DEFINED_glFinishFenceNV
void __stdcall GLee_Lazy_glFinishFenceNV(GLuint fence) {if (GLeeInit()) glFinishFenceNV(fence);}
GLEEPFNGLFINISHFENCENVPROC GLeeFuncPtr_glFinishFenceNV=GLee_Lazy_glFinishFenceNV;
#endif
#ifndef GLEE_C_DEFINED_glSetFenceNV
#define GLEE_C_DEFINED_glSetFenceNV
void __stdcall GLee_Lazy_glSetFenceNV(GLuint fence, GLenum condition) {if (GLeeInit()) glSetFenceNV(fence, condition);}
GLEEPFNGLSETFENCENVPROC GLeeFuncPtr_glSetFenceNV=GLee_Lazy_glSetFenceNV;
#endif
#endif
/* GL_IBM_texture_mirrored_repeat */
#ifdef __GLEE_GL_IBM_texture_mirrored_repeat
#endif
/* GL_NV_evaluators */
#ifdef __GLEE_GL_NV_evaluators
#ifndef GLEE_C_DEFINED_glMapControlPointsNV
#define GLEE_C_DEFINED_glMapControlPointsNV
void __stdcall GLee_Lazy_glMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const GLvoid * points) {if (GLeeInit()) glMapControlPointsNV(target, index, type, ustride, vstride, uorder, vorder, packed, points);}
GLEEPFNGLMAPCONTROLPOINTSNVPROC GLeeFuncPtr_glMapControlPointsNV=GLee_Lazy_glMapControlPointsNV;
#endif
#ifndef GLEE_C_DEFINED_glMapParameterivNV
#define GLEE_C_DEFINED_glMapParameterivNV
void __stdcall GLee_Lazy_glMapParameterivNV(GLenum target, GLenum pname, const GLint * params) {if (GLeeInit()) glMapParameterivNV(target, pname, params);}
GLEEPFNGLMAPPARAMETERIVNVPROC GLeeFuncPtr_glMapParameterivNV=GLee_Lazy_glMapParameterivNV;
#endif
#ifndef GLEE_C_DEFINED_glMapParameterfvNV
#define GLEE_C_DEFINED_glMapParameterfvNV
void __stdcall GLee_Lazy_glMapParameterfvNV(GLenum target, GLenum pname, const GLfloat * params) {if (GLeeInit()) glMapParameterfvNV(target, pname, params);}
GLEEPFNGLMAPPARAMETERFVNVPROC GLeeFuncPtr_glMapParameterfvNV=GLee_Lazy_glMapParameterfvNV;
#endif
#ifndef GLEE_C_DEFINED_glGetMapControlPointsNV
#define GLEE_C_DEFINED_glGetMapControlPointsNV
void __stdcall GLee_Lazy_glGetMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, GLvoid * points) {if (GLeeInit()) glGetMapControlPointsNV(target, index, type, ustride, vstride, packed, points);}
GLEEPFNGLGETMAPCONTROLPOINTSNVPROC GLeeFuncPtr_glGetMapControlPointsNV=GLee_Lazy_glGetMapControlPointsNV;
#endif
#ifndef GLEE_C_DEFINED_glGetMapParameterivNV
#define GLEE_C_DEFINED_glGetMapParameterivNV
void __stdcall GLee_Lazy_glGetMapParameterivNV(GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetMapParameterivNV(target, pname, params);}
GLEEPFNGLGETMAPPARAMETERIVNVPROC GLeeFuncPtr_glGetMapParameterivNV=GLee_Lazy_glGetMapParameterivNV;
#endif
#ifndef GLEE_C_DEFINED_glGetMapParameterfvNV
#define GLEE_C_DEFINED_glGetMapParameterfvNV
void __stdcall GLee_Lazy_glGetMapParameterfvNV(GLenum target, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetMapParameterfvNV(target, pname, params);}
GLEEPFNGLGETMAPPARAMETERFVNVPROC GLeeFuncPtr_glGetMapParameterfvNV=GLee_Lazy_glGetMapParameterfvNV;
#endif
#ifndef GLEE_C_DEFINED_glGetMapAttribParameterivNV
#define GLEE_C_DEFINED_glGetMapAttribParameterivNV
void __stdcall GLee_Lazy_glGetMapAttribParameterivNV(GLenum target, GLuint index, GLenum pname, GLint * params) {if (GLeeInit()) glGetMapAttribParameterivNV(target, index, pname, params);}
GLEEPFNGLGETMAPATTRIBPARAMETERIVNVPROC GLeeFuncPtr_glGetMapAttribParameterivNV=GLee_Lazy_glGetMapAttribParameterivNV;
#endif
#ifndef GLEE_C_DEFINED_glGetMapAttribParameterfvNV
#define GLEE_C_DEFINED_glGetMapAttribParameterfvNV
void __stdcall GLee_Lazy_glGetMapAttribParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetMapAttribParameterfvNV(target, index, pname, params);}
GLEEPFNGLGETMAPATTRIBPARAMETERFVNVPROC GLeeFuncPtr_glGetMapAttribParameterfvNV=GLee_Lazy_glGetMapAttribParameterfvNV;
#endif
#ifndef GLEE_C_DEFINED_glEvalMapsNV
#define GLEE_C_DEFINED_glEvalMapsNV
void __stdcall GLee_Lazy_glEvalMapsNV(GLenum target, GLenum mode) {if (GLeeInit()) glEvalMapsNV(target, mode);}
GLEEPFNGLEVALMAPSNVPROC GLeeFuncPtr_glEvalMapsNV=GLee_Lazy_glEvalMapsNV;
#endif
#endif
/* GL_NV_packed_depth_stencil */
#ifdef __GLEE_GL_NV_packed_depth_stencil
#endif
/* GL_NV_register_combiners2 */
#ifdef __GLEE_GL_NV_register_combiners2
#ifndef GLEE_C_DEFINED_glCombinerStageParameterfvNV
#define GLEE_C_DEFINED_glCombinerStageParameterfvNV
void __stdcall GLee_Lazy_glCombinerStageParameterfvNV(GLenum stage, GLenum pname, const GLfloat * params) {if (GLeeInit()) glCombinerStageParameterfvNV(stage, pname, params);}
GLEEPFNGLCOMBINERSTAGEPARAMETERFVNVPROC GLeeFuncPtr_glCombinerStageParameterfvNV=GLee_Lazy_glCombinerStageParameterfvNV;
#endif
#ifndef GLEE_C_DEFINED_glGetCombinerStageParameterfvNV
#define GLEE_C_DEFINED_glGetCombinerStageParameterfvNV
void __stdcall GLee_Lazy_glGetCombinerStageParameterfvNV(GLenum stage, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetCombinerStageParameterfvNV(stage, pname, params);}
GLEEPFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC GLeeFuncPtr_glGetCombinerStageParameterfvNV=GLee_Lazy_glGetCombinerStageParameterfvNV;
#endif
#endif
/* GL_NV_texture_compression_vtc */
#ifdef __GLEE_GL_NV_texture_compression_vtc
#endif
/* GL_NV_texture_rectangle */
#ifdef __GLEE_GL_NV_texture_rectangle
#endif
/* GL_NV_texture_shader */
#ifdef __GLEE_GL_NV_texture_shader
#endif
/* GL_NV_texture_shader2 */
#ifdef __GLEE_GL_NV_texture_shader2
#endif
/* GL_NV_vertex_array_range2 */
#ifdef __GLEE_GL_NV_vertex_array_range2
#endif
/* GL_NV_vertex_program */
#ifdef __GLEE_GL_NV_vertex_program
#ifndef GLEE_C_DEFINED_glAreProgramsResidentNV
#define GLEE_C_DEFINED_glAreProgramsResidentNV
GLboolean __stdcall GLee_Lazy_glAreProgramsResidentNV(GLsizei n, const GLuint * programs, GLboolean * residences) {if (GLeeInit()) return glAreProgramsResidentNV(n, programs, residences); return (GLboolean)0;}
GLEEPFNGLAREPROGRAMSRESIDENTNVPROC GLeeFuncPtr_glAreProgramsResidentNV=GLee_Lazy_glAreProgramsResidentNV;
#endif
#ifndef GLEE_C_DEFINED_glBindProgramNV
#define GLEE_C_DEFINED_glBindProgramNV
void __stdcall GLee_Lazy_glBindProgramNV(GLenum target, GLuint id) {if (GLeeInit()) glBindProgramNV(target, id);}
GLEEPFNGLBINDPROGRAMNVPROC GLeeFuncPtr_glBindProgramNV=GLee_Lazy_glBindProgramNV;
#endif
#ifndef GLEE_C_DEFINED_glDeleteProgramsNV
#define GLEE_C_DEFINED_glDeleteProgramsNV
void __stdcall GLee_Lazy_glDeleteProgramsNV(GLsizei n, const GLuint * programs) {if (GLeeInit()) glDeleteProgramsNV(n, programs);}
GLEEPFNGLDELETEPROGRAMSNVPROC GLeeFuncPtr_glDeleteProgramsNV=GLee_Lazy_glDeleteProgramsNV;
#endif
#ifndef GLEE_C_DEFINED_glExecuteProgramNV
#define GLEE_C_DEFINED_glExecuteProgramNV
void __stdcall GLee_Lazy_glExecuteProgramNV(GLenum target, GLuint id, const GLfloat * params) {if (GLeeInit()) glExecuteProgramNV(target, id, params);}
GLEEPFNGLEXECUTEPROGRAMNVPROC GLeeFuncPtr_glExecuteProgramNV=GLee_Lazy_glExecuteProgramNV;
#endif
#ifndef GLEE_C_DEFINED_glGenProgramsNV
#define GLEE_C_DEFINED_glGenProgramsNV
void __stdcall GLee_Lazy_glGenProgramsNV(GLsizei n, GLuint * programs) {if (GLeeInit()) glGenProgramsNV(n, programs);}
GLEEPFNGLGENPROGRAMSNVPROC GLeeFuncPtr_glGenProgramsNV=GLee_Lazy_glGenProgramsNV;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramParameterdvNV
#define GLEE_C_DEFINED_glGetProgramParameterdvNV
void __stdcall GLee_Lazy_glGetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, GLdouble * params) {if (GLeeInit()) glGetProgramParameterdvNV(target, index, pname, params);}
GLEEPFNGLGETPROGRAMPARAMETERDVNVPROC GLeeFuncPtr_glGetProgramParameterdvNV=GLee_Lazy_glGetProgramParameterdvNV;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramParameterfvNV
#define GLEE_C_DEFINED_glGetProgramParameterfvNV
void __stdcall GLee_Lazy_glGetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetProgramParameterfvNV(target, index, pname, params);}
GLEEPFNGLGETPROGRAMPARAMETERFVNVPROC GLeeFuncPtr_glGetProgramParameterfvNV=GLee_Lazy_glGetProgramParameterfvNV;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramivNV
#define GLEE_C_DEFINED_glGetProgramivNV
void __stdcall GLee_Lazy_glGetProgramivNV(GLuint id, GLenum pname, GLint * params) {if (GLeeInit()) glGetProgramivNV(id, pname, params);}
GLEEPFNGLGETPROGRAMIVNVPROC GLeeFuncPtr_glGetProgramivNV=GLee_Lazy_glGetProgramivNV;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramStringNV
#define GLEE_C_DEFINED_glGetProgramStringNV
void __stdcall GLee_Lazy_glGetProgramStringNV(GLuint id, GLenum pname, GLubyte * program) {if (GLeeInit()) glGetProgramStringNV(id, pname, program);}
GLEEPFNGLGETPROGRAMSTRINGNVPROC GLeeFuncPtr_glGetProgramStringNV=GLee_Lazy_glGetProgramStringNV;
#endif
#ifndef GLEE_C_DEFINED_glGetTrackMatrixivNV
#define GLEE_C_DEFINED_glGetTrackMatrixivNV
void __stdcall GLee_Lazy_glGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, GLint * params) {if (GLeeInit()) glGetTrackMatrixivNV(target, address, pname, params);}
GLEEPFNGLGETTRACKMATRIXIVNVPROC GLeeFuncPtr_glGetTrackMatrixivNV=GLee_Lazy_glGetTrackMatrixivNV;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribdvNV
#define GLEE_C_DEFINED_glGetVertexAttribdvNV
void __stdcall GLee_Lazy_glGetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble * params) {if (GLeeInit()) glGetVertexAttribdvNV(index, pname, params);}
GLEEPFNGLGETVERTEXATTRIBDVNVPROC GLeeFuncPtr_glGetVertexAttribdvNV=GLee_Lazy_glGetVertexAttribdvNV;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribfvNV
#define GLEE_C_DEFINED_glGetVertexAttribfvNV
void __stdcall GLee_Lazy_glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetVertexAttribfvNV(index, pname, params);}
GLEEPFNGLGETVERTEXATTRIBFVNVPROC GLeeFuncPtr_glGetVertexAttribfvNV=GLee_Lazy_glGetVertexAttribfvNV;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribivNV
#define GLEE_C_DEFINED_glGetVertexAttribivNV
void __stdcall GLee_Lazy_glGetVertexAttribivNV(GLuint index, GLenum pname, GLint * params) {if (GLeeInit()) glGetVertexAttribivNV(index, pname, params);}
GLEEPFNGLGETVERTEXATTRIBIVNVPROC GLeeFuncPtr_glGetVertexAttribivNV=GLee_Lazy_glGetVertexAttribivNV;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribPointervNV
#define GLEE_C_DEFINED_glGetVertexAttribPointervNV
void __stdcall GLee_Lazy_glGetVertexAttribPointervNV(GLuint index, GLenum pname, GLvoid* * pointer) {if (GLeeInit()) glGetVertexAttribPointervNV(index, pname, pointer);}
GLEEPFNGLGETVERTEXATTRIBPOINTERVNVPROC GLeeFuncPtr_glGetVertexAttribPointervNV=GLee_Lazy_glGetVertexAttribPointervNV;
#endif
#ifndef GLEE_C_DEFINED_glIsProgramNV
#define GLEE_C_DEFINED_glIsProgramNV
GLboolean __stdcall GLee_Lazy_glIsProgramNV(GLuint id) {if (GLeeInit()) return glIsProgramNV(id); return (GLboolean)0;}
GLEEPFNGLISPROGRAMNVPROC GLeeFuncPtr_glIsProgramNV=GLee_Lazy_glIsProgramNV;
#endif
#ifndef GLEE_C_DEFINED_glLoadProgramNV
#define GLEE_C_DEFINED_glLoadProgramNV
void __stdcall GLee_Lazy_glLoadProgramNV(GLenum target, GLuint id, GLsizei len, const GLubyte * program) {if (GLeeInit()) glLoadProgramNV(target, id, len, program);}
GLEEPFNGLLOADPROGRAMNVPROC GLeeFuncPtr_glLoadProgramNV=GLee_Lazy_glLoadProgramNV;
#endif
#ifndef GLEE_C_DEFINED_glProgramParameter4dNV
#define GLEE_C_DEFINED_glProgramParameter4dNV
void __stdcall GLee_Lazy_glProgramParameter4dNV(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {if (GLeeInit()) glProgramParameter4dNV(target, index, x, y, z, w);}
GLEEPFNGLPROGRAMPARAMETER4DNVPROC GLeeFuncPtr_glProgramParameter4dNV=GLee_Lazy_glProgramParameter4dNV;
#endif
#ifndef GLEE_C_DEFINED_glProgramParameter4dvNV
#define GLEE_C_DEFINED_glProgramParameter4dvNV
void __stdcall GLee_Lazy_glProgramParameter4dvNV(GLenum target, GLuint index, const GLdouble * v) {if (GLeeInit()) glProgramParameter4dvNV(target, index, v);}
GLEEPFNGLPROGRAMPARAMETER4DVNVPROC GLeeFuncPtr_glProgramParameter4dvNV=GLee_Lazy_glProgramParameter4dvNV;
#endif
#ifndef GLEE_C_DEFINED_glProgramParameter4fNV
#define GLEE_C_DEFINED_glProgramParameter4fNV
void __stdcall GLee_Lazy_glProgramParameter4fNV(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {if (GLeeInit()) glProgramParameter4fNV(target, index, x, y, z, w);}
GLEEPFNGLPROGRAMPARAMETER4FNVPROC GLeeFuncPtr_glProgramParameter4fNV=GLee_Lazy_glProgramParameter4fNV;
#endif
#ifndef GLEE_C_DEFINED_glProgramParameter4fvNV
#define GLEE_C_DEFINED_glProgramParameter4fvNV
void __stdcall GLee_Lazy_glProgramParameter4fvNV(GLenum target, GLuint index, const GLfloat * v) {if (GLeeInit()) glProgramParameter4fvNV(target, index, v);}
GLEEPFNGLPROGRAMPARAMETER4FVNVPROC GLeeFuncPtr_glProgramParameter4fvNV=GLee_Lazy_glProgramParameter4fvNV;
#endif
#ifndef GLEE_C_DEFINED_glProgramParameters4dvNV
#define GLEE_C_DEFINED_glProgramParameters4dvNV
void __stdcall GLee_Lazy_glProgramParameters4dvNV(GLenum target, GLuint index, GLuint count, const GLdouble * v) {if (GLeeInit()) glProgramParameters4dvNV(target, index, count, v);}
GLEEPFNGLPROGRAMPARAMETERS4DVNVPROC GLeeFuncPtr_glProgramParameters4dvNV=GLee_Lazy_glProgramParameters4dvNV;
#endif
#ifndef GLEE_C_DEFINED_glProgramParameters4fvNV
#define GLEE_C_DEFINED_glProgramParameters4fvNV
void __stdcall GLee_Lazy_glProgramParameters4fvNV(GLenum target, GLuint index, GLuint count, const GLfloat * v) {if (GLeeInit()) glProgramParameters4fvNV(target, index, count, v);}
GLEEPFNGLPROGRAMPARAMETERS4FVNVPROC GLeeFuncPtr_glProgramParameters4fvNV=GLee_Lazy_glProgramParameters4fvNV;
#endif
#ifndef GLEE_C_DEFINED_glRequestResidentProgramsNV
#define GLEE_C_DEFINED_glRequestResidentProgramsNV
void __stdcall GLee_Lazy_glRequestResidentProgramsNV(GLsizei n, const GLuint * programs) {if (GLeeInit()) glRequestResidentProgramsNV(n, programs);}
GLEEPFNGLREQUESTRESIDENTPROGRAMSNVPROC GLeeFuncPtr_glRequestResidentProgramsNV=GLee_Lazy_glRequestResidentProgramsNV;
#endif
#ifndef GLEE_C_DEFINED_glTrackMatrixNV
#define GLEE_C_DEFINED_glTrackMatrixNV
void __stdcall GLee_Lazy_glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GLenum transform) {if (GLeeInit()) glTrackMatrixNV(target, address, matrix, transform);}
GLEEPFNGLTRACKMATRIXNVPROC GLeeFuncPtr_glTrackMatrixNV=GLee_Lazy_glTrackMatrixNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribPointerNV
#define GLEE_C_DEFINED_glVertexAttribPointerNV
void __stdcall GLee_Lazy_glVertexAttribPointerNV(GLuint index, GLint fsize, GLenum type, GLsizei stride, const GLvoid * pointer) {if (GLeeInit()) glVertexAttribPointerNV(index, fsize, type, stride, pointer);}
GLEEPFNGLVERTEXATTRIBPOINTERNVPROC GLeeFuncPtr_glVertexAttribPointerNV=GLee_Lazy_glVertexAttribPointerNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1dNV
#define GLEE_C_DEFINED_glVertexAttrib1dNV
void __stdcall GLee_Lazy_glVertexAttrib1dNV(GLuint index, GLdouble x) {if (GLeeInit()) glVertexAttrib1dNV(index, x);}
GLEEPFNGLVERTEXATTRIB1DNVPROC GLeeFuncPtr_glVertexAttrib1dNV=GLee_Lazy_glVertexAttrib1dNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1dvNV
#define GLEE_C_DEFINED_glVertexAttrib1dvNV
void __stdcall GLee_Lazy_glVertexAttrib1dvNV(GLuint index, const GLdouble * v) {if (GLeeInit()) glVertexAttrib1dvNV(index, v);}
GLEEPFNGLVERTEXATTRIB1DVNVPROC GLeeFuncPtr_glVertexAttrib1dvNV=GLee_Lazy_glVertexAttrib1dvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1fNV
#define GLEE_C_DEFINED_glVertexAttrib1fNV
void __stdcall GLee_Lazy_glVertexAttrib1fNV(GLuint index, GLfloat x) {if (GLeeInit()) glVertexAttrib1fNV(index, x);}
GLEEPFNGLVERTEXATTRIB1FNVPROC GLeeFuncPtr_glVertexAttrib1fNV=GLee_Lazy_glVertexAttrib1fNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1fvNV
#define GLEE_C_DEFINED_glVertexAttrib1fvNV
void __stdcall GLee_Lazy_glVertexAttrib1fvNV(GLuint index, const GLfloat * v) {if (GLeeInit()) glVertexAttrib1fvNV(index, v);}
GLEEPFNGLVERTEXATTRIB1FVNVPROC GLeeFuncPtr_glVertexAttrib1fvNV=GLee_Lazy_glVertexAttrib1fvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1sNV
#define GLEE_C_DEFINED_glVertexAttrib1sNV
void __stdcall GLee_Lazy_glVertexAttrib1sNV(GLuint index, GLshort x) {if (GLeeInit()) glVertexAttrib1sNV(index, x);}
GLEEPFNGLVERTEXATTRIB1SNVPROC GLeeFuncPtr_glVertexAttrib1sNV=GLee_Lazy_glVertexAttrib1sNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1svNV
#define GLEE_C_DEFINED_glVertexAttrib1svNV
void __stdcall GLee_Lazy_glVertexAttrib1svNV(GLuint index, const GLshort * v) {if (GLeeInit()) glVertexAttrib1svNV(index, v);}
GLEEPFNGLVERTEXATTRIB1SVNVPROC GLeeFuncPtr_glVertexAttrib1svNV=GLee_Lazy_glVertexAttrib1svNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2dNV
#define GLEE_C_DEFINED_glVertexAttrib2dNV
void __stdcall GLee_Lazy_glVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y) {if (GLeeInit()) glVertexAttrib2dNV(index, x, y);}
GLEEPFNGLVERTEXATTRIB2DNVPROC GLeeFuncPtr_glVertexAttrib2dNV=GLee_Lazy_glVertexAttrib2dNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2dvNV
#define GLEE_C_DEFINED_glVertexAttrib2dvNV
void __stdcall GLee_Lazy_glVertexAttrib2dvNV(GLuint index, const GLdouble * v) {if (GLeeInit()) glVertexAttrib2dvNV(index, v);}
GLEEPFNGLVERTEXATTRIB2DVNVPROC GLeeFuncPtr_glVertexAttrib2dvNV=GLee_Lazy_glVertexAttrib2dvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2fNV
#define GLEE_C_DEFINED_glVertexAttrib2fNV
void __stdcall GLee_Lazy_glVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y) {if (GLeeInit()) glVertexAttrib2fNV(index, x, y);}
GLEEPFNGLVERTEXATTRIB2FNVPROC GLeeFuncPtr_glVertexAttrib2fNV=GLee_Lazy_glVertexAttrib2fNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2fvNV
#define GLEE_C_DEFINED_glVertexAttrib2fvNV
void __stdcall GLee_Lazy_glVertexAttrib2fvNV(GLuint index, const GLfloat * v) {if (GLeeInit()) glVertexAttrib2fvNV(index, v);}
GLEEPFNGLVERTEXATTRIB2FVNVPROC GLeeFuncPtr_glVertexAttrib2fvNV=GLee_Lazy_glVertexAttrib2fvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2sNV
#define GLEE_C_DEFINED_glVertexAttrib2sNV
void __stdcall GLee_Lazy_glVertexAttrib2sNV(GLuint index, GLshort x, GLshort y) {if (GLeeInit()) glVertexAttrib2sNV(index, x, y);}
GLEEPFNGLVERTEXATTRIB2SNVPROC GLeeFuncPtr_glVertexAttrib2sNV=GLee_Lazy_glVertexAttrib2sNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2svNV
#define GLEE_C_DEFINED_glVertexAttrib2svNV
void __stdcall GLee_Lazy_glVertexAttrib2svNV(GLuint index, const GLshort * v) {if (GLeeInit()) glVertexAttrib2svNV(index, v);}
GLEEPFNGLVERTEXATTRIB2SVNVPROC GLeeFuncPtr_glVertexAttrib2svNV=GLee_Lazy_glVertexAttrib2svNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3dNV
#define GLEE_C_DEFINED_glVertexAttrib3dNV
void __stdcall GLee_Lazy_glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z) {if (GLeeInit()) glVertexAttrib3dNV(index, x, y, z);}
GLEEPFNGLVERTEXATTRIB3DNVPROC GLeeFuncPtr_glVertexAttrib3dNV=GLee_Lazy_glVertexAttrib3dNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3dvNV
#define GLEE_C_DEFINED_glVertexAttrib3dvNV
void __stdcall GLee_Lazy_glVertexAttrib3dvNV(GLuint index, const GLdouble * v) {if (GLeeInit()) glVertexAttrib3dvNV(index, v);}
GLEEPFNGLVERTEXATTRIB3DVNVPROC GLeeFuncPtr_glVertexAttrib3dvNV=GLee_Lazy_glVertexAttrib3dvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3fNV
#define GLEE_C_DEFINED_glVertexAttrib3fNV
void __stdcall GLee_Lazy_glVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glVertexAttrib3fNV(index, x, y, z);}
GLEEPFNGLVERTEXATTRIB3FNVPROC GLeeFuncPtr_glVertexAttrib3fNV=GLee_Lazy_glVertexAttrib3fNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3fvNV
#define GLEE_C_DEFINED_glVertexAttrib3fvNV
void __stdcall GLee_Lazy_glVertexAttrib3fvNV(GLuint index, const GLfloat * v) {if (GLeeInit()) glVertexAttrib3fvNV(index, v);}
GLEEPFNGLVERTEXATTRIB3FVNVPROC GLeeFuncPtr_glVertexAttrib3fvNV=GLee_Lazy_glVertexAttrib3fvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3sNV
#define GLEE_C_DEFINED_glVertexAttrib3sNV
void __stdcall GLee_Lazy_glVertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z) {if (GLeeInit()) glVertexAttrib3sNV(index, x, y, z);}
GLEEPFNGLVERTEXATTRIB3SNVPROC GLeeFuncPtr_glVertexAttrib3sNV=GLee_Lazy_glVertexAttrib3sNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3svNV
#define GLEE_C_DEFINED_glVertexAttrib3svNV
void __stdcall GLee_Lazy_glVertexAttrib3svNV(GLuint index, const GLshort * v) {if (GLeeInit()) glVertexAttrib3svNV(index, v);}
GLEEPFNGLVERTEXATTRIB3SVNVPROC GLeeFuncPtr_glVertexAttrib3svNV=GLee_Lazy_glVertexAttrib3svNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4dNV
#define GLEE_C_DEFINED_glVertexAttrib4dNV
void __stdcall GLee_Lazy_glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {if (GLeeInit()) glVertexAttrib4dNV(index, x, y, z, w);}
GLEEPFNGLVERTEXATTRIB4DNVPROC GLeeFuncPtr_glVertexAttrib4dNV=GLee_Lazy_glVertexAttrib4dNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4dvNV
#define GLEE_C_DEFINED_glVertexAttrib4dvNV
void __stdcall GLee_Lazy_glVertexAttrib4dvNV(GLuint index, const GLdouble * v) {if (GLeeInit()) glVertexAttrib4dvNV(index, v);}
GLEEPFNGLVERTEXATTRIB4DVNVPROC GLeeFuncPtr_glVertexAttrib4dvNV=GLee_Lazy_glVertexAttrib4dvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4fNV
#define GLEE_C_DEFINED_glVertexAttrib4fNV
void __stdcall GLee_Lazy_glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {if (GLeeInit()) glVertexAttrib4fNV(index, x, y, z, w);}
GLEEPFNGLVERTEXATTRIB4FNVPROC GLeeFuncPtr_glVertexAttrib4fNV=GLee_Lazy_glVertexAttrib4fNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4fvNV
#define GLEE_C_DEFINED_glVertexAttrib4fvNV
void __stdcall GLee_Lazy_glVertexAttrib4fvNV(GLuint index, const GLfloat * v) {if (GLeeInit()) glVertexAttrib4fvNV(index, v);}
GLEEPFNGLVERTEXATTRIB4FVNVPROC GLeeFuncPtr_glVertexAttrib4fvNV=GLee_Lazy_glVertexAttrib4fvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4sNV
#define GLEE_C_DEFINED_glVertexAttrib4sNV
void __stdcall GLee_Lazy_glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) {if (GLeeInit()) glVertexAttrib4sNV(index, x, y, z, w);}
GLEEPFNGLVERTEXATTRIB4SNVPROC GLeeFuncPtr_glVertexAttrib4sNV=GLee_Lazy_glVertexAttrib4sNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4svNV
#define GLEE_C_DEFINED_glVertexAttrib4svNV
void __stdcall GLee_Lazy_glVertexAttrib4svNV(GLuint index, const GLshort * v) {if (GLeeInit()) glVertexAttrib4svNV(index, v);}
GLEEPFNGLVERTEXATTRIB4SVNVPROC GLeeFuncPtr_glVertexAttrib4svNV=GLee_Lazy_glVertexAttrib4svNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4ubNV
#define GLEE_C_DEFINED_glVertexAttrib4ubNV
void __stdcall GLee_Lazy_glVertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) {if (GLeeInit()) glVertexAttrib4ubNV(index, x, y, z, w);}
GLEEPFNGLVERTEXATTRIB4UBNVPROC GLeeFuncPtr_glVertexAttrib4ubNV=GLee_Lazy_glVertexAttrib4ubNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4ubvNV
#define GLEE_C_DEFINED_glVertexAttrib4ubvNV
void __stdcall GLee_Lazy_glVertexAttrib4ubvNV(GLuint index, const GLubyte * v) {if (GLeeInit()) glVertexAttrib4ubvNV(index, v);}
GLEEPFNGLVERTEXATTRIB4UBVNVPROC GLeeFuncPtr_glVertexAttrib4ubvNV=GLee_Lazy_glVertexAttrib4ubvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribs1dvNV
#define GLEE_C_DEFINED_glVertexAttribs1dvNV
void __stdcall GLee_Lazy_glVertexAttribs1dvNV(GLuint index, GLsizei count, const GLdouble * v) {if (GLeeInit()) glVertexAttribs1dvNV(index, count, v);}
GLEEPFNGLVERTEXATTRIBS1DVNVPROC GLeeFuncPtr_glVertexAttribs1dvNV=GLee_Lazy_glVertexAttribs1dvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribs1fvNV
#define GLEE_C_DEFINED_glVertexAttribs1fvNV
void __stdcall GLee_Lazy_glVertexAttribs1fvNV(GLuint index, GLsizei count, const GLfloat * v) {if (GLeeInit()) glVertexAttribs1fvNV(index, count, v);}
GLEEPFNGLVERTEXATTRIBS1FVNVPROC GLeeFuncPtr_glVertexAttribs1fvNV=GLee_Lazy_glVertexAttribs1fvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribs1svNV
#define GLEE_C_DEFINED_glVertexAttribs1svNV
void __stdcall GLee_Lazy_glVertexAttribs1svNV(GLuint index, GLsizei count, const GLshort * v) {if (GLeeInit()) glVertexAttribs1svNV(index, count, v);}
GLEEPFNGLVERTEXATTRIBS1SVNVPROC GLeeFuncPtr_glVertexAttribs1svNV=GLee_Lazy_glVertexAttribs1svNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribs2dvNV
#define GLEE_C_DEFINED_glVertexAttribs2dvNV
void __stdcall GLee_Lazy_glVertexAttribs2dvNV(GLuint index, GLsizei count, const GLdouble * v) {if (GLeeInit()) glVertexAttribs2dvNV(index, count, v);}
GLEEPFNGLVERTEXATTRIBS2DVNVPROC GLeeFuncPtr_glVertexAttribs2dvNV=GLee_Lazy_glVertexAttribs2dvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribs2fvNV
#define GLEE_C_DEFINED_glVertexAttribs2fvNV
void __stdcall GLee_Lazy_glVertexAttribs2fvNV(GLuint index, GLsizei count, const GLfloat * v) {if (GLeeInit()) glVertexAttribs2fvNV(index, count, v);}
GLEEPFNGLVERTEXATTRIBS2FVNVPROC GLeeFuncPtr_glVertexAttribs2fvNV=GLee_Lazy_glVertexAttribs2fvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribs2svNV
#define GLEE_C_DEFINED_glVertexAttribs2svNV
void __stdcall GLee_Lazy_glVertexAttribs2svNV(GLuint index, GLsizei count, const GLshort * v) {if (GLeeInit()) glVertexAttribs2svNV(index, count, v);}
GLEEPFNGLVERTEXATTRIBS2SVNVPROC GLeeFuncPtr_glVertexAttribs2svNV=GLee_Lazy_glVertexAttribs2svNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribs3dvNV
#define GLEE_C_DEFINED_glVertexAttribs3dvNV
void __stdcall GLee_Lazy_glVertexAttribs3dvNV(GLuint index, GLsizei count, const GLdouble * v) {if (GLeeInit()) glVertexAttribs3dvNV(index, count, v);}
GLEEPFNGLVERTEXATTRIBS3DVNVPROC GLeeFuncPtr_glVertexAttribs3dvNV=GLee_Lazy_glVertexAttribs3dvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribs3fvNV
#define GLEE_C_DEFINED_glVertexAttribs3fvNV
void __stdcall GLee_Lazy_glVertexAttribs3fvNV(GLuint index, GLsizei count, const GLfloat * v) {if (GLeeInit()) glVertexAttribs3fvNV(index, count, v);}
GLEEPFNGLVERTEXATTRIBS3FVNVPROC GLeeFuncPtr_glVertexAttribs3fvNV=GLee_Lazy_glVertexAttribs3fvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribs3svNV
#define GLEE_C_DEFINED_glVertexAttribs3svNV
void __stdcall GLee_Lazy_glVertexAttribs3svNV(GLuint index, GLsizei count, const GLshort * v) {if (GLeeInit()) glVertexAttribs3svNV(index, count, v);}
GLEEPFNGLVERTEXATTRIBS3SVNVPROC GLeeFuncPtr_glVertexAttribs3svNV=GLee_Lazy_glVertexAttribs3svNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribs4dvNV
#define GLEE_C_DEFINED_glVertexAttribs4dvNV
void __stdcall GLee_Lazy_glVertexAttribs4dvNV(GLuint index, GLsizei count, const GLdouble * v) {if (GLeeInit()) glVertexAttribs4dvNV(index, count, v);}
GLEEPFNGLVERTEXATTRIBS4DVNVPROC GLeeFuncPtr_glVertexAttribs4dvNV=GLee_Lazy_glVertexAttribs4dvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribs4fvNV
#define GLEE_C_DEFINED_glVertexAttribs4fvNV
void __stdcall GLee_Lazy_glVertexAttribs4fvNV(GLuint index, GLsizei count, const GLfloat * v) {if (GLeeInit()) glVertexAttribs4fvNV(index, count, v);}
GLEEPFNGLVERTEXATTRIBS4FVNVPROC GLeeFuncPtr_glVertexAttribs4fvNV=GLee_Lazy_glVertexAttribs4fvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribs4svNV
#define GLEE_C_DEFINED_glVertexAttribs4svNV
void __stdcall GLee_Lazy_glVertexAttribs4svNV(GLuint index, GLsizei count, const GLshort * v) {if (GLeeInit()) glVertexAttribs4svNV(index, count, v);}
GLEEPFNGLVERTEXATTRIBS4SVNVPROC GLeeFuncPtr_glVertexAttribs4svNV=GLee_Lazy_glVertexAttribs4svNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribs4ubvNV
#define GLEE_C_DEFINED_glVertexAttribs4ubvNV
void __stdcall GLee_Lazy_glVertexAttribs4ubvNV(GLuint index, GLsizei count, const GLubyte * v) {if (GLeeInit()) glVertexAttribs4ubvNV(index, count, v);}
GLEEPFNGLVERTEXATTRIBS4UBVNVPROC GLeeFuncPtr_glVertexAttribs4ubvNV=GLee_Lazy_glVertexAttribs4ubvNV;
#endif
#endif
/* GL_SGIX_texture_coordinate_clamp */
#ifdef __GLEE_GL_SGIX_texture_coordinate_clamp
#endif
/* GL_SGIX_scalebias_hint */
#ifdef __GLEE_GL_SGIX_scalebias_hint
#endif
/* GL_OML_interlace */
#ifdef __GLEE_GL_OML_interlace
#endif
/* GL_OML_subsample */
#ifdef __GLEE_GL_OML_subsample
#endif
/* GL_OML_resample */
#ifdef __GLEE_GL_OML_resample
#endif
/* GL_NV_copy_depth_to_color */
#ifdef __GLEE_GL_NV_copy_depth_to_color
#endif
/* GL_ATI_envmap_bumpmap */
#ifdef __GLEE_GL_ATI_envmap_bumpmap
#ifndef GLEE_C_DEFINED_glTexBumpParameterivATI
#define GLEE_C_DEFINED_glTexBumpParameterivATI
void __stdcall GLee_Lazy_glTexBumpParameterivATI(GLenum pname, const GLint * param) {if (GLeeInit()) glTexBumpParameterivATI(pname, param);}
GLEEPFNGLTEXBUMPPARAMETERIVATIPROC GLeeFuncPtr_glTexBumpParameterivATI=GLee_Lazy_glTexBumpParameterivATI;
#endif
#ifndef GLEE_C_DEFINED_glTexBumpParameterfvATI
#define GLEE_C_DEFINED_glTexBumpParameterfvATI
void __stdcall GLee_Lazy_glTexBumpParameterfvATI(GLenum pname, const GLfloat * param) {if (GLeeInit()) glTexBumpParameterfvATI(pname, param);}
GLEEPFNGLTEXBUMPPARAMETERFVATIPROC GLeeFuncPtr_glTexBumpParameterfvATI=GLee_Lazy_glTexBumpParameterfvATI;
#endif
#ifndef GLEE_C_DEFINED_glGetTexBumpParameterivATI
#define GLEE_C_DEFINED_glGetTexBumpParameterivATI
void __stdcall GLee_Lazy_glGetTexBumpParameterivATI(GLenum pname, GLint * param) {if (GLeeInit()) glGetTexBumpParameterivATI(pname, param);}
GLEEPFNGLGETTEXBUMPPARAMETERIVATIPROC GLeeFuncPtr_glGetTexBumpParameterivATI=GLee_Lazy_glGetTexBumpParameterivATI;
#endif
#ifndef GLEE_C_DEFINED_glGetTexBumpParameterfvATI
#define GLEE_C_DEFINED_glGetTexBumpParameterfvATI
void __stdcall GLee_Lazy_glGetTexBumpParameterfvATI(GLenum pname, GLfloat * param) {if (GLeeInit()) glGetTexBumpParameterfvATI(pname, param);}
GLEEPFNGLGETTEXBUMPPARAMETERFVATIPROC GLeeFuncPtr_glGetTexBumpParameterfvATI=GLee_Lazy_glGetTexBumpParameterfvATI;
#endif
#endif
/* GL_ATI_fragment_shader */
#ifdef __GLEE_GL_ATI_fragment_shader
#ifndef GLEE_C_DEFINED_glGenFragmentShadersATI
#define GLEE_C_DEFINED_glGenFragmentShadersATI
GLuint __stdcall GLee_Lazy_glGenFragmentShadersATI(GLuint range) {if (GLeeInit()) return glGenFragmentShadersATI(range); return (GLuint)0;}
GLEEPFNGLGENFRAGMENTSHADERSATIPROC GLeeFuncPtr_glGenFragmentShadersATI=GLee_Lazy_glGenFragmentShadersATI;
#endif
#ifndef GLEE_C_DEFINED_glBindFragmentShaderATI
#define GLEE_C_DEFINED_glBindFragmentShaderATI
void __stdcall GLee_Lazy_glBindFragmentShaderATI(GLuint id) {if (GLeeInit()) glBindFragmentShaderATI(id);}
GLEEPFNGLBINDFRAGMENTSHADERATIPROC GLeeFuncPtr_glBindFragmentShaderATI=GLee_Lazy_glBindFragmentShaderATI;
#endif
#ifndef GLEE_C_DEFINED_glDeleteFragmentShaderATI
#define GLEE_C_DEFINED_glDeleteFragmentShaderATI
void __stdcall GLee_Lazy_glDeleteFragmentShaderATI(GLuint id) {if (GLeeInit()) glDeleteFragmentShaderATI(id);}
GLEEPFNGLDELETEFRAGMENTSHADERATIPROC GLeeFuncPtr_glDeleteFragmentShaderATI=GLee_Lazy_glDeleteFragmentShaderATI;
#endif
#ifndef GLEE_C_DEFINED_glBeginFragmentShaderATI
#define GLEE_C_DEFINED_glBeginFragmentShaderATI
void __stdcall GLee_Lazy_glBeginFragmentShaderATI(void) {if (GLeeInit()) glBeginFragmentShaderATI();}
GLEEPFNGLBEGINFRAGMENTSHADERATIPROC GLeeFuncPtr_glBeginFragmentShaderATI=GLee_Lazy_glBeginFragmentShaderATI;
#endif
#ifndef GLEE_C_DEFINED_glEndFragmentShaderATI
#define GLEE_C_DEFINED_glEndFragmentShaderATI
void __stdcall GLee_Lazy_glEndFragmentShaderATI(void) {if (GLeeInit()) glEndFragmentShaderATI();}
GLEEPFNGLENDFRAGMENTSHADERATIPROC GLeeFuncPtr_glEndFragmentShaderATI=GLee_Lazy_glEndFragmentShaderATI;
#endif
#ifndef GLEE_C_DEFINED_glPassTexCoordATI
#define GLEE_C_DEFINED_glPassTexCoordATI
void __stdcall GLee_Lazy_glPassTexCoordATI(GLuint dst, GLuint coord, GLenum swizzle) {if (GLeeInit()) glPassTexCoordATI(dst, coord, swizzle);}
GLEEPFNGLPASSTEXCOORDATIPROC GLeeFuncPtr_glPassTexCoordATI=GLee_Lazy_glPassTexCoordATI;
#endif
#ifndef GLEE_C_DEFINED_glSampleMapATI
#define GLEE_C_DEFINED_glSampleMapATI
void __stdcall GLee_Lazy_glSampleMapATI(GLuint dst, GLuint interp, GLenum swizzle) {if (GLeeInit()) glSampleMapATI(dst, interp, swizzle);}
GLEEPFNGLSAMPLEMAPATIPROC GLeeFuncPtr_glSampleMapATI=GLee_Lazy_glSampleMapATI;
#endif
#ifndef GLEE_C_DEFINED_glColorFragmentOp1ATI
#define GLEE_C_DEFINED_glColorFragmentOp1ATI
void __stdcall GLee_Lazy_glColorFragmentOp1ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod) {if (GLeeInit()) glColorFragmentOp1ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod);}
GLEEPFNGLCOLORFRAGMENTOP1ATIPROC GLeeFuncPtr_glColorFragmentOp1ATI=GLee_Lazy_glColorFragmentOp1ATI;
#endif
#ifndef GLEE_C_DEFINED_glColorFragmentOp2ATI
#define GLEE_C_DEFINED_glColorFragmentOp2ATI
void __stdcall GLee_Lazy_glColorFragmentOp2ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod) {if (GLeeInit()) glColorFragmentOp2ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);}
GLEEPFNGLCOLORFRAGMENTOP2ATIPROC GLeeFuncPtr_glColorFragmentOp2ATI=GLee_Lazy_glColorFragmentOp2ATI;
#endif
#ifndef GLEE_C_DEFINED_glColorFragmentOp3ATI
#define GLEE_C_DEFINED_glColorFragmentOp3ATI
void __stdcall GLee_Lazy_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) {if (GLeeInit()) glColorFragmentOp3ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);}
GLEEPFNGLCOLORFRAGMENTOP3ATIPROC GLeeFuncPtr_glColorFragmentOp3ATI=GLee_Lazy_glColorFragmentOp3ATI;
#endif
#ifndef GLEE_C_DEFINED_glAlphaFragmentOp1ATI
#define GLEE_C_DEFINED_glAlphaFragmentOp1ATI
void __stdcall GLee_Lazy_glAlphaFragmentOp1ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod) {if (GLeeInit()) glAlphaFragmentOp1ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod);}
GLEEPFNGLALPHAFRAGMENTOP1ATIPROC GLeeFuncPtr_glAlphaFragmentOp1ATI=GLee_Lazy_glAlphaFragmentOp1ATI;
#endif
#ifndef GLEE_C_DEFINED_glAlphaFragmentOp2ATI
#define GLEE_C_DEFINED_glAlphaFragmentOp2ATI
void __stdcall GLee_Lazy_glAlphaFragmentOp2ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod) {if (GLeeInit()) glAlphaFragmentOp2ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);}
GLEEPFNGLALPHAFRAGMENTOP2ATIPROC GLeeFuncPtr_glAlphaFragmentOp2ATI=GLee_Lazy_glAlphaFragmentOp2ATI;
#endif
#ifndef GLEE_C_DEFINED_glAlphaFragmentOp3ATI
#define GLEE_C_DEFINED_glAlphaFragmentOp3ATI
void __stdcall GLee_Lazy_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) {if (GLeeInit()) glAlphaFragmentOp3ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);}
GLEEPFNGLALPHAFRAGMENTOP3ATIPROC GLeeFuncPtr_glAlphaFragmentOp3ATI=GLee_Lazy_glAlphaFragmentOp3ATI;
#endif
#ifndef GLEE_C_DEFINED_glSetFragmentShaderConstantATI
#define GLEE_C_DEFINED_glSetFragmentShaderConstantATI
void __stdcall GLee_Lazy_glSetFragmentShaderConstantATI(GLuint dst, const GLfloat * value) {if (GLeeInit()) glSetFragmentShaderConstantATI(dst, value);}
GLEEPFNGLSETFRAGMENTSHADERCONSTANTATIPROC GLeeFuncPtr_glSetFragmentShaderConstantATI=GLee_Lazy_glSetFragmentShaderConstantATI;
#endif
#endif
/* GL_ATI_pn_triangles */
#ifdef __GLEE_GL_ATI_pn_triangles
#ifndef GLEE_C_DEFINED_glPNTrianglesiATI
#define GLEE_C_DEFINED_glPNTrianglesiATI
void __stdcall GLee_Lazy_glPNTrianglesiATI(GLenum pname, GLint param) {if (GLeeInit()) glPNTrianglesiATI(pname, param);}
GLEEPFNGLPNTRIANGLESIATIPROC GLeeFuncPtr_glPNTrianglesiATI=GLee_Lazy_glPNTrianglesiATI;
#endif
#ifndef GLEE_C_DEFINED_glPNTrianglesfATI
#define GLEE_C_DEFINED_glPNTrianglesfATI
void __stdcall GLee_Lazy_glPNTrianglesfATI(GLenum pname, GLfloat param) {if (GLeeInit()) glPNTrianglesfATI(pname, param);}
GLEEPFNGLPNTRIANGLESFATIPROC GLeeFuncPtr_glPNTrianglesfATI=GLee_Lazy_glPNTrianglesfATI;
#endif
#endif
/* GL_ATI_vertex_array_object */
#ifdef __GLEE_GL_ATI_vertex_array_object
#ifndef GLEE_C_DEFINED_glNewObjectBufferATI
#define GLEE_C_DEFINED_glNewObjectBufferATI
GLuint __stdcall GLee_Lazy_glNewObjectBufferATI(GLsizei size, const GLvoid * pointer, GLenum usage) {if (GLeeInit()) return glNewObjectBufferATI(size, pointer, usage); return (GLuint)0;}
GLEEPFNGLNEWOBJECTBUFFERATIPROC GLeeFuncPtr_glNewObjectBufferATI=GLee_Lazy_glNewObjectBufferATI;
#endif
#ifndef GLEE_C_DEFINED_glIsObjectBufferATI
#define GLEE_C_DEFINED_glIsObjectBufferATI
GLboolean __stdcall GLee_Lazy_glIsObjectBufferATI(GLuint buffer) {if (GLeeInit()) return glIsObjectBufferATI(buffer); return (GLboolean)0;}
GLEEPFNGLISOBJECTBUFFERATIPROC GLeeFuncPtr_glIsObjectBufferATI=GLee_Lazy_glIsObjectBufferATI;
#endif
#ifndef GLEE_C_DEFINED_glUpdateObjectBufferATI
#define GLEE_C_DEFINED_glUpdateObjectBufferATI
void __stdcall GLee_Lazy_glUpdateObjectBufferATI(GLuint buffer, GLuint offset, GLsizei size, const GLvoid * pointer, GLenum preserve) {if (GLeeInit()) glUpdateObjectBufferATI(buffer, offset, size, pointer, preserve);}
GLEEPFNGLUPDATEOBJECTBUFFERATIPROC GLeeFuncPtr_glUpdateObjectBufferATI=GLee_Lazy_glUpdateObjectBufferATI;
#endif
#ifndef GLEE_C_DEFINED_glGetObjectBufferfvATI
#define GLEE_C_DEFINED_glGetObjectBufferfvATI
void __stdcall GLee_Lazy_glGetObjectBufferfvATI(GLuint buffer, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetObjectBufferfvATI(buffer, pname, params);}
GLEEPFNGLGETOBJECTBUFFERFVATIPROC GLeeFuncPtr_glGetObjectBufferfvATI=GLee_Lazy_glGetObjectBufferfvATI;
#endif
#ifndef GLEE_C_DEFINED_glGetObjectBufferivATI
#define GLEE_C_DEFINED_glGetObjectBufferivATI
void __stdcall GLee_Lazy_glGetObjectBufferivATI(GLuint buffer, GLenum pname, GLint * params) {if (GLeeInit()) glGetObjectBufferivATI(buffer, pname, params);}
GLEEPFNGLGETOBJECTBUFFERIVATIPROC GLeeFuncPtr_glGetObjectBufferivATI=GLee_Lazy_glGetObjectBufferivATI;
#endif
#ifndef GLEE_C_DEFINED_glFreeObjectBufferATI
#define GLEE_C_DEFINED_glFreeObjectBufferATI
void __stdcall GLee_Lazy_glFreeObjectBufferATI(GLuint buffer) {if (GLeeInit()) glFreeObjectBufferATI(buffer);}
GLEEPFNGLFREEOBJECTBUFFERATIPROC GLeeFuncPtr_glFreeObjectBufferATI=GLee_Lazy_glFreeObjectBufferATI;
#endif
#ifndef GLEE_C_DEFINED_glArrayObjectATI
#define GLEE_C_DEFINED_glArrayObjectATI
void __stdcall GLee_Lazy_glArrayObjectATI(GLenum array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset) {if (GLeeInit()) glArrayObjectATI(array, size, type, stride, buffer, offset);}
GLEEPFNGLARRAYOBJECTATIPROC GLeeFuncPtr_glArrayObjectATI=GLee_Lazy_glArrayObjectATI;
#endif
#ifndef GLEE_C_DEFINED_glGetArrayObjectfvATI
#define GLEE_C_DEFINED_glGetArrayObjectfvATI
void __stdcall GLee_Lazy_glGetArrayObjectfvATI(GLenum array, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetArrayObjectfvATI(array, pname, params);}
GLEEPFNGLGETARRAYOBJECTFVATIPROC GLeeFuncPtr_glGetArrayObjectfvATI=GLee_Lazy_glGetArrayObjectfvATI;
#endif
#ifndef GLEE_C_DEFINED_glGetArrayObjectivATI
#define GLEE_C_DEFINED_glGetArrayObjectivATI
void __stdcall GLee_Lazy_glGetArrayObjectivATI(GLenum array, GLenum pname, GLint * params) {if (GLeeInit()) glGetArrayObjectivATI(array, pname, params);}
GLEEPFNGLGETARRAYOBJECTIVATIPROC GLeeFuncPtr_glGetArrayObjectivATI=GLee_Lazy_glGetArrayObjectivATI;
#endif
#ifndef GLEE_C_DEFINED_glVariantArrayObjectATI
#define GLEE_C_DEFINED_glVariantArrayObjectATI
void __stdcall GLee_Lazy_glVariantArrayObjectATI(GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset) {if (GLeeInit()) glVariantArrayObjectATI(id, type, stride, buffer, offset);}
GLEEPFNGLVARIANTARRAYOBJECTATIPROC GLeeFuncPtr_glVariantArrayObjectATI=GLee_Lazy_glVariantArrayObjectATI;
#endif
#ifndef GLEE_C_DEFINED_glGetVariantArrayObjectfvATI
#define GLEE_C_DEFINED_glGetVariantArrayObjectfvATI
void __stdcall GLee_Lazy_glGetVariantArrayObjectfvATI(GLuint id, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetVariantArrayObjectfvATI(id, pname, params);}
GLEEPFNGLGETVARIANTARRAYOBJECTFVATIPROC GLeeFuncPtr_glGetVariantArrayObjectfvATI=GLee_Lazy_glGetVariantArrayObjectfvATI;
#endif
#ifndef GLEE_C_DEFINED_glGetVariantArrayObjectivATI
#define GLEE_C_DEFINED_glGetVariantArrayObjectivATI
void __stdcall GLee_Lazy_glGetVariantArrayObjectivATI(GLuint id, GLenum pname, GLint * params) {if (GLeeInit()) glGetVariantArrayObjectivATI(id, pname, params);}
GLEEPFNGLGETVARIANTARRAYOBJECTIVATIPROC GLeeFuncPtr_glGetVariantArrayObjectivATI=GLee_Lazy_glGetVariantArrayObjectivATI;
#endif
#endif
/* GL_EXT_vertex_shader */
#ifdef __GLEE_GL_EXT_vertex_shader
#ifndef GLEE_C_DEFINED_glBeginVertexShaderEXT
#define GLEE_C_DEFINED_glBeginVertexShaderEXT
void __stdcall GLee_Lazy_glBeginVertexShaderEXT(void) {if (GLeeInit()) glBeginVertexShaderEXT();}
GLEEPFNGLBEGINVERTEXSHADEREXTPROC GLeeFuncPtr_glBeginVertexShaderEXT=GLee_Lazy_glBeginVertexShaderEXT;
#endif
#ifndef GLEE_C_DEFINED_glEndVertexShaderEXT
#define GLEE_C_DEFINED_glEndVertexShaderEXT
void __stdcall GLee_Lazy_glEndVertexShaderEXT(void) {if (GLeeInit()) glEndVertexShaderEXT();}
GLEEPFNGLENDVERTEXSHADEREXTPROC GLeeFuncPtr_glEndVertexShaderEXT=GLee_Lazy_glEndVertexShaderEXT;
#endif
#ifndef GLEE_C_DEFINED_glBindVertexShaderEXT
#define GLEE_C_DEFINED_glBindVertexShaderEXT
void __stdcall GLee_Lazy_glBindVertexShaderEXT(GLuint id) {if (GLeeInit()) glBindVertexShaderEXT(id);}
GLEEPFNGLBINDVERTEXSHADEREXTPROC GLeeFuncPtr_glBindVertexShaderEXT=GLee_Lazy_glBindVertexShaderEXT;
#endif
#ifndef GLEE_C_DEFINED_glGenVertexShadersEXT
#define GLEE_C_DEFINED_glGenVertexShadersEXT
GLuint __stdcall GLee_Lazy_glGenVertexShadersEXT(GLuint range) {if (GLeeInit()) return glGenVertexShadersEXT(range); return (GLuint)0;}
GLEEPFNGLGENVERTEXSHADERSEXTPROC GLeeFuncPtr_glGenVertexShadersEXT=GLee_Lazy_glGenVertexShadersEXT;
#endif
#ifndef GLEE_C_DEFINED_glDeleteVertexShaderEXT
#define GLEE_C_DEFINED_glDeleteVertexShaderEXT
void __stdcall GLee_Lazy_glDeleteVertexShaderEXT(GLuint id) {if (GLeeInit()) glDeleteVertexShaderEXT(id);}
GLEEPFNGLDELETEVERTEXSHADEREXTPROC GLeeFuncPtr_glDeleteVertexShaderEXT=GLee_Lazy_glDeleteVertexShaderEXT;
#endif
#ifndef GLEE_C_DEFINED_glShaderOp1EXT
#define GLEE_C_DEFINED_glShaderOp1EXT
void __stdcall GLee_Lazy_glShaderOp1EXT(GLenum op, GLuint res, GLuint arg1) {if (GLeeInit()) glShaderOp1EXT(op, res, arg1);}
GLEEPFNGLSHADEROP1EXTPROC GLeeFuncPtr_glShaderOp1EXT=GLee_Lazy_glShaderOp1EXT;
#endif
#ifndef GLEE_C_DEFINED_glShaderOp2EXT
#define GLEE_C_DEFINED_glShaderOp2EXT
void __stdcall GLee_Lazy_glShaderOp2EXT(GLenum op, GLuint res, GLuint arg1, GLuint arg2) {if (GLeeInit()) glShaderOp2EXT(op, res, arg1, arg2);}
GLEEPFNGLSHADEROP2EXTPROC GLeeFuncPtr_glShaderOp2EXT=GLee_Lazy_glShaderOp2EXT;
#endif
#ifndef GLEE_C_DEFINED_glShaderOp3EXT
#define GLEE_C_DEFINED_glShaderOp3EXT
void __stdcall GLee_Lazy_glShaderOp3EXT(GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3) {if (GLeeInit()) glShaderOp3EXT(op, res, arg1, arg2, arg3);}
GLEEPFNGLSHADEROP3EXTPROC GLeeFuncPtr_glShaderOp3EXT=GLee_Lazy_glShaderOp3EXT;
#endif
#ifndef GLEE_C_DEFINED_glSwizzleEXT
#define GLEE_C_DEFINED_glSwizzleEXT
void __stdcall GLee_Lazy_glSwizzleEXT(GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW) {if (GLeeInit()) glSwizzleEXT(res, in, outX, outY, outZ, outW);}
GLEEPFNGLSWIZZLEEXTPROC GLeeFuncPtr_glSwizzleEXT=GLee_Lazy_glSwizzleEXT;
#endif
#ifndef GLEE_C_DEFINED_glWriteMaskEXT
#define GLEE_C_DEFINED_glWriteMaskEXT
void __stdcall GLee_Lazy_glWriteMaskEXT(GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW) {if (GLeeInit()) glWriteMaskEXT(res, in, outX, outY, outZ, outW);}
GLEEPFNGLWRITEMASKEXTPROC GLeeFuncPtr_glWriteMaskEXT=GLee_Lazy_glWriteMaskEXT;
#endif
#ifndef GLEE_C_DEFINED_glInsertComponentEXT
#define GLEE_C_DEFINED_glInsertComponentEXT
void __stdcall GLee_Lazy_glInsertComponentEXT(GLuint res, GLuint src, GLuint num) {if (GLeeInit()) glInsertComponentEXT(res, src, num);}
GLEEPFNGLINSERTCOMPONENTEXTPROC GLeeFuncPtr_glInsertComponentEXT=GLee_Lazy_glInsertComponentEXT;
#endif
#ifndef GLEE_C_DEFINED_glExtractComponentEXT
#define GLEE_C_DEFINED_glExtractComponentEXT
void __stdcall GLee_Lazy_glExtractComponentEXT(GLuint res, GLuint src, GLuint num) {if (GLeeInit()) glExtractComponentEXT(res, src, num);}
GLEEPFNGLEXTRACTCOMPONENTEXTPROC GLeeFuncPtr_glExtractComponentEXT=GLee_Lazy_glExtractComponentEXT;
#endif
#ifndef GLEE_C_DEFINED_glGenSymbolsEXT
#define GLEE_C_DEFINED_glGenSymbolsEXT
GLuint __stdcall GLee_Lazy_glGenSymbolsEXT(GLenum datatype, GLenum storagetype, GLenum range, GLuint components) {if (GLeeInit()) return glGenSymbolsEXT(datatype, storagetype, range, components); return (GLuint)0;}
GLEEPFNGLGENSYMBOLSEXTPROC GLeeFuncPtr_glGenSymbolsEXT=GLee_Lazy_glGenSymbolsEXT;
#endif
#ifndef GLEE_C_DEFINED_glSetInvariantEXT
#define GLEE_C_DEFINED_glSetInvariantEXT
void __stdcall GLee_Lazy_glSetInvariantEXT(GLuint id, GLenum type, const GLvoid * addr) {if (GLeeInit()) glSetInvariantEXT(id, type, addr);}
GLEEPFNGLSETINVARIANTEXTPROC GLeeFuncPtr_glSetInvariantEXT=GLee_Lazy_glSetInvariantEXT;
#endif
#ifndef GLEE_C_DEFINED_glSetLocalConstantEXT
#define GLEE_C_DEFINED_glSetLocalConstantEXT
void __stdcall GLee_Lazy_glSetLocalConstantEXT(GLuint id, GLenum type, const GLvoid * addr) {if (GLeeInit()) glSetLocalConstantEXT(id, type, addr);}
GLEEPFNGLSETLOCALCONSTANTEXTPROC GLeeFuncPtr_glSetLocalConstantEXT=GLee_Lazy_glSetLocalConstantEXT;
#endif
#ifndef GLEE_C_DEFINED_glVariantbvEXT
#define GLEE_C_DEFINED_glVariantbvEXT
void __stdcall GLee_Lazy_glVariantbvEXT(GLuint id, const GLbyte * addr) {if (GLeeInit()) glVariantbvEXT(id, addr);}
GLEEPFNGLVARIANTBVEXTPROC GLeeFuncPtr_glVariantbvEXT=GLee_Lazy_glVariantbvEXT;
#endif
#ifndef GLEE_C_DEFINED_glVariantsvEXT
#define GLEE_C_DEFINED_glVariantsvEXT
void __stdcall GLee_Lazy_glVariantsvEXT(GLuint id, const GLshort * addr) {if (GLeeInit()) glVariantsvEXT(id, addr);}
GLEEPFNGLVARIANTSVEXTPROC GLeeFuncPtr_glVariantsvEXT=GLee_Lazy_glVariantsvEXT;
#endif
#ifndef GLEE_C_DEFINED_glVariantivEXT
#define GLEE_C_DEFINED_glVariantivEXT
void __stdcall GLee_Lazy_glVariantivEXT(GLuint id, const GLint * addr) {if (GLeeInit()) glVariantivEXT(id, addr);}
GLEEPFNGLVARIANTIVEXTPROC GLeeFuncPtr_glVariantivEXT=GLee_Lazy_glVariantivEXT;
#endif
#ifndef GLEE_C_DEFINED_glVariantfvEXT
#define GLEE_C_DEFINED_glVariantfvEXT
void __stdcall GLee_Lazy_glVariantfvEXT(GLuint id, const GLfloat * addr) {if (GLeeInit()) glVariantfvEXT(id, addr);}
GLEEPFNGLVARIANTFVEXTPROC GLeeFuncPtr_glVariantfvEXT=GLee_Lazy_glVariantfvEXT;
#endif
#ifndef GLEE_C_DEFINED_glVariantdvEXT
#define GLEE_C_DEFINED_glVariantdvEXT
void __stdcall GLee_Lazy_glVariantdvEXT(GLuint id, const GLdouble * addr) {if (GLeeInit()) glVariantdvEXT(id, addr);}
GLEEPFNGLVARIANTDVEXTPROC GLeeFuncPtr_glVariantdvEXT=GLee_Lazy_glVariantdvEXT;
#endif
#ifndef GLEE_C_DEFINED_glVariantubvEXT
#define GLEE_C_DEFINED_glVariantubvEXT
void __stdcall GLee_Lazy_glVariantubvEXT(GLuint id, const GLubyte * addr) {if (GLeeInit()) glVariantubvEXT(id, addr);}
GLEEPFNGLVARIANTUBVEXTPROC GLeeFuncPtr_glVariantubvEXT=GLee_Lazy_glVariantubvEXT;
#endif
#ifndef GLEE_C_DEFINED_glVariantusvEXT
#define GLEE_C_DEFINED_glVariantusvEXT
void __stdcall GLee_Lazy_glVariantusvEXT(GLuint id, const GLushort * addr) {if (GLeeInit()) glVariantusvEXT(id, addr);}
GLEEPFNGLVARIANTUSVEXTPROC GLeeFuncPtr_glVariantusvEXT=GLee_Lazy_glVariantusvEXT;
#endif
#ifndef GLEE_C_DEFINED_glVariantuivEXT
#define GLEE_C_DEFINED_glVariantuivEXT
void __stdcall GLee_Lazy_glVariantuivEXT(GLuint id, const GLuint * addr) {if (GLeeInit()) glVariantuivEXT(id, addr);}
GLEEPFNGLVARIANTUIVEXTPROC GLeeFuncPtr_glVariantuivEXT=GLee_Lazy_glVariantuivEXT;
#endif
#ifndef GLEE_C_DEFINED_glVariantPointerEXT
#define GLEE_C_DEFINED_glVariantPointerEXT
void __stdcall GLee_Lazy_glVariantPointerEXT(GLuint id, GLenum type, GLuint stride, const GLvoid * addr) {if (GLeeInit()) glVariantPointerEXT(id, type, stride, addr);}
GLEEPFNGLVARIANTPOINTEREXTPROC GLeeFuncPtr_glVariantPointerEXT=GLee_Lazy_glVariantPointerEXT;
#endif
#ifndef GLEE_C_DEFINED_glEnableVariantClientStateEXT
#define GLEE_C_DEFINED_glEnableVariantClientStateEXT
void __stdcall GLee_Lazy_glEnableVariantClientStateEXT(GLuint id) {if (GLeeInit()) glEnableVariantClientStateEXT(id);}
GLEEPFNGLENABLEVARIANTCLIENTSTATEEXTPROC GLeeFuncPtr_glEnableVariantClientStateEXT=GLee_Lazy_glEnableVariantClientStateEXT;
#endif
#ifndef GLEE_C_DEFINED_glDisableVariantClientStateEXT
#define GLEE_C_DEFINED_glDisableVariantClientStateEXT
void __stdcall GLee_Lazy_glDisableVariantClientStateEXT(GLuint id) {if (GLeeInit()) glDisableVariantClientStateEXT(id);}
GLEEPFNGLDISABLEVARIANTCLIENTSTATEEXTPROC GLeeFuncPtr_glDisableVariantClientStateEXT=GLee_Lazy_glDisableVariantClientStateEXT;
#endif
#ifndef GLEE_C_DEFINED_glBindLightParameterEXT
#define GLEE_C_DEFINED_glBindLightParameterEXT
GLuint __stdcall GLee_Lazy_glBindLightParameterEXT(GLenum light, GLenum value) {if (GLeeInit()) return glBindLightParameterEXT(light, value); return (GLuint)0;}
GLEEPFNGLBINDLIGHTPARAMETEREXTPROC GLeeFuncPtr_glBindLightParameterEXT=GLee_Lazy_glBindLightParameterEXT;
#endif
#ifndef GLEE_C_DEFINED_glBindMaterialParameterEXT
#define GLEE_C_DEFINED_glBindMaterialParameterEXT
GLuint __stdcall GLee_Lazy_glBindMaterialParameterEXT(GLenum face, GLenum value) {if (GLeeInit()) return glBindMaterialParameterEXT(face, value); return (GLuint)0;}
GLEEPFNGLBINDMATERIALPARAMETEREXTPROC GLeeFuncPtr_glBindMaterialParameterEXT=GLee_Lazy_glBindMaterialParameterEXT;
#endif
#ifndef GLEE_C_DEFINED_glBindTexGenParameterEXT
#define GLEE_C_DEFINED_glBindTexGenParameterEXT
GLuint __stdcall GLee_Lazy_glBindTexGenParameterEXT(GLenum unit, GLenum coord, GLenum value) {if (GLeeInit()) return glBindTexGenParameterEXT(unit, coord, value); return (GLuint)0;}
GLEEPFNGLBINDTEXGENPARAMETEREXTPROC GLeeFuncPtr_glBindTexGenParameterEXT=GLee_Lazy_glBindTexGenParameterEXT;
#endif
#ifndef GLEE_C_DEFINED_glBindTextureUnitParameterEXT
#define GLEE_C_DEFINED_glBindTextureUnitParameterEXT
GLuint __stdcall GLee_Lazy_glBindTextureUnitParameterEXT(GLenum unit, GLenum value) {if (GLeeInit()) return glBindTextureUnitParameterEXT(unit, value); return (GLuint)0;}
GLEEPFNGLBINDTEXTUREUNITPARAMETEREXTPROC GLeeFuncPtr_glBindTextureUnitParameterEXT=GLee_Lazy_glBindTextureUnitParameterEXT;
#endif
#ifndef GLEE_C_DEFINED_glBindParameterEXT
#define GLEE_C_DEFINED_glBindParameterEXT
GLuint __stdcall GLee_Lazy_glBindParameterEXT(GLenum value) {if (GLeeInit()) return glBindParameterEXT(value); return (GLuint)0;}
GLEEPFNGLBINDPARAMETEREXTPROC GLeeFuncPtr_glBindParameterEXT=GLee_Lazy_glBindParameterEXT;
#endif
#ifndef GLEE_C_DEFINED_glIsVariantEnabledEXT
#define GLEE_C_DEFINED_glIsVariantEnabledEXT
GLboolean __stdcall GLee_Lazy_glIsVariantEnabledEXT(GLuint id, GLenum cap) {if (GLeeInit()) return glIsVariantEnabledEXT(id, cap); return (GLboolean)0;}
GLEEPFNGLISVARIANTENABLEDEXTPROC GLeeFuncPtr_glIsVariantEnabledEXT=GLee_Lazy_glIsVariantEnabledEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetVariantBooleanvEXT
#define GLEE_C_DEFINED_glGetVariantBooleanvEXT
void __stdcall GLee_Lazy_glGetVariantBooleanvEXT(GLuint id, GLenum value, GLboolean * data) {if (GLeeInit()) glGetVariantBooleanvEXT(id, value, data);}
GLEEPFNGLGETVARIANTBOOLEANVEXTPROC GLeeFuncPtr_glGetVariantBooleanvEXT=GLee_Lazy_glGetVariantBooleanvEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetVariantIntegervEXT
#define GLEE_C_DEFINED_glGetVariantIntegervEXT
void __stdcall GLee_Lazy_glGetVariantIntegervEXT(GLuint id, GLenum value, GLint * data) {if (GLeeInit()) glGetVariantIntegervEXT(id, value, data);}
GLEEPFNGLGETVARIANTINTEGERVEXTPROC GLeeFuncPtr_glGetVariantIntegervEXT=GLee_Lazy_glGetVariantIntegervEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetVariantFloatvEXT
#define GLEE_C_DEFINED_glGetVariantFloatvEXT
void __stdcall GLee_Lazy_glGetVariantFloatvEXT(GLuint id, GLenum value, GLfloat * data) {if (GLeeInit()) glGetVariantFloatvEXT(id, value, data);}
GLEEPFNGLGETVARIANTFLOATVEXTPROC GLeeFuncPtr_glGetVariantFloatvEXT=GLee_Lazy_glGetVariantFloatvEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetVariantPointervEXT
#define GLEE_C_DEFINED_glGetVariantPointervEXT
void __stdcall GLee_Lazy_glGetVariantPointervEXT(GLuint id, GLenum value, GLvoid* * data) {if (GLeeInit()) glGetVariantPointervEXT(id, value, data);}
GLEEPFNGLGETVARIANTPOINTERVEXTPROC GLeeFuncPtr_glGetVariantPointervEXT=GLee_Lazy_glGetVariantPointervEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetInvariantBooleanvEXT
#define GLEE_C_DEFINED_glGetInvariantBooleanvEXT
void __stdcall GLee_Lazy_glGetInvariantBooleanvEXT(GLuint id, GLenum value, GLboolean * data) {if (GLeeInit()) glGetInvariantBooleanvEXT(id, value, data);}
GLEEPFNGLGETINVARIANTBOOLEANVEXTPROC GLeeFuncPtr_glGetInvariantBooleanvEXT=GLee_Lazy_glGetInvariantBooleanvEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetInvariantIntegervEXT
#define GLEE_C_DEFINED_glGetInvariantIntegervEXT
void __stdcall GLee_Lazy_glGetInvariantIntegervEXT(GLuint id, GLenum value, GLint * data) {if (GLeeInit()) glGetInvariantIntegervEXT(id, value, data);}
GLEEPFNGLGETINVARIANTINTEGERVEXTPROC GLeeFuncPtr_glGetInvariantIntegervEXT=GLee_Lazy_glGetInvariantIntegervEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetInvariantFloatvEXT
#define GLEE_C_DEFINED_glGetInvariantFloatvEXT
void __stdcall GLee_Lazy_glGetInvariantFloatvEXT(GLuint id, GLenum value, GLfloat * data) {if (GLeeInit()) glGetInvariantFloatvEXT(id, value, data);}
GLEEPFNGLGETINVARIANTFLOATVEXTPROC GLeeFuncPtr_glGetInvariantFloatvEXT=GLee_Lazy_glGetInvariantFloatvEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetLocalConstantBooleanvEXT
#define GLEE_C_DEFINED_glGetLocalConstantBooleanvEXT
void __stdcall GLee_Lazy_glGetLocalConstantBooleanvEXT(GLuint id, GLenum value, GLboolean * data) {if (GLeeInit()) glGetLocalConstantBooleanvEXT(id, value, data);}
GLEEPFNGLGETLOCALCONSTANTBOOLEANVEXTPROC GLeeFuncPtr_glGetLocalConstantBooleanvEXT=GLee_Lazy_glGetLocalConstantBooleanvEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetLocalConstantIntegervEXT
#define GLEE_C_DEFINED_glGetLocalConstantIntegervEXT
void __stdcall GLee_Lazy_glGetLocalConstantIntegervEXT(GLuint id, GLenum value, GLint * data) {if (GLeeInit()) glGetLocalConstantIntegervEXT(id, value, data);}
GLEEPFNGLGETLOCALCONSTANTINTEGERVEXTPROC GLeeFuncPtr_glGetLocalConstantIntegervEXT=GLee_Lazy_glGetLocalConstantIntegervEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetLocalConstantFloatvEXT
#define GLEE_C_DEFINED_glGetLocalConstantFloatvEXT
void __stdcall GLee_Lazy_glGetLocalConstantFloatvEXT(GLuint id, GLenum value, GLfloat * data) {if (GLeeInit()) glGetLocalConstantFloatvEXT(id, value, data);}
GLEEPFNGLGETLOCALCONSTANTFLOATVEXTPROC GLeeFuncPtr_glGetLocalConstantFloatvEXT=GLee_Lazy_glGetLocalConstantFloatvEXT;
#endif
#endif
/* GL_ATI_vertex_streams */
#ifdef __GLEE_GL_ATI_vertex_streams
#ifndef GLEE_C_DEFINED_glVertexStream1sATI
#define GLEE_C_DEFINED_glVertexStream1sATI
void __stdcall GLee_Lazy_glVertexStream1sATI(GLenum stream, GLshort x) {if (GLeeInit()) glVertexStream1sATI(stream, x);}
GLEEPFNGLVERTEXSTREAM1SATIPROC GLeeFuncPtr_glVertexStream1sATI=GLee_Lazy_glVertexStream1sATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream1svATI
#define GLEE_C_DEFINED_glVertexStream1svATI
void __stdcall GLee_Lazy_glVertexStream1svATI(GLenum stream, const GLshort * coords) {if (GLeeInit()) glVertexStream1svATI(stream, coords);}
GLEEPFNGLVERTEXSTREAM1SVATIPROC GLeeFuncPtr_glVertexStream1svATI=GLee_Lazy_glVertexStream1svATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream1iATI
#define GLEE_C_DEFINED_glVertexStream1iATI
void __stdcall GLee_Lazy_glVertexStream1iATI(GLenum stream, GLint x) {if (GLeeInit()) glVertexStream1iATI(stream, x);}
GLEEPFNGLVERTEXSTREAM1IATIPROC GLeeFuncPtr_glVertexStream1iATI=GLee_Lazy_glVertexStream1iATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream1ivATI
#define GLEE_C_DEFINED_glVertexStream1ivATI
void __stdcall GLee_Lazy_glVertexStream1ivATI(GLenum stream, const GLint * coords) {if (GLeeInit()) glVertexStream1ivATI(stream, coords);}
GLEEPFNGLVERTEXSTREAM1IVATIPROC GLeeFuncPtr_glVertexStream1ivATI=GLee_Lazy_glVertexStream1ivATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream1fATI
#define GLEE_C_DEFINED_glVertexStream1fATI
void __stdcall GLee_Lazy_glVertexStream1fATI(GLenum stream, GLfloat x) {if (GLeeInit()) glVertexStream1fATI(stream, x);}
GLEEPFNGLVERTEXSTREAM1FATIPROC GLeeFuncPtr_glVertexStream1fATI=GLee_Lazy_glVertexStream1fATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream1fvATI
#define GLEE_C_DEFINED_glVertexStream1fvATI
void __stdcall GLee_Lazy_glVertexStream1fvATI(GLenum stream, const GLfloat * coords) {if (GLeeInit()) glVertexStream1fvATI(stream, coords);}
GLEEPFNGLVERTEXSTREAM1FVATIPROC GLeeFuncPtr_glVertexStream1fvATI=GLee_Lazy_glVertexStream1fvATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream1dATI
#define GLEE_C_DEFINED_glVertexStream1dATI
void __stdcall GLee_Lazy_glVertexStream1dATI(GLenum stream, GLdouble x) {if (GLeeInit()) glVertexStream1dATI(stream, x);}
GLEEPFNGLVERTEXSTREAM1DATIPROC GLeeFuncPtr_glVertexStream1dATI=GLee_Lazy_glVertexStream1dATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream1dvATI
#define GLEE_C_DEFINED_glVertexStream1dvATI
void __stdcall GLee_Lazy_glVertexStream1dvATI(GLenum stream, const GLdouble * coords) {if (GLeeInit()) glVertexStream1dvATI(stream, coords);}
GLEEPFNGLVERTEXSTREAM1DVATIPROC GLeeFuncPtr_glVertexStream1dvATI=GLee_Lazy_glVertexStream1dvATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream2sATI
#define GLEE_C_DEFINED_glVertexStream2sATI
void __stdcall GLee_Lazy_glVertexStream2sATI(GLenum stream, GLshort x, GLshort y) {if (GLeeInit()) glVertexStream2sATI(stream, x, y);}
GLEEPFNGLVERTEXSTREAM2SATIPROC GLeeFuncPtr_glVertexStream2sATI=GLee_Lazy_glVertexStream2sATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream2svATI
#define GLEE_C_DEFINED_glVertexStream2svATI
void __stdcall GLee_Lazy_glVertexStream2svATI(GLenum stream, const GLshort * coords) {if (GLeeInit()) glVertexStream2svATI(stream, coords);}
GLEEPFNGLVERTEXSTREAM2SVATIPROC GLeeFuncPtr_glVertexStream2svATI=GLee_Lazy_glVertexStream2svATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream2iATI
#define GLEE_C_DEFINED_glVertexStream2iATI
void __stdcall GLee_Lazy_glVertexStream2iATI(GLenum stream, GLint x, GLint y) {if (GLeeInit()) glVertexStream2iATI(stream, x, y);}
GLEEPFNGLVERTEXSTREAM2IATIPROC GLeeFuncPtr_glVertexStream2iATI=GLee_Lazy_glVertexStream2iATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream2ivATI
#define GLEE_C_DEFINED_glVertexStream2ivATI
void __stdcall GLee_Lazy_glVertexStream2ivATI(GLenum stream, const GLint * coords) {if (GLeeInit()) glVertexStream2ivATI(stream, coords);}
GLEEPFNGLVERTEXSTREAM2IVATIPROC GLeeFuncPtr_glVertexStream2ivATI=GLee_Lazy_glVertexStream2ivATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream2fATI
#define GLEE_C_DEFINED_glVertexStream2fATI
void __stdcall GLee_Lazy_glVertexStream2fATI(GLenum stream, GLfloat x, GLfloat y) {if (GLeeInit()) glVertexStream2fATI(stream, x, y);}
GLEEPFNGLVERTEXSTREAM2FATIPROC GLeeFuncPtr_glVertexStream2fATI=GLee_Lazy_glVertexStream2fATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream2fvATI
#define GLEE_C_DEFINED_glVertexStream2fvATI
void __stdcall GLee_Lazy_glVertexStream2fvATI(GLenum stream, const GLfloat * coords) {if (GLeeInit()) glVertexStream2fvATI(stream, coords);}
GLEEPFNGLVERTEXSTREAM2FVATIPROC GLeeFuncPtr_glVertexStream2fvATI=GLee_Lazy_glVertexStream2fvATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream2dATI
#define GLEE_C_DEFINED_glVertexStream2dATI
void __stdcall GLee_Lazy_glVertexStream2dATI(GLenum stream, GLdouble x, GLdouble y) {if (GLeeInit()) glVertexStream2dATI(stream, x, y);}
GLEEPFNGLVERTEXSTREAM2DATIPROC GLeeFuncPtr_glVertexStream2dATI=GLee_Lazy_glVertexStream2dATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream2dvATI
#define GLEE_C_DEFINED_glVertexStream2dvATI
void __stdcall GLee_Lazy_glVertexStream2dvATI(GLenum stream, const GLdouble * coords) {if (GLeeInit()) glVertexStream2dvATI(stream, coords);}
GLEEPFNGLVERTEXSTREAM2DVATIPROC GLeeFuncPtr_glVertexStream2dvATI=GLee_Lazy_glVertexStream2dvATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream3sATI
#define GLEE_C_DEFINED_glVertexStream3sATI
void __stdcall GLee_Lazy_glVertexStream3sATI(GLenum stream, GLshort x, GLshort y, GLshort z) {if (GLeeInit()) glVertexStream3sATI(stream, x, y, z);}
GLEEPFNGLVERTEXSTREAM3SATIPROC GLeeFuncPtr_glVertexStream3sATI=GLee_Lazy_glVertexStream3sATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream3svATI
#define GLEE_C_DEFINED_glVertexStream3svATI
void __stdcall GLee_Lazy_glVertexStream3svATI(GLenum stream, const GLshort * coords) {if (GLeeInit()) glVertexStream3svATI(stream, coords);}
GLEEPFNGLVERTEXSTREAM3SVATIPROC GLeeFuncPtr_glVertexStream3svATI=GLee_Lazy_glVertexStream3svATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream3iATI
#define GLEE_C_DEFINED_glVertexStream3iATI
void __stdcall GLee_Lazy_glVertexStream3iATI(GLenum stream, GLint x, GLint y, GLint z) {if (GLeeInit()) glVertexStream3iATI(stream, x, y, z);}
GLEEPFNGLVERTEXSTREAM3IATIPROC GLeeFuncPtr_glVertexStream3iATI=GLee_Lazy_glVertexStream3iATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream3ivATI
#define GLEE_C_DEFINED_glVertexStream3ivATI
void __stdcall GLee_Lazy_glVertexStream3ivATI(GLenum stream, const GLint * coords) {if (GLeeInit()) glVertexStream3ivATI(stream, coords);}
GLEEPFNGLVERTEXSTREAM3IVATIPROC GLeeFuncPtr_glVertexStream3ivATI=GLee_Lazy_glVertexStream3ivATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream3fATI
#define GLEE_C_DEFINED_glVertexStream3fATI
void __stdcall GLee_Lazy_glVertexStream3fATI(GLenum stream, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glVertexStream3fATI(stream, x, y, z);}
GLEEPFNGLVERTEXSTREAM3FATIPROC GLeeFuncPtr_glVertexStream3fATI=GLee_Lazy_glVertexStream3fATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream3fvATI
#define GLEE_C_DEFINED_glVertexStream3fvATI
void __stdcall GLee_Lazy_glVertexStream3fvATI(GLenum stream, const GLfloat * coords) {if (GLeeInit()) glVertexStream3fvATI(stream, coords);}
GLEEPFNGLVERTEXSTREAM3FVATIPROC GLeeFuncPtr_glVertexStream3fvATI=GLee_Lazy_glVertexStream3fvATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream3dATI
#define GLEE_C_DEFINED_glVertexStream3dATI
void __stdcall GLee_Lazy_glVertexStream3dATI(GLenum stream, GLdouble x, GLdouble y, GLdouble z) {if (GLeeInit()) glVertexStream3dATI(stream, x, y, z);}
GLEEPFNGLVERTEXSTREAM3DATIPROC GLeeFuncPtr_glVertexStream3dATI=GLee_Lazy_glVertexStream3dATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream3dvATI
#define GLEE_C_DEFINED_glVertexStream3dvATI
void __stdcall GLee_Lazy_glVertexStream3dvATI(GLenum stream, const GLdouble * coords) {if (GLeeInit()) glVertexStream3dvATI(stream, coords);}
GLEEPFNGLVERTEXSTREAM3DVATIPROC GLeeFuncPtr_glVertexStream3dvATI=GLee_Lazy_glVertexStream3dvATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream4sATI
#define GLEE_C_DEFINED_glVertexStream4sATI
void __stdcall GLee_Lazy_glVertexStream4sATI(GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w) {if (GLeeInit()) glVertexStream4sATI(stream, x, y, z, w);}
GLEEPFNGLVERTEXSTREAM4SATIPROC GLeeFuncPtr_glVertexStream4sATI=GLee_Lazy_glVertexStream4sATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream4svATI
#define GLEE_C_DEFINED_glVertexStream4svATI
void __stdcall GLee_Lazy_glVertexStream4svATI(GLenum stream, const GLshort * coords) {if (GLeeInit()) glVertexStream4svATI(stream, coords);}
GLEEPFNGLVERTEXSTREAM4SVATIPROC GLeeFuncPtr_glVertexStream4svATI=GLee_Lazy_glVertexStream4svATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream4iATI
#define GLEE_C_DEFINED_glVertexStream4iATI
void __stdcall GLee_Lazy_glVertexStream4iATI(GLenum stream, GLint x, GLint y, GLint z, GLint w) {if (GLeeInit()) glVertexStream4iATI(stream, x, y, z, w);}
GLEEPFNGLVERTEXSTREAM4IATIPROC GLeeFuncPtr_glVertexStream4iATI=GLee_Lazy_glVertexStream4iATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream4ivATI
#define GLEE_C_DEFINED_glVertexStream4ivATI
void __stdcall GLee_Lazy_glVertexStream4ivATI(GLenum stream, const GLint * coords) {if (GLeeInit()) glVertexStream4ivATI(stream, coords);}
GLEEPFNGLVERTEXSTREAM4IVATIPROC GLeeFuncPtr_glVertexStream4ivATI=GLee_Lazy_glVertexStream4ivATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream4fATI
#define GLEE_C_DEFINED_glVertexStream4fATI
void __stdcall GLee_Lazy_glVertexStream4fATI(GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {if (GLeeInit()) glVertexStream4fATI(stream, x, y, z, w);}
GLEEPFNGLVERTEXSTREAM4FATIPROC GLeeFuncPtr_glVertexStream4fATI=GLee_Lazy_glVertexStream4fATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream4fvATI
#define GLEE_C_DEFINED_glVertexStream4fvATI
void __stdcall GLee_Lazy_glVertexStream4fvATI(GLenum stream, const GLfloat * coords) {if (GLeeInit()) glVertexStream4fvATI(stream, coords);}
GLEEPFNGLVERTEXSTREAM4FVATIPROC GLeeFuncPtr_glVertexStream4fvATI=GLee_Lazy_glVertexStream4fvATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream4dATI
#define GLEE_C_DEFINED_glVertexStream4dATI
void __stdcall GLee_Lazy_glVertexStream4dATI(GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {if (GLeeInit()) glVertexStream4dATI(stream, x, y, z, w);}
GLEEPFNGLVERTEXSTREAM4DATIPROC GLeeFuncPtr_glVertexStream4dATI=GLee_Lazy_glVertexStream4dATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexStream4dvATI
#define GLEE_C_DEFINED_glVertexStream4dvATI
void __stdcall GLee_Lazy_glVertexStream4dvATI(GLenum stream, const GLdouble * coords) {if (GLeeInit()) glVertexStream4dvATI(stream, coords);}
GLEEPFNGLVERTEXSTREAM4DVATIPROC GLeeFuncPtr_glVertexStream4dvATI=GLee_Lazy_glVertexStream4dvATI;
#endif
#ifndef GLEE_C_DEFINED_glNormalStream3bATI
#define GLEE_C_DEFINED_glNormalStream3bATI
void __stdcall GLee_Lazy_glNormalStream3bATI(GLenum stream, GLbyte nx, GLbyte ny, GLbyte nz) {if (GLeeInit()) glNormalStream3bATI(stream, nx, ny, nz);}
GLEEPFNGLNORMALSTREAM3BATIPROC GLeeFuncPtr_glNormalStream3bATI=GLee_Lazy_glNormalStream3bATI;
#endif
#ifndef GLEE_C_DEFINED_glNormalStream3bvATI
#define GLEE_C_DEFINED_glNormalStream3bvATI
void __stdcall GLee_Lazy_glNormalStream3bvATI(GLenum stream, const GLbyte * coords) {if (GLeeInit()) glNormalStream3bvATI(stream, coords);}
GLEEPFNGLNORMALSTREAM3BVATIPROC GLeeFuncPtr_glNormalStream3bvATI=GLee_Lazy_glNormalStream3bvATI;
#endif
#ifndef GLEE_C_DEFINED_glNormalStream3sATI
#define GLEE_C_DEFINED_glNormalStream3sATI
void __stdcall GLee_Lazy_glNormalStream3sATI(GLenum stream, GLshort nx, GLshort ny, GLshort nz) {if (GLeeInit()) glNormalStream3sATI(stream, nx, ny, nz);}
GLEEPFNGLNORMALSTREAM3SATIPROC GLeeFuncPtr_glNormalStream3sATI=GLee_Lazy_glNormalStream3sATI;
#endif
#ifndef GLEE_C_DEFINED_glNormalStream3svATI
#define GLEE_C_DEFINED_glNormalStream3svATI
void __stdcall GLee_Lazy_glNormalStream3svATI(GLenum stream, const GLshort * coords) {if (GLeeInit()) glNormalStream3svATI(stream, coords);}
GLEEPFNGLNORMALSTREAM3SVATIPROC GLeeFuncPtr_glNormalStream3svATI=GLee_Lazy_glNormalStream3svATI;
#endif
#ifndef GLEE_C_DEFINED_glNormalStream3iATI
#define GLEE_C_DEFINED_glNormalStream3iATI
void __stdcall GLee_Lazy_glNormalStream3iATI(GLenum stream, GLint nx, GLint ny, GLint nz) {if (GLeeInit()) glNormalStream3iATI(stream, nx, ny, nz);}
GLEEPFNGLNORMALSTREAM3IATIPROC GLeeFuncPtr_glNormalStream3iATI=GLee_Lazy_glNormalStream3iATI;
#endif
#ifndef GLEE_C_DEFINED_glNormalStream3ivATI
#define GLEE_C_DEFINED_glNormalStream3ivATI
void __stdcall GLee_Lazy_glNormalStream3ivATI(GLenum stream, const GLint * coords) {if (GLeeInit()) glNormalStream3ivATI(stream, coords);}
GLEEPFNGLNORMALSTREAM3IVATIPROC GLeeFuncPtr_glNormalStream3ivATI=GLee_Lazy_glNormalStream3ivATI;
#endif
#ifndef GLEE_C_DEFINED_glNormalStream3fATI
#define GLEE_C_DEFINED_glNormalStream3fATI
void __stdcall GLee_Lazy_glNormalStream3fATI(GLenum stream, GLfloat nx, GLfloat ny, GLfloat nz) {if (GLeeInit()) glNormalStream3fATI(stream, nx, ny, nz);}
GLEEPFNGLNORMALSTREAM3FATIPROC GLeeFuncPtr_glNormalStream3fATI=GLee_Lazy_glNormalStream3fATI;
#endif
#ifndef GLEE_C_DEFINED_glNormalStream3fvATI
#define GLEE_C_DEFINED_glNormalStream3fvATI
void __stdcall GLee_Lazy_glNormalStream3fvATI(GLenum stream, const GLfloat * coords) {if (GLeeInit()) glNormalStream3fvATI(stream, coords);}
GLEEPFNGLNORMALSTREAM3FVATIPROC GLeeFuncPtr_glNormalStream3fvATI=GLee_Lazy_glNormalStream3fvATI;
#endif
#ifndef GLEE_C_DEFINED_glNormalStream3dATI
#define GLEE_C_DEFINED_glNormalStream3dATI
void __stdcall GLee_Lazy_glNormalStream3dATI(GLenum stream, GLdouble nx, GLdouble ny, GLdouble nz) {if (GLeeInit()) glNormalStream3dATI(stream, nx, ny, nz);}
GLEEPFNGLNORMALSTREAM3DATIPROC GLeeFuncPtr_glNormalStream3dATI=GLee_Lazy_glNormalStream3dATI;
#endif
#ifndef GLEE_C_DEFINED_glNormalStream3dvATI
#define GLEE_C_DEFINED_glNormalStream3dvATI
void __stdcall GLee_Lazy_glNormalStream3dvATI(GLenum stream, const GLdouble * coords) {if (GLeeInit()) glNormalStream3dvATI(stream, coords);}
GLEEPFNGLNORMALSTREAM3DVATIPROC GLeeFuncPtr_glNormalStream3dvATI=GLee_Lazy_glNormalStream3dvATI;
#endif
#ifndef GLEE_C_DEFINED_glClientActiveVertexStreamATI
#define GLEE_C_DEFINED_glClientActiveVertexStreamATI
void __stdcall GLee_Lazy_glClientActiveVertexStreamATI(GLenum stream) {if (GLeeInit()) glClientActiveVertexStreamATI(stream);}
GLEEPFNGLCLIENTACTIVEVERTEXSTREAMATIPROC GLeeFuncPtr_glClientActiveVertexStreamATI=GLee_Lazy_glClientActiveVertexStreamATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexBlendEnviATI
#define GLEE_C_DEFINED_glVertexBlendEnviATI
void __stdcall GLee_Lazy_glVertexBlendEnviATI(GLenum pname, GLint param) {if (GLeeInit()) glVertexBlendEnviATI(pname, param);}
GLEEPFNGLVERTEXBLENDENVIATIPROC GLeeFuncPtr_glVertexBlendEnviATI=GLee_Lazy_glVertexBlendEnviATI;
#endif
#ifndef GLEE_C_DEFINED_glVertexBlendEnvfATI
#define GLEE_C_DEFINED_glVertexBlendEnvfATI
void __stdcall GLee_Lazy_glVertexBlendEnvfATI(GLenum pname, GLfloat param) {if (GLeeInit()) glVertexBlendEnvfATI(pname, param);}
GLEEPFNGLVERTEXBLENDENVFATIPROC GLeeFuncPtr_glVertexBlendEnvfATI=GLee_Lazy_glVertexBlendEnvfATI;
#endif
#endif
/* GL_ATI_element_array */
#ifdef __GLEE_GL_ATI_element_array
#ifndef GLEE_C_DEFINED_glElementPointerATI
#define GLEE_C_DEFINED_glElementPointerATI
void __stdcall GLee_Lazy_glElementPointerATI(GLenum type, const GLvoid * pointer) {if (GLeeInit()) glElementPointerATI(type, pointer);}
GLEEPFNGLELEMENTPOINTERATIPROC GLeeFuncPtr_glElementPointerATI=GLee_Lazy_glElementPointerATI;
#endif
#ifndef GLEE_C_DEFINED_glDrawElementArrayATI
#define GLEE_C_DEFINED_glDrawElementArrayATI
void __stdcall GLee_Lazy_glDrawElementArrayATI(GLenum mode, GLsizei count) {if (GLeeInit()) glDrawElementArrayATI(mode, count);}
GLEEPFNGLDRAWELEMENTARRAYATIPROC GLeeFuncPtr_glDrawElementArrayATI=GLee_Lazy_glDrawElementArrayATI;
#endif
#ifndef GLEE_C_DEFINED_glDrawRangeElementArrayATI
#define GLEE_C_DEFINED_glDrawRangeElementArrayATI
void __stdcall GLee_Lazy_glDrawRangeElementArrayATI(GLenum mode, GLuint start, GLuint end, GLsizei count) {if (GLeeInit()) glDrawRangeElementArrayATI(mode, start, end, count);}
GLEEPFNGLDRAWRANGEELEMENTARRAYATIPROC GLeeFuncPtr_glDrawRangeElementArrayATI=GLee_Lazy_glDrawRangeElementArrayATI;
#endif
#endif
/* GL_SUN_mesh_array */
#ifdef __GLEE_GL_SUN_mesh_array
#ifndef GLEE_C_DEFINED_glDrawMeshArraysSUN
#define GLEE_C_DEFINED_glDrawMeshArraysSUN
void __stdcall GLee_Lazy_glDrawMeshArraysSUN(GLenum mode, GLint first, GLsizei count, GLsizei width) {if (GLeeInit()) glDrawMeshArraysSUN(mode, first, count, width);}
GLEEPFNGLDRAWMESHARRAYSSUNPROC GLeeFuncPtr_glDrawMeshArraysSUN=GLee_Lazy_glDrawMeshArraysSUN;
#endif
#endif
/* GL_SUN_slice_accum */
#ifdef __GLEE_GL_SUN_slice_accum
#endif
/* GL_NV_multisample_filter_hint */
#ifdef __GLEE_GL_NV_multisample_filter_hint
#endif
/* GL_NV_depth_clamp */
#ifdef __GLEE_GL_NV_depth_clamp
#endif
/* GL_NV_occlusion_query */
#ifdef __GLEE_GL_NV_occlusion_query
#ifndef GLEE_C_DEFINED_glGenOcclusionQueriesNV
#define GLEE_C_DEFINED_glGenOcclusionQueriesNV
void __stdcall GLee_Lazy_glGenOcclusionQueriesNV(GLsizei n, GLuint * ids) {if (GLeeInit()) glGenOcclusionQueriesNV(n, ids);}
GLEEPFNGLGENOCCLUSIONQUERIESNVPROC GLeeFuncPtr_glGenOcclusionQueriesNV=GLee_Lazy_glGenOcclusionQueriesNV;
#endif
#ifndef GLEE_C_DEFINED_glDeleteOcclusionQueriesNV
#define GLEE_C_DEFINED_glDeleteOcclusionQueriesNV
void __stdcall GLee_Lazy_glDeleteOcclusionQueriesNV(GLsizei n, const GLuint * ids) {if (GLeeInit()) glDeleteOcclusionQueriesNV(n, ids);}
GLEEPFNGLDELETEOCCLUSIONQUERIESNVPROC GLeeFuncPtr_glDeleteOcclusionQueriesNV=GLee_Lazy_glDeleteOcclusionQueriesNV;
#endif
#ifndef GLEE_C_DEFINED_glIsOcclusionQueryNV
#define GLEE_C_DEFINED_glIsOcclusionQueryNV
GLboolean __stdcall GLee_Lazy_glIsOcclusionQueryNV(GLuint id) {if (GLeeInit()) return glIsOcclusionQueryNV(id); return (GLboolean)0;}
GLEEPFNGLISOCCLUSIONQUERYNVPROC GLeeFuncPtr_glIsOcclusionQueryNV=GLee_Lazy_glIsOcclusionQueryNV;
#endif
#ifndef GLEE_C_DEFINED_glBeginOcclusionQueryNV
#define GLEE_C_DEFINED_glBeginOcclusionQueryNV
void __stdcall GLee_Lazy_glBeginOcclusionQueryNV(GLuint id) {if (GLeeInit()) glBeginOcclusionQueryNV(id);}
GLEEPFNGLBEGINOCCLUSIONQUERYNVPROC GLeeFuncPtr_glBeginOcclusionQueryNV=GLee_Lazy_glBeginOcclusionQueryNV;
#endif
#ifndef GLEE_C_DEFINED_glEndOcclusionQueryNV
#define GLEE_C_DEFINED_glEndOcclusionQueryNV
void __stdcall GLee_Lazy_glEndOcclusionQueryNV(void) {if (GLeeInit()) glEndOcclusionQueryNV();}
GLEEPFNGLENDOCCLUSIONQUERYNVPROC GLeeFuncPtr_glEndOcclusionQueryNV=GLee_Lazy_glEndOcclusionQueryNV;
#endif
#ifndef GLEE_C_DEFINED_glGetOcclusionQueryivNV
#define GLEE_C_DEFINED_glGetOcclusionQueryivNV
void __stdcall GLee_Lazy_glGetOcclusionQueryivNV(GLuint id, GLenum pname, GLint * params) {if (GLeeInit()) glGetOcclusionQueryivNV(id, pname, params);}
GLEEPFNGLGETOCCLUSIONQUERYIVNVPROC GLeeFuncPtr_glGetOcclusionQueryivNV=GLee_Lazy_glGetOcclusionQueryivNV;
#endif
#ifndef GLEE_C_DEFINED_glGetOcclusionQueryuivNV
#define GLEE_C_DEFINED_glGetOcclusionQueryuivNV
void __stdcall GLee_Lazy_glGetOcclusionQueryuivNV(GLuint id, GLenum pname, GLuint * params) {if (GLeeInit()) glGetOcclusionQueryuivNV(id, pname, params);}
GLEEPFNGLGETOCCLUSIONQUERYUIVNVPROC GLeeFuncPtr_glGetOcclusionQueryuivNV=GLee_Lazy_glGetOcclusionQueryuivNV;
#endif
#endif
/* GL_NV_point_sprite */
#ifdef __GLEE_GL_NV_point_sprite
#ifndef GLEE_C_DEFINED_glPointParameteriNV
#define GLEE_C_DEFINED_glPointParameteriNV
void __stdcall GLee_Lazy_glPointParameteriNV(GLenum pname, GLint param) {if (GLeeInit()) glPointParameteriNV(pname, param);}
GLEEPFNGLPOINTPARAMETERINVPROC GLeeFuncPtr_glPointParameteriNV=GLee_Lazy_glPointParameteriNV;
#endif
#ifndef GLEE_C_DEFINED_glPointParameterivNV
#define GLEE_C_DEFINED_glPointParameterivNV
void __stdcall GLee_Lazy_glPointParameterivNV(GLenum pname, const GLint * params) {if (GLeeInit()) glPointParameterivNV(pname, params);}
GLEEPFNGLPOINTPARAMETERIVNVPROC GLeeFuncPtr_glPointParameterivNV=GLee_Lazy_glPointParameterivNV;
#endif
#endif
/* GL_NV_texture_shader3 */
#ifdef __GLEE_GL_NV_texture_shader3
#endif
/* GL_NV_vertex_program1_1 */
#ifdef __GLEE_GL_NV_vertex_program1_1
#endif
/* GL_EXT_shadow_funcs */
#ifdef __GLEE_GL_EXT_shadow_funcs
#endif
/* GL_EXT_stencil_two_side */
#ifdef __GLEE_GL_EXT_stencil_two_side
#ifndef GLEE_C_DEFINED_glActiveStencilFaceEXT
#define GLEE_C_DEFINED_glActiveStencilFaceEXT
void __stdcall GLee_Lazy_glActiveStencilFaceEXT(GLenum face) {if (GLeeInit()) glActiveStencilFaceEXT(face);}
GLEEPFNGLACTIVESTENCILFACEEXTPROC GLeeFuncPtr_glActiveStencilFaceEXT=GLee_Lazy_glActiveStencilFaceEXT;
#endif
#endif
/* GL_ATI_text_fragment_shader */
#ifdef __GLEE_GL_ATI_text_fragment_shader
#endif
/* GL_APPLE_client_storage */
#ifdef __GLEE_GL_APPLE_client_storage
#endif
/* GL_APPLE_element_array */
#ifdef __GLEE_GL_APPLE_element_array
#ifndef GLEE_C_DEFINED_glElementPointerAPPLE
#define GLEE_C_DEFINED_glElementPointerAPPLE
void __stdcall GLee_Lazy_glElementPointerAPPLE(GLenum type, const GLvoid * pointer) {if (GLeeInit()) glElementPointerAPPLE(type, pointer);}
GLEEPFNGLELEMENTPOINTERAPPLEPROC GLeeFuncPtr_glElementPointerAPPLE=GLee_Lazy_glElementPointerAPPLE;
#endif
#ifndef GLEE_C_DEFINED_glDrawElementArrayAPPLE
#define GLEE_C_DEFINED_glDrawElementArrayAPPLE
void __stdcall GLee_Lazy_glDrawElementArrayAPPLE(GLenum mode, GLint first, GLsizei count) {if (GLeeInit()) glDrawElementArrayAPPLE(mode, first, count);}
GLEEPFNGLDRAWELEMENTARRAYAPPLEPROC GLeeFuncPtr_glDrawElementArrayAPPLE=GLee_Lazy_glDrawElementArrayAPPLE;
#endif
#ifndef GLEE_C_DEFINED_glDrawRangeElementArrayAPPLE
#define GLEE_C_DEFINED_glDrawRangeElementArrayAPPLE
void __stdcall GLee_Lazy_glDrawRangeElementArrayAPPLE(GLenum mode, GLuint start, GLuint end, GLint first, GLsizei count) {if (GLeeInit()) glDrawRangeElementArrayAPPLE(mode, start, end, first, count);}
GLEEPFNGLDRAWRANGEELEMENTARRAYAPPLEPROC GLeeFuncPtr_glDrawRangeElementArrayAPPLE=GLee_Lazy_glDrawRangeElementArrayAPPLE;
#endif
#ifndef GLEE_C_DEFINED_glMultiDrawElementArrayAPPLE
#define GLEE_C_DEFINED_glMultiDrawElementArrayAPPLE
void __stdcall GLee_Lazy_glMultiDrawElementArrayAPPLE(GLenum mode, const GLint * first, const GLsizei * count, GLsizei primcount) {if (GLeeInit()) glMultiDrawElementArrayAPPLE(mode, first, count, primcount);}
GLEEPFNGLMULTIDRAWELEMENTARRAYAPPLEPROC GLeeFuncPtr_glMultiDrawElementArrayAPPLE=GLee_Lazy_glMultiDrawElementArrayAPPLE;
#endif
#ifndef GLEE_C_DEFINED_glMultiDrawRangeElementArrayAPPLE
#define GLEE_C_DEFINED_glMultiDrawRangeElementArrayAPPLE
void __stdcall GLee_Lazy_glMultiDrawRangeElementArrayAPPLE(GLenum mode, GLuint start, GLuint end, const GLint * first, const GLsizei * count, GLsizei primcount) {if (GLeeInit()) glMultiDrawRangeElementArrayAPPLE(mode, start, end, first, count, primcount);}
GLEEPFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC GLeeFuncPtr_glMultiDrawRangeElementArrayAPPLE=GLee_Lazy_glMultiDrawRangeElementArrayAPPLE;
#endif
#endif
/* GL_APPLE_fence */
#ifdef __GLEE_GL_APPLE_fence
#ifndef GLEE_C_DEFINED_glGenFencesAPPLE
#define GLEE_C_DEFINED_glGenFencesAPPLE
void __stdcall GLee_Lazy_glGenFencesAPPLE(GLsizei n, GLuint * fences) {if (GLeeInit()) glGenFencesAPPLE(n, fences);}
GLEEPFNGLGENFENCESAPPLEPROC GLeeFuncPtr_glGenFencesAPPLE=GLee_Lazy_glGenFencesAPPLE;
#endif
#ifndef GLEE_C_DEFINED_glDeleteFencesAPPLE
#define GLEE_C_DEFINED_glDeleteFencesAPPLE
void __stdcall GLee_Lazy_glDeleteFencesAPPLE(GLsizei n, const GLuint * fences) {if (GLeeInit()) glDeleteFencesAPPLE(n, fences);}
GLEEPFNGLDELETEFENCESAPPLEPROC GLeeFuncPtr_glDeleteFencesAPPLE=GLee_Lazy_glDeleteFencesAPPLE;
#endif
#ifndef GLEE_C_DEFINED_glSetFenceAPPLE
#define GLEE_C_DEFINED_glSetFenceAPPLE
void __stdcall GLee_Lazy_glSetFenceAPPLE(GLuint fence) {if (GLeeInit()) glSetFenceAPPLE(fence);}
GLEEPFNGLSETFENCEAPPLEPROC GLeeFuncPtr_glSetFenceAPPLE=GLee_Lazy_glSetFenceAPPLE;
#endif
#ifndef GLEE_C_DEFINED_glIsFenceAPPLE
#define GLEE_C_DEFINED_glIsFenceAPPLE
GLboolean __stdcall GLee_Lazy_glIsFenceAPPLE(GLuint fence) {if (GLeeInit()) return glIsFenceAPPLE(fence); return (GLboolean)0;}
GLEEPFNGLISFENCEAPPLEPROC GLeeFuncPtr_glIsFenceAPPLE=GLee_Lazy_glIsFenceAPPLE;
#endif
#ifndef GLEE_C_DEFINED_glTestFenceAPPLE
#define GLEE_C_DEFINED_glTestFenceAPPLE
GLboolean __stdcall GLee_Lazy_glTestFenceAPPLE(GLuint fence) {if (GLeeInit()) return glTestFenceAPPLE(fence); return (GLboolean)0;}
GLEEPFNGLTESTFENCEAPPLEPROC GLeeFuncPtr_glTestFenceAPPLE=GLee_Lazy_glTestFenceAPPLE;
#endif
#ifndef GLEE_C_DEFINED_glFinishFenceAPPLE
#define GLEE_C_DEFINED_glFinishFenceAPPLE
void __stdcall GLee_Lazy_glFinishFenceAPPLE(GLuint fence) {if (GLeeInit()) glFinishFenceAPPLE(fence);}
GLEEPFNGLFINISHFENCEAPPLEPROC GLeeFuncPtr_glFinishFenceAPPLE=GLee_Lazy_glFinishFenceAPPLE;
#endif
#ifndef GLEE_C_DEFINED_glTestObjectAPPLE
#define GLEE_C_DEFINED_glTestObjectAPPLE
GLboolean __stdcall GLee_Lazy_glTestObjectAPPLE(GLenum object, GLuint name) {if (GLeeInit()) return glTestObjectAPPLE(object, name); return (GLboolean)0;}
GLEEPFNGLTESTOBJECTAPPLEPROC GLeeFuncPtr_glTestObjectAPPLE=GLee_Lazy_glTestObjectAPPLE;
#endif
#ifndef GLEE_C_DEFINED_glFinishObjectAPPLE
#define GLEE_C_DEFINED_glFinishObjectAPPLE
void __stdcall GLee_Lazy_glFinishObjectAPPLE(GLenum object, GLint name) {if (GLeeInit()) glFinishObjectAPPLE(object, name);}
GLEEPFNGLFINISHOBJECTAPPLEPROC GLeeFuncPtr_glFinishObjectAPPLE=GLee_Lazy_glFinishObjectAPPLE;
#endif
#endif
/* GL_APPLE_vertex_array_object */
#ifdef __GLEE_GL_APPLE_vertex_array_object
#ifndef GLEE_C_DEFINED_glBindVertexArrayAPPLE
#define GLEE_C_DEFINED_glBindVertexArrayAPPLE
void __stdcall GLee_Lazy_glBindVertexArrayAPPLE(GLuint array) {if (GLeeInit()) glBindVertexArrayAPPLE(array);}
GLEEPFNGLBINDVERTEXARRAYAPPLEPROC GLeeFuncPtr_glBindVertexArrayAPPLE=GLee_Lazy_glBindVertexArrayAPPLE;
#endif
#ifndef GLEE_C_DEFINED_glDeleteVertexArraysAPPLE
#define GLEE_C_DEFINED_glDeleteVertexArraysAPPLE
void __stdcall GLee_Lazy_glDeleteVertexArraysAPPLE(GLsizei n, const GLuint * arrays) {if (GLeeInit()) glDeleteVertexArraysAPPLE(n, arrays);}
GLEEPFNGLDELETEVERTEXARRAYSAPPLEPROC GLeeFuncPtr_glDeleteVertexArraysAPPLE=GLee_Lazy_glDeleteVertexArraysAPPLE;
#endif
#ifndef GLEE_C_DEFINED_glGenVertexArraysAPPLE
#define GLEE_C_DEFINED_glGenVertexArraysAPPLE
void __stdcall GLee_Lazy_glGenVertexArraysAPPLE(GLsizei n, GLuint * arrays) {if (GLeeInit()) glGenVertexArraysAPPLE(n, arrays);}
GLEEPFNGLGENVERTEXARRAYSAPPLEPROC GLeeFuncPtr_glGenVertexArraysAPPLE=GLee_Lazy_glGenVertexArraysAPPLE;
#endif
#ifndef GLEE_C_DEFINED_glIsVertexArrayAPPLE
#define GLEE_C_DEFINED_glIsVertexArrayAPPLE
GLboolean __stdcall GLee_Lazy_glIsVertexArrayAPPLE(GLuint array) {if (GLeeInit()) return glIsVertexArrayAPPLE(array); return (GLboolean)0;}
GLEEPFNGLISVERTEXARRAYAPPLEPROC GLeeFuncPtr_glIsVertexArrayAPPLE=GLee_Lazy_glIsVertexArrayAPPLE;
#endif
#endif
/* GL_APPLE_vertex_array_range */
#ifdef __GLEE_GL_APPLE_vertex_array_range
#ifndef GLEE_C_DEFINED_glVertexArrayRangeAPPLE
#define GLEE_C_DEFINED_glVertexArrayRangeAPPLE
void __stdcall GLee_Lazy_glVertexArrayRangeAPPLE(GLsizei length, GLvoid * pointer) {if (GLeeInit()) glVertexArrayRangeAPPLE(length, pointer);}
GLEEPFNGLVERTEXARRAYRANGEAPPLEPROC GLeeFuncPtr_glVertexArrayRangeAPPLE=GLee_Lazy_glVertexArrayRangeAPPLE;
#endif
#ifndef GLEE_C_DEFINED_glFlushVertexArrayRangeAPPLE
#define GLEE_C_DEFINED_glFlushVertexArrayRangeAPPLE
void __stdcall GLee_Lazy_glFlushVertexArrayRangeAPPLE(GLsizei length, GLvoid * pointer) {if (GLeeInit()) glFlushVertexArrayRangeAPPLE(length, pointer);}
GLEEPFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC GLeeFuncPtr_glFlushVertexArrayRangeAPPLE=GLee_Lazy_glFlushVertexArrayRangeAPPLE;
#endif
#ifndef GLEE_C_DEFINED_glVertexArrayParameteriAPPLE
#define GLEE_C_DEFINED_glVertexArrayParameteriAPPLE
void __stdcall GLee_Lazy_glVertexArrayParameteriAPPLE(GLenum pname, GLint param) {if (GLeeInit()) glVertexArrayParameteriAPPLE(pname, param);}
GLEEPFNGLVERTEXARRAYPARAMETERIAPPLEPROC GLeeFuncPtr_glVertexArrayParameteriAPPLE=GLee_Lazy_glVertexArrayParameteriAPPLE;
#endif
#endif
/* GL_APPLE_ycbcr_422 */
#ifdef __GLEE_GL_APPLE_ycbcr_422
#endif
/* GL_S3_s3tc */
#ifdef __GLEE_GL_S3_s3tc
#endif
/* GL_ATI_draw_buffers */
#ifdef __GLEE_GL_ATI_draw_buffers
#ifndef GLEE_C_DEFINED_glDrawBuffersATI
#define GLEE_C_DEFINED_glDrawBuffersATI
void __stdcall GLee_Lazy_glDrawBuffersATI(GLsizei n, const GLenum * bufs) {if (GLeeInit()) glDrawBuffersATI(n, bufs);}
GLEEPFNGLDRAWBUFFERSATIPROC GLeeFuncPtr_glDrawBuffersATI=GLee_Lazy_glDrawBuffersATI;
#endif
#endif
/* GL_ATI_pixel_format_float */
#ifdef __GLEE_GL_ATI_pixel_format_float
#endif
/* GL_ATI_texture_env_combine3 */
#ifdef __GLEE_GL_ATI_texture_env_combine3
#endif
/* GL_ATI_texture_float */
#ifdef __GLEE_GL_ATI_texture_float
#endif
/* GL_NV_float_buffer */
#ifdef __GLEE_GL_NV_float_buffer
#endif
/* GL_NV_fragment_program */
#ifdef __GLEE_GL_NV_fragment_program
#ifndef GLEE_C_DEFINED_glProgramNamedParameter4fNV
#define GLEE_C_DEFINED_glProgramNamedParameter4fNV
void __stdcall GLee_Lazy_glProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {if (GLeeInit()) glProgramNamedParameter4fNV(id, len, name, x, y, z, w);}
GLEEPFNGLPROGRAMNAMEDPARAMETER4FNVPROC GLeeFuncPtr_glProgramNamedParameter4fNV=GLee_Lazy_glProgramNamedParameter4fNV;
#endif
#ifndef GLEE_C_DEFINED_glProgramNamedParameter4dNV
#define GLEE_C_DEFINED_glProgramNamedParameter4dNV
void __stdcall GLee_Lazy_glProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {if (GLeeInit()) glProgramNamedParameter4dNV(id, len, name, x, y, z, w);}
GLEEPFNGLPROGRAMNAMEDPARAMETER4DNVPROC GLeeFuncPtr_glProgramNamedParameter4dNV=GLee_Lazy_glProgramNamedParameter4dNV;
#endif
#ifndef GLEE_C_DEFINED_glProgramNamedParameter4fvNV
#define GLEE_C_DEFINED_glProgramNamedParameter4fvNV
void __stdcall GLee_Lazy_glProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte * name, const GLfloat * v) {if (GLeeInit()) glProgramNamedParameter4fvNV(id, len, name, v);}
GLEEPFNGLPROGRAMNAMEDPARAMETER4FVNVPROC GLeeFuncPtr_glProgramNamedParameter4fvNV=GLee_Lazy_glProgramNamedParameter4fvNV;
#endif
#ifndef GLEE_C_DEFINED_glProgramNamedParameter4dvNV
#define GLEE_C_DEFINED_glProgramNamedParameter4dvNV
void __stdcall GLee_Lazy_glProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte * name, const GLdouble * v) {if (GLeeInit()) glProgramNamedParameter4dvNV(id, len, name, v);}
GLEEPFNGLPROGRAMNAMEDPARAMETER4DVNVPROC GLeeFuncPtr_glProgramNamedParameter4dvNV=GLee_Lazy_glProgramNamedParameter4dvNV;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramNamedParameterfvNV
#define GLEE_C_DEFINED_glGetProgramNamedParameterfvNV
void __stdcall GLee_Lazy_glGetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat * params) {if (GLeeInit()) glGetProgramNamedParameterfvNV(id, len, name, params);}
GLEEPFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC GLeeFuncPtr_glGetProgramNamedParameterfvNV=GLee_Lazy_glGetProgramNamedParameterfvNV;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramNamedParameterdvNV
#define GLEE_C_DEFINED_glGetProgramNamedParameterdvNV
void __stdcall GLee_Lazy_glGetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble * params) {if (GLeeInit()) glGetProgramNamedParameterdvNV(id, len, name, params);}
GLEEPFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC GLeeFuncPtr_glGetProgramNamedParameterdvNV=GLee_Lazy_glGetProgramNamedParameterdvNV;
#endif
#endif
/* GL_NV_half_float */
#ifdef __GLEE_GL_NV_half_float
#ifndef GLEE_C_DEFINED_glVertex2hNV
#define GLEE_C_DEFINED_glVertex2hNV
void __stdcall GLee_Lazy_glVertex2hNV(GLhalfNV x, GLhalfNV y) {if (GLeeInit()) glVertex2hNV(x, y);}
GLEEPFNGLVERTEX2HNVPROC GLeeFuncPtr_glVertex2hNV=GLee_Lazy_glVertex2hNV;
#endif
#ifndef GLEE_C_DEFINED_glVertex2hvNV
#define GLEE_C_DEFINED_glVertex2hvNV
void __stdcall GLee_Lazy_glVertex2hvNV(const GLhalfNV * v) {if (GLeeInit()) glVertex2hvNV(v);}
GLEEPFNGLVERTEX2HVNVPROC GLeeFuncPtr_glVertex2hvNV=GLee_Lazy_glVertex2hvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertex3hNV
#define GLEE_C_DEFINED_glVertex3hNV
void __stdcall GLee_Lazy_glVertex3hNV(GLhalfNV x, GLhalfNV y, GLhalfNV z) {if (GLeeInit()) glVertex3hNV(x, y, z);}
GLEEPFNGLVERTEX3HNVPROC GLeeFuncPtr_glVertex3hNV=GLee_Lazy_glVertex3hNV;
#endif
#ifndef GLEE_C_DEFINED_glVertex3hvNV
#define GLEE_C_DEFINED_glVertex3hvNV
void __stdcall GLee_Lazy_glVertex3hvNV(const GLhalfNV * v) {if (GLeeInit()) glVertex3hvNV(v);}
GLEEPFNGLVERTEX3HVNVPROC GLeeFuncPtr_glVertex3hvNV=GLee_Lazy_glVertex3hvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertex4hNV
#define GLEE_C_DEFINED_glVertex4hNV
void __stdcall GLee_Lazy_glVertex4hNV(GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w) {if (GLeeInit()) glVertex4hNV(x, y, z, w);}
GLEEPFNGLVERTEX4HNVPROC GLeeFuncPtr_glVertex4hNV=GLee_Lazy_glVertex4hNV;
#endif
#ifndef GLEE_C_DEFINED_glVertex4hvNV
#define GLEE_C_DEFINED_glVertex4hvNV
void __stdcall GLee_Lazy_glVertex4hvNV(const GLhalfNV * v) {if (GLeeInit()) glVertex4hvNV(v);}
GLEEPFNGLVERTEX4HVNVPROC GLeeFuncPtr_glVertex4hvNV=GLee_Lazy_glVertex4hvNV;
#endif
#ifndef GLEE_C_DEFINED_glNormal3hNV
#define GLEE_C_DEFINED_glNormal3hNV
void __stdcall GLee_Lazy_glNormal3hNV(GLhalfNV nx, GLhalfNV ny, GLhalfNV nz) {if (GLeeInit()) glNormal3hNV(nx, ny, nz);}
GLEEPFNGLNORMAL3HNVPROC GLeeFuncPtr_glNormal3hNV=GLee_Lazy_glNormal3hNV;
#endif
#ifndef GLEE_C_DEFINED_glNormal3hvNV
#define GLEE_C_DEFINED_glNormal3hvNV
void __stdcall GLee_Lazy_glNormal3hvNV(const GLhalfNV * v) {if (GLeeInit()) glNormal3hvNV(v);}
GLEEPFNGLNORMAL3HVNVPROC GLeeFuncPtr_glNormal3hvNV=GLee_Lazy_glNormal3hvNV;
#endif
#ifndef GLEE_C_DEFINED_glColor3hNV
#define GLEE_C_DEFINED_glColor3hNV
void __stdcall GLee_Lazy_glColor3hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue) {if (GLeeInit()) glColor3hNV(red, green, blue);}
GLEEPFNGLCOLOR3HNVPROC GLeeFuncPtr_glColor3hNV=GLee_Lazy_glColor3hNV;
#endif
#ifndef GLEE_C_DEFINED_glColor3hvNV
#define GLEE_C_DEFINED_glColor3hvNV
void __stdcall GLee_Lazy_glColor3hvNV(const GLhalfNV * v) {if (GLeeInit()) glColor3hvNV(v);}
GLEEPFNGLCOLOR3HVNVPROC GLeeFuncPtr_glColor3hvNV=GLee_Lazy_glColor3hvNV;
#endif
#ifndef GLEE_C_DEFINED_glColor4hNV
#define GLEE_C_DEFINED_glColor4hNV
void __stdcall GLee_Lazy_glColor4hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue, GLhalfNV alpha) {if (GLeeInit()) glColor4hNV(red, green, blue, alpha);}
GLEEPFNGLCOLOR4HNVPROC GLeeFuncPtr_glColor4hNV=GLee_Lazy_glColor4hNV;
#endif
#ifndef GLEE_C_DEFINED_glColor4hvNV
#define GLEE_C_DEFINED_glColor4hvNV
void __stdcall GLee_Lazy_glColor4hvNV(const GLhalfNV * v) {if (GLeeInit()) glColor4hvNV(v);}
GLEEPFNGLCOLOR4HVNVPROC GLeeFuncPtr_glColor4hvNV=GLee_Lazy_glColor4hvNV;
#endif
#ifndef GLEE_C_DEFINED_glTexCoord1hNV
#define GLEE_C_DEFINED_glTexCoord1hNV
void __stdcall GLee_Lazy_glTexCoord1hNV(GLhalfNV s) {if (GLeeInit()) glTexCoord1hNV(s);}
GLEEPFNGLTEXCOORD1HNVPROC GLeeFuncPtr_glTexCoord1hNV=GLee_Lazy_glTexCoord1hNV;
#endif
#ifndef GLEE_C_DEFINED_glTexCoord1hvNV
#define GLEE_C_DEFINED_glTexCoord1hvNV
void __stdcall GLee_Lazy_glTexCoord1hvNV(const GLhalfNV * v) {if (GLeeInit()) glTexCoord1hvNV(v);}
GLEEPFNGLTEXCOORD1HVNVPROC GLeeFuncPtr_glTexCoord1hvNV=GLee_Lazy_glTexCoord1hvNV;
#endif
#ifndef GLEE_C_DEFINED_glTexCoord2hNV
#define GLEE_C_DEFINED_glTexCoord2hNV
void __stdcall GLee_Lazy_glTexCoord2hNV(GLhalfNV s, GLhalfNV t) {if (GLeeInit()) glTexCoord2hNV(s, t);}
GLEEPFNGLTEXCOORD2HNVPROC GLeeFuncPtr_glTexCoord2hNV=GLee_Lazy_glTexCoord2hNV;
#endif
#ifndef GLEE_C_DEFINED_glTexCoord2hvNV
#define GLEE_C_DEFINED_glTexCoord2hvNV
void __stdcall GLee_Lazy_glTexCoord2hvNV(const GLhalfNV * v) {if (GLeeInit()) glTexCoord2hvNV(v);}
GLEEPFNGLTEXCOORD2HVNVPROC GLeeFuncPtr_glTexCoord2hvNV=GLee_Lazy_glTexCoord2hvNV;
#endif
#ifndef GLEE_C_DEFINED_glTexCoord3hNV
#define GLEE_C_DEFINED_glTexCoord3hNV
void __stdcall GLee_Lazy_glTexCoord3hNV(GLhalfNV s, GLhalfNV t, GLhalfNV r) {if (GLeeInit()) glTexCoord3hNV(s, t, r);}
GLEEPFNGLTEXCOORD3HNVPROC GLeeFuncPtr_glTexCoord3hNV=GLee_Lazy_glTexCoord3hNV;
#endif
#ifndef GLEE_C_DEFINED_glTexCoord3hvNV
#define GLEE_C_DEFINED_glTexCoord3hvNV
void __stdcall GLee_Lazy_glTexCoord3hvNV(const GLhalfNV * v) {if (GLeeInit()) glTexCoord3hvNV(v);}
GLEEPFNGLTEXCOORD3HVNVPROC GLeeFuncPtr_glTexCoord3hvNV=GLee_Lazy_glTexCoord3hvNV;
#endif
#ifndef GLEE_C_DEFINED_glTexCoord4hNV
#define GLEE_C_DEFINED_glTexCoord4hNV
void __stdcall GLee_Lazy_glTexCoord4hNV(GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q) {if (GLeeInit()) glTexCoord4hNV(s, t, r, q);}
GLEEPFNGLTEXCOORD4HNVPROC GLeeFuncPtr_glTexCoord4hNV=GLee_Lazy_glTexCoord4hNV;
#endif
#ifndef GLEE_C_DEFINED_glTexCoord4hvNV
#define GLEE_C_DEFINED_glTexCoord4hvNV
void __stdcall GLee_Lazy_glTexCoord4hvNV(const GLhalfNV * v) {if (GLeeInit()) glTexCoord4hvNV(v);}
GLEEPFNGLTEXCOORD4HVNVPROC GLeeFuncPtr_glTexCoord4hvNV=GLee_Lazy_glTexCoord4hvNV;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1hNV
#define GLEE_C_DEFINED_glMultiTexCoord1hNV
void __stdcall GLee_Lazy_glMultiTexCoord1hNV(GLenum target, GLhalfNV s) {if (GLeeInit()) glMultiTexCoord1hNV(target, s);}
GLEEPFNGLMULTITEXCOORD1HNVPROC GLeeFuncPtr_glMultiTexCoord1hNV=GLee_Lazy_glMultiTexCoord1hNV;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord1hvNV
#define GLEE_C_DEFINED_glMultiTexCoord1hvNV
void __stdcall GLee_Lazy_glMultiTexCoord1hvNV(GLenum target, const GLhalfNV * v) {if (GLeeInit()) glMultiTexCoord1hvNV(target, v);}
GLEEPFNGLMULTITEXCOORD1HVNVPROC GLeeFuncPtr_glMultiTexCoord1hvNV=GLee_Lazy_glMultiTexCoord1hvNV;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2hNV
#define GLEE_C_DEFINED_glMultiTexCoord2hNV
void __stdcall GLee_Lazy_glMultiTexCoord2hNV(GLenum target, GLhalfNV s, GLhalfNV t) {if (GLeeInit()) glMultiTexCoord2hNV(target, s, t);}
GLEEPFNGLMULTITEXCOORD2HNVPROC GLeeFuncPtr_glMultiTexCoord2hNV=GLee_Lazy_glMultiTexCoord2hNV;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord2hvNV
#define GLEE_C_DEFINED_glMultiTexCoord2hvNV
void __stdcall GLee_Lazy_glMultiTexCoord2hvNV(GLenum target, const GLhalfNV * v) {if (GLeeInit()) glMultiTexCoord2hvNV(target, v);}
GLEEPFNGLMULTITEXCOORD2HVNVPROC GLeeFuncPtr_glMultiTexCoord2hvNV=GLee_Lazy_glMultiTexCoord2hvNV;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3hNV
#define GLEE_C_DEFINED_glMultiTexCoord3hNV
void __stdcall GLee_Lazy_glMultiTexCoord3hNV(GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r) {if (GLeeInit()) glMultiTexCoord3hNV(target, s, t, r);}
GLEEPFNGLMULTITEXCOORD3HNVPROC GLeeFuncPtr_glMultiTexCoord3hNV=GLee_Lazy_glMultiTexCoord3hNV;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord3hvNV
#define GLEE_C_DEFINED_glMultiTexCoord3hvNV
void __stdcall GLee_Lazy_glMultiTexCoord3hvNV(GLenum target, const GLhalfNV * v) {if (GLeeInit()) glMultiTexCoord3hvNV(target, v);}
GLEEPFNGLMULTITEXCOORD3HVNVPROC GLeeFuncPtr_glMultiTexCoord3hvNV=GLee_Lazy_glMultiTexCoord3hvNV;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4hNV
#define GLEE_C_DEFINED_glMultiTexCoord4hNV
void __stdcall GLee_Lazy_glMultiTexCoord4hNV(GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q) {if (GLeeInit()) glMultiTexCoord4hNV(target, s, t, r, q);}
GLEEPFNGLMULTITEXCOORD4HNVPROC GLeeFuncPtr_glMultiTexCoord4hNV=GLee_Lazy_glMultiTexCoord4hNV;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoord4hvNV
#define GLEE_C_DEFINED_glMultiTexCoord4hvNV
void __stdcall GLee_Lazy_glMultiTexCoord4hvNV(GLenum target, const GLhalfNV * v) {if (GLeeInit()) glMultiTexCoord4hvNV(target, v);}
GLEEPFNGLMULTITEXCOORD4HVNVPROC GLeeFuncPtr_glMultiTexCoord4hvNV=GLee_Lazy_glMultiTexCoord4hvNV;
#endif
#ifndef GLEE_C_DEFINED_glFogCoordhNV
#define GLEE_C_DEFINED_glFogCoordhNV
void __stdcall GLee_Lazy_glFogCoordhNV(GLhalfNV fog) {if (GLeeInit()) glFogCoordhNV(fog);}
GLEEPFNGLFOGCOORDHNVPROC GLeeFuncPtr_glFogCoordhNV=GLee_Lazy_glFogCoordhNV;
#endif
#ifndef GLEE_C_DEFINED_glFogCoordhvNV
#define GLEE_C_DEFINED_glFogCoordhvNV
void __stdcall GLee_Lazy_glFogCoordhvNV(const GLhalfNV * fog) {if (GLeeInit()) glFogCoordhvNV(fog);}
GLEEPFNGLFOGCOORDHVNVPROC GLeeFuncPtr_glFogCoordhvNV=GLee_Lazy_glFogCoordhvNV;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3hNV
#define GLEE_C_DEFINED_glSecondaryColor3hNV
void __stdcall GLee_Lazy_glSecondaryColor3hNV(GLhalfNV red, GLhalfNV green, GLhalfNV blue) {if (GLeeInit()) glSecondaryColor3hNV(red, green, blue);}
GLEEPFNGLSECONDARYCOLOR3HNVPROC GLeeFuncPtr_glSecondaryColor3hNV=GLee_Lazy_glSecondaryColor3hNV;
#endif
#ifndef GLEE_C_DEFINED_glSecondaryColor3hvNV
#define GLEE_C_DEFINED_glSecondaryColor3hvNV
void __stdcall GLee_Lazy_glSecondaryColor3hvNV(const GLhalfNV * v) {if (GLeeInit()) glSecondaryColor3hvNV(v);}
GLEEPFNGLSECONDARYCOLOR3HVNVPROC GLeeFuncPtr_glSecondaryColor3hvNV=GLee_Lazy_glSecondaryColor3hvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexWeighthNV
#define GLEE_C_DEFINED_glVertexWeighthNV
void __stdcall GLee_Lazy_glVertexWeighthNV(GLhalfNV weight) {if (GLeeInit()) glVertexWeighthNV(weight);}
GLEEPFNGLVERTEXWEIGHTHNVPROC GLeeFuncPtr_glVertexWeighthNV=GLee_Lazy_glVertexWeighthNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexWeighthvNV
#define GLEE_C_DEFINED_glVertexWeighthvNV
void __stdcall GLee_Lazy_glVertexWeighthvNV(const GLhalfNV * weight) {if (GLeeInit()) glVertexWeighthvNV(weight);}
GLEEPFNGLVERTEXWEIGHTHVNVPROC GLeeFuncPtr_glVertexWeighthvNV=GLee_Lazy_glVertexWeighthvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1hNV
#define GLEE_C_DEFINED_glVertexAttrib1hNV
void __stdcall GLee_Lazy_glVertexAttrib1hNV(GLuint index, GLhalfNV x) {if (GLeeInit()) glVertexAttrib1hNV(index, x);}
GLEEPFNGLVERTEXATTRIB1HNVPROC GLeeFuncPtr_glVertexAttrib1hNV=GLee_Lazy_glVertexAttrib1hNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib1hvNV
#define GLEE_C_DEFINED_glVertexAttrib1hvNV
void __stdcall GLee_Lazy_glVertexAttrib1hvNV(GLuint index, const GLhalfNV * v) {if (GLeeInit()) glVertexAttrib1hvNV(index, v);}
GLEEPFNGLVERTEXATTRIB1HVNVPROC GLeeFuncPtr_glVertexAttrib1hvNV=GLee_Lazy_glVertexAttrib1hvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2hNV
#define GLEE_C_DEFINED_glVertexAttrib2hNV
void __stdcall GLee_Lazy_glVertexAttrib2hNV(GLuint index, GLhalfNV x, GLhalfNV y) {if (GLeeInit()) glVertexAttrib2hNV(index, x, y);}
GLEEPFNGLVERTEXATTRIB2HNVPROC GLeeFuncPtr_glVertexAttrib2hNV=GLee_Lazy_glVertexAttrib2hNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib2hvNV
#define GLEE_C_DEFINED_glVertexAttrib2hvNV
void __stdcall GLee_Lazy_glVertexAttrib2hvNV(GLuint index, const GLhalfNV * v) {if (GLeeInit()) glVertexAttrib2hvNV(index, v);}
GLEEPFNGLVERTEXATTRIB2HVNVPROC GLeeFuncPtr_glVertexAttrib2hvNV=GLee_Lazy_glVertexAttrib2hvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3hNV
#define GLEE_C_DEFINED_glVertexAttrib3hNV
void __stdcall GLee_Lazy_glVertexAttrib3hNV(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z) {if (GLeeInit()) glVertexAttrib3hNV(index, x, y, z);}
GLEEPFNGLVERTEXATTRIB3HNVPROC GLeeFuncPtr_glVertexAttrib3hNV=GLee_Lazy_glVertexAttrib3hNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib3hvNV
#define GLEE_C_DEFINED_glVertexAttrib3hvNV
void __stdcall GLee_Lazy_glVertexAttrib3hvNV(GLuint index, const GLhalfNV * v) {if (GLeeInit()) glVertexAttrib3hvNV(index, v);}
GLEEPFNGLVERTEXATTRIB3HVNVPROC GLeeFuncPtr_glVertexAttrib3hvNV=GLee_Lazy_glVertexAttrib3hvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4hNV
#define GLEE_C_DEFINED_glVertexAttrib4hNV
void __stdcall GLee_Lazy_glVertexAttrib4hNV(GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w) {if (GLeeInit()) glVertexAttrib4hNV(index, x, y, z, w);}
GLEEPFNGLVERTEXATTRIB4HNVPROC GLeeFuncPtr_glVertexAttrib4hNV=GLee_Lazy_glVertexAttrib4hNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttrib4hvNV
#define GLEE_C_DEFINED_glVertexAttrib4hvNV
void __stdcall GLee_Lazy_glVertexAttrib4hvNV(GLuint index, const GLhalfNV * v) {if (GLeeInit()) glVertexAttrib4hvNV(index, v);}
GLEEPFNGLVERTEXATTRIB4HVNVPROC GLeeFuncPtr_glVertexAttrib4hvNV=GLee_Lazy_glVertexAttrib4hvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribs1hvNV
#define GLEE_C_DEFINED_glVertexAttribs1hvNV
void __stdcall GLee_Lazy_glVertexAttribs1hvNV(GLuint index, GLsizei n, const GLhalfNV * v) {if (GLeeInit()) glVertexAttribs1hvNV(index, n, v);}
GLEEPFNGLVERTEXATTRIBS1HVNVPROC GLeeFuncPtr_glVertexAttribs1hvNV=GLee_Lazy_glVertexAttribs1hvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribs2hvNV
#define GLEE_C_DEFINED_glVertexAttribs2hvNV
void __stdcall GLee_Lazy_glVertexAttribs2hvNV(GLuint index, GLsizei n, const GLhalfNV * v) {if (GLeeInit()) glVertexAttribs2hvNV(index, n, v);}
GLEEPFNGLVERTEXATTRIBS2HVNVPROC GLeeFuncPtr_glVertexAttribs2hvNV=GLee_Lazy_glVertexAttribs2hvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribs3hvNV
#define GLEE_C_DEFINED_glVertexAttribs3hvNV
void __stdcall GLee_Lazy_glVertexAttribs3hvNV(GLuint index, GLsizei n, const GLhalfNV * v) {if (GLeeInit()) glVertexAttribs3hvNV(index, n, v);}
GLEEPFNGLVERTEXATTRIBS3HVNVPROC GLeeFuncPtr_glVertexAttribs3hvNV=GLee_Lazy_glVertexAttribs3hvNV;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribs4hvNV
#define GLEE_C_DEFINED_glVertexAttribs4hvNV
void __stdcall GLee_Lazy_glVertexAttribs4hvNV(GLuint index, GLsizei n, const GLhalfNV * v) {if (GLeeInit()) glVertexAttribs4hvNV(index, n, v);}
GLEEPFNGLVERTEXATTRIBS4HVNVPROC GLeeFuncPtr_glVertexAttribs4hvNV=GLee_Lazy_glVertexAttribs4hvNV;
#endif
#endif
/* GL_NV_pixel_data_range */
#ifdef __GLEE_GL_NV_pixel_data_range
#ifndef GLEE_C_DEFINED_glPixelDataRangeNV
#define GLEE_C_DEFINED_glPixelDataRangeNV
void __stdcall GLee_Lazy_glPixelDataRangeNV(GLenum target, GLsizei length, GLvoid * pointer) {if (GLeeInit()) glPixelDataRangeNV(target, length, pointer);}
GLEEPFNGLPIXELDATARANGENVPROC GLeeFuncPtr_glPixelDataRangeNV=GLee_Lazy_glPixelDataRangeNV;
#endif
#ifndef GLEE_C_DEFINED_glFlushPixelDataRangeNV
#define GLEE_C_DEFINED_glFlushPixelDataRangeNV
void __stdcall GLee_Lazy_glFlushPixelDataRangeNV(GLenum target) {if (GLeeInit()) glFlushPixelDataRangeNV(target);}
GLEEPFNGLFLUSHPIXELDATARANGENVPROC GLeeFuncPtr_glFlushPixelDataRangeNV=GLee_Lazy_glFlushPixelDataRangeNV;
#endif
#endif
/* GL_NV_primitive_restart */
#ifdef __GLEE_GL_NV_primitive_restart
#ifndef GLEE_C_DEFINED_glPrimitiveRestartNV
#define GLEE_C_DEFINED_glPrimitiveRestartNV
void __stdcall GLee_Lazy_glPrimitiveRestartNV(void) {if (GLeeInit()) glPrimitiveRestartNV();}
GLEEPFNGLPRIMITIVERESTARTNVPROC GLeeFuncPtr_glPrimitiveRestartNV=GLee_Lazy_glPrimitiveRestartNV;
#endif
#ifndef GLEE_C_DEFINED_glPrimitiveRestartIndexNV
#define GLEE_C_DEFINED_glPrimitiveRestartIndexNV
void __stdcall GLee_Lazy_glPrimitiveRestartIndexNV(GLuint index) {if (GLeeInit()) glPrimitiveRestartIndexNV(index);}
GLEEPFNGLPRIMITIVERESTARTINDEXNVPROC GLeeFuncPtr_glPrimitiveRestartIndexNV=GLee_Lazy_glPrimitiveRestartIndexNV;
#endif
#endif
/* GL_NV_texture_expand_normal */
#ifdef __GLEE_GL_NV_texture_expand_normal
#endif
/* GL_NV_vertex_program2 */
#ifdef __GLEE_GL_NV_vertex_program2
#endif
/* GL_ATI_map_object_buffer */
#ifdef __GLEE_GL_ATI_map_object_buffer
#ifndef GLEE_C_DEFINED_glMapObjectBufferATI
#define GLEE_C_DEFINED_glMapObjectBufferATI
GLvoid* __stdcall GLee_Lazy_glMapObjectBufferATI(GLuint buffer) {if (GLeeInit()) return glMapObjectBufferATI(buffer); return (GLvoid*)0;}
GLEEPFNGLMAPOBJECTBUFFERATIPROC GLeeFuncPtr_glMapObjectBufferATI=GLee_Lazy_glMapObjectBufferATI;
#endif
#ifndef GLEE_C_DEFINED_glUnmapObjectBufferATI
#define GLEE_C_DEFINED_glUnmapObjectBufferATI
void __stdcall GLee_Lazy_glUnmapObjectBufferATI(GLuint buffer) {if (GLeeInit()) glUnmapObjectBufferATI(buffer);}
GLEEPFNGLUNMAPOBJECTBUFFERATIPROC GLeeFuncPtr_glUnmapObjectBufferATI=GLee_Lazy_glUnmapObjectBufferATI;
#endif
#endif
/* GL_ATI_separate_stencil */
#ifdef __GLEE_GL_ATI_separate_stencil
#ifndef GLEE_C_DEFINED_glStencilOpSeparateATI
#define GLEE_C_DEFINED_glStencilOpSeparateATI
void __stdcall GLee_Lazy_glStencilOpSeparateATI(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) {if (GLeeInit()) glStencilOpSeparateATI(face, sfail, dpfail, dppass);}
GLEEPFNGLSTENCILOPSEPARATEATIPROC GLeeFuncPtr_glStencilOpSeparateATI=GLee_Lazy_glStencilOpSeparateATI;
#endif
#ifndef GLEE_C_DEFINED_glStencilFuncSeparateATI
#define GLEE_C_DEFINED_glStencilFuncSeparateATI
void __stdcall GLee_Lazy_glStencilFuncSeparateATI(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask) {if (GLeeInit()) glStencilFuncSeparateATI(frontfunc, backfunc, ref, mask);}
GLEEPFNGLSTENCILFUNCSEPARATEATIPROC GLeeFuncPtr_glStencilFuncSeparateATI=GLee_Lazy_glStencilFuncSeparateATI;
#endif
#endif
/* GL_ATI_vertex_attrib_array_object */
#ifdef __GLEE_GL_ATI_vertex_attrib_array_object
#ifndef GLEE_C_DEFINED_glVertexAttribArrayObjectATI
#define GLEE_C_DEFINED_glVertexAttribArrayObjectATI
void __stdcall GLee_Lazy_glVertexAttribArrayObjectATI(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint buffer, GLuint offset) {if (GLeeInit()) glVertexAttribArrayObjectATI(index, size, type, normalized, stride, buffer, offset);}
GLEEPFNGLVERTEXATTRIBARRAYOBJECTATIPROC GLeeFuncPtr_glVertexAttribArrayObjectATI=GLee_Lazy_glVertexAttribArrayObjectATI;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribArrayObjectfvATI
#define GLEE_C_DEFINED_glGetVertexAttribArrayObjectfvATI
void __stdcall GLee_Lazy_glGetVertexAttribArrayObjectfvATI(GLuint index, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetVertexAttribArrayObjectfvATI(index, pname, params);}
GLEEPFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC GLeeFuncPtr_glGetVertexAttribArrayObjectfvATI=GLee_Lazy_glGetVertexAttribArrayObjectfvATI;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribArrayObjectivATI
#define GLEE_C_DEFINED_glGetVertexAttribArrayObjectivATI
void __stdcall GLee_Lazy_glGetVertexAttribArrayObjectivATI(GLuint index, GLenum pname, GLint * params) {if (GLeeInit()) glGetVertexAttribArrayObjectivATI(index, pname, params);}
GLEEPFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC GLeeFuncPtr_glGetVertexAttribArrayObjectivATI=GLee_Lazy_glGetVertexAttribArrayObjectivATI;
#endif
#endif
/* GL_OES_read_format */
#ifdef __GLEE_GL_OES_read_format
#endif
/* GL_EXT_depth_bounds_test */
#ifdef __GLEE_GL_EXT_depth_bounds_test
#ifndef GLEE_C_DEFINED_glDepthBoundsEXT
#define GLEE_C_DEFINED_glDepthBoundsEXT
void __stdcall GLee_Lazy_glDepthBoundsEXT(GLclampd zmin, GLclampd zmax) {if (GLeeInit()) glDepthBoundsEXT(zmin, zmax);}
GLEEPFNGLDEPTHBOUNDSEXTPROC GLeeFuncPtr_glDepthBoundsEXT=GLee_Lazy_glDepthBoundsEXT;
#endif
#endif
/* GL_EXT_texture_mirror_clamp */
#ifdef __GLEE_GL_EXT_texture_mirror_clamp
#endif
/* GL_EXT_blend_equation_separate */
#ifdef __GLEE_GL_EXT_blend_equation_separate
#ifndef GLEE_C_DEFINED_glBlendEquationSeparateEXT
#define GLEE_C_DEFINED_glBlendEquationSeparateEXT
void __stdcall GLee_Lazy_glBlendEquationSeparateEXT(GLenum modeRGB, GLenum modeAlpha) {if (GLeeInit()) glBlendEquationSeparateEXT(modeRGB, modeAlpha);}
GLEEPFNGLBLENDEQUATIONSEPARATEEXTPROC GLeeFuncPtr_glBlendEquationSeparateEXT=GLee_Lazy_glBlendEquationSeparateEXT;
#endif
#endif
/* GL_MESA_pack_invert */
#ifdef __GLEE_GL_MESA_pack_invert
#endif
/* GL_MESA_ycbcr_texture */
#ifdef __GLEE_GL_MESA_ycbcr_texture
#endif
/* GL_EXT_pixel_buffer_object */
#ifdef __GLEE_GL_EXT_pixel_buffer_object
#endif
/* GL_NV_fragment_program_option */
#ifdef __GLEE_GL_NV_fragment_program_option
#endif
/* GL_NV_fragment_program2 */
#ifdef __GLEE_GL_NV_fragment_program2
#endif
/* GL_NV_vertex_program2_option */
#ifdef __GLEE_GL_NV_vertex_program2_option
#endif
/* GL_NV_vertex_program3 */
#ifdef __GLEE_GL_NV_vertex_program3
#endif
/* GL_EXT_framebuffer_object */
#ifdef __GLEE_GL_EXT_framebuffer_object
#ifndef GLEE_C_DEFINED_glIsRenderbufferEXT
#define GLEE_C_DEFINED_glIsRenderbufferEXT
GLboolean __stdcall GLee_Lazy_glIsRenderbufferEXT(GLuint renderbuffer) {if (GLeeInit()) return glIsRenderbufferEXT(renderbuffer); return (GLboolean)0;}
GLEEPFNGLISRENDERBUFFEREXTPROC GLeeFuncPtr_glIsRenderbufferEXT=GLee_Lazy_glIsRenderbufferEXT;
#endif
#ifndef GLEE_C_DEFINED_glBindRenderbufferEXT
#define GLEE_C_DEFINED_glBindRenderbufferEXT
void __stdcall GLee_Lazy_glBindRenderbufferEXT(GLenum target, GLuint renderbuffer) {if (GLeeInit()) glBindRenderbufferEXT(target, renderbuffer);}
GLEEPFNGLBINDRENDERBUFFEREXTPROC GLeeFuncPtr_glBindRenderbufferEXT=GLee_Lazy_glBindRenderbufferEXT;
#endif
#ifndef GLEE_C_DEFINED_glDeleteRenderbuffersEXT
#define GLEE_C_DEFINED_glDeleteRenderbuffersEXT
void __stdcall GLee_Lazy_glDeleteRenderbuffersEXT(GLsizei n, const GLuint * renderbuffers) {if (GLeeInit()) glDeleteRenderbuffersEXT(n, renderbuffers);}
GLEEPFNGLDELETERENDERBUFFERSEXTPROC GLeeFuncPtr_glDeleteRenderbuffersEXT=GLee_Lazy_glDeleteRenderbuffersEXT;
#endif
#ifndef GLEE_C_DEFINED_glGenRenderbuffersEXT
#define GLEE_C_DEFINED_glGenRenderbuffersEXT
void __stdcall GLee_Lazy_glGenRenderbuffersEXT(GLsizei n, GLuint * renderbuffers) {if (GLeeInit()) glGenRenderbuffersEXT(n, renderbuffers);}
GLEEPFNGLGENRENDERBUFFERSEXTPROC GLeeFuncPtr_glGenRenderbuffersEXT=GLee_Lazy_glGenRenderbuffersEXT;
#endif
#ifndef GLEE_C_DEFINED_glRenderbufferStorageEXT
#define GLEE_C_DEFINED_glRenderbufferStorageEXT
void __stdcall GLee_Lazy_glRenderbufferStorageEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) {if (GLeeInit()) glRenderbufferStorageEXT(target, internalformat, width, height);}
GLEEPFNGLRENDERBUFFERSTORAGEEXTPROC GLeeFuncPtr_glRenderbufferStorageEXT=GLee_Lazy_glRenderbufferStorageEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetRenderbufferParameterivEXT
#define GLEE_C_DEFINED_glGetRenderbufferParameterivEXT
void __stdcall GLee_Lazy_glGetRenderbufferParameterivEXT(GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetRenderbufferParameterivEXT(target, pname, params);}
GLEEPFNGLGETRENDERBUFFERPARAMETERIVEXTPROC GLeeFuncPtr_glGetRenderbufferParameterivEXT=GLee_Lazy_glGetRenderbufferParameterivEXT;
#endif
#ifndef GLEE_C_DEFINED_glIsFramebufferEXT
#define GLEE_C_DEFINED_glIsFramebufferEXT
GLboolean __stdcall GLee_Lazy_glIsFramebufferEXT(GLuint framebuffer) {if (GLeeInit()) return glIsFramebufferEXT(framebuffer); return (GLboolean)0;}
GLEEPFNGLISFRAMEBUFFEREXTPROC GLeeFuncPtr_glIsFramebufferEXT=GLee_Lazy_glIsFramebufferEXT;
#endif
#ifndef GLEE_C_DEFINED_glBindFramebufferEXT
#define GLEE_C_DEFINED_glBindFramebufferEXT
void __stdcall GLee_Lazy_glBindFramebufferEXT(GLenum target, GLuint framebuffer) {if (GLeeInit()) glBindFramebufferEXT(target, framebuffer);}
GLEEPFNGLBINDFRAMEBUFFEREXTPROC GLeeFuncPtr_glBindFramebufferEXT=GLee_Lazy_glBindFramebufferEXT;
#endif
#ifndef GLEE_C_DEFINED_glDeleteFramebuffersEXT
#define GLEE_C_DEFINED_glDeleteFramebuffersEXT
void __stdcall GLee_Lazy_glDeleteFramebuffersEXT(GLsizei n, const GLuint * framebuffers) {if (GLeeInit()) glDeleteFramebuffersEXT(n, framebuffers);}
GLEEPFNGLDELETEFRAMEBUFFERSEXTPROC GLeeFuncPtr_glDeleteFramebuffersEXT=GLee_Lazy_glDeleteFramebuffersEXT;
#endif
#ifndef GLEE_C_DEFINED_glGenFramebuffersEXT
#define GLEE_C_DEFINED_glGenFramebuffersEXT
void __stdcall GLee_Lazy_glGenFramebuffersEXT(GLsizei n, GLuint * framebuffers) {if (GLeeInit()) glGenFramebuffersEXT(n, framebuffers);}
GLEEPFNGLGENFRAMEBUFFERSEXTPROC GLeeFuncPtr_glGenFramebuffersEXT=GLee_Lazy_glGenFramebuffersEXT;
#endif
#ifndef GLEE_C_DEFINED_glCheckFramebufferStatusEXT
#define GLEE_C_DEFINED_glCheckFramebufferStatusEXT
GLenum __stdcall GLee_Lazy_glCheckFramebufferStatusEXT(GLenum target) {if (GLeeInit()) return glCheckFramebufferStatusEXT(target); return (GLenum)0;}
GLEEPFNGLCHECKFRAMEBUFFERSTATUSEXTPROC GLeeFuncPtr_glCheckFramebufferStatusEXT=GLee_Lazy_glCheckFramebufferStatusEXT;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferTexture1DEXT
#define GLEE_C_DEFINED_glFramebufferTexture1DEXT
void __stdcall GLee_Lazy_glFramebufferTexture1DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {if (GLeeInit()) glFramebufferTexture1DEXT(target, attachment, textarget, texture, level);}
GLEEPFNGLFRAMEBUFFERTEXTURE1DEXTPROC GLeeFuncPtr_glFramebufferTexture1DEXT=GLee_Lazy_glFramebufferTexture1DEXT;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferTexture2DEXT
#define GLEE_C_DEFINED_glFramebufferTexture2DEXT
void __stdcall GLee_Lazy_glFramebufferTexture2DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {if (GLeeInit()) glFramebufferTexture2DEXT(target, attachment, textarget, texture, level);}
GLEEPFNGLFRAMEBUFFERTEXTURE2DEXTPROC GLeeFuncPtr_glFramebufferTexture2DEXT=GLee_Lazy_glFramebufferTexture2DEXT;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferTexture3DEXT
#define GLEE_C_DEFINED_glFramebufferTexture3DEXT
void __stdcall GLee_Lazy_glFramebufferTexture3DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) {if (GLeeInit()) glFramebufferTexture3DEXT(target, attachment, textarget, texture, level, zoffset);}
GLEEPFNGLFRAMEBUFFERTEXTURE3DEXTPROC GLeeFuncPtr_glFramebufferTexture3DEXT=GLee_Lazy_glFramebufferTexture3DEXT;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferRenderbufferEXT
#define GLEE_C_DEFINED_glFramebufferRenderbufferEXT
void __stdcall GLee_Lazy_glFramebufferRenderbufferEXT(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) {if (GLeeInit()) glFramebufferRenderbufferEXT(target, attachment, renderbuffertarget, renderbuffer);}
GLEEPFNGLFRAMEBUFFERRENDERBUFFEREXTPROC GLeeFuncPtr_glFramebufferRenderbufferEXT=GLee_Lazy_glFramebufferRenderbufferEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetFramebufferAttachmentParameterivEXT
#define GLEE_C_DEFINED_glGetFramebufferAttachmentParameterivEXT
void __stdcall GLee_Lazy_glGetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment, GLenum pname, GLint * params) {if (GLeeInit()) glGetFramebufferAttachmentParameterivEXT(target, attachment, pname, params);}
GLEEPFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC GLeeFuncPtr_glGetFramebufferAttachmentParameterivEXT=GLee_Lazy_glGetFramebufferAttachmentParameterivEXT;
#endif
#ifndef GLEE_C_DEFINED_glGenerateMipmapEXT
#define GLEE_C_DEFINED_glGenerateMipmapEXT
void __stdcall GLee_Lazy_glGenerateMipmapEXT(GLenum target) {if (GLeeInit()) glGenerateMipmapEXT(target);}
GLEEPFNGLGENERATEMIPMAPEXTPROC GLeeFuncPtr_glGenerateMipmapEXT=GLee_Lazy_glGenerateMipmapEXT;
#endif
#endif
/* GL_GREMEDY_string_marker */
#ifdef __GLEE_GL_GREMEDY_string_marker
#ifndef GLEE_C_DEFINED_glStringMarkerGREMEDY
#define GLEE_C_DEFINED_glStringMarkerGREMEDY
void __stdcall GLee_Lazy_glStringMarkerGREMEDY(GLsizei len, const GLvoid * string) {if (GLeeInit()) glStringMarkerGREMEDY(len, string);}
GLEEPFNGLSTRINGMARKERGREMEDYPROC GLeeFuncPtr_glStringMarkerGREMEDY=GLee_Lazy_glStringMarkerGREMEDY;
#endif
#endif
/* GL_EXT_packed_depth_stencil */
#ifdef __GLEE_GL_EXT_packed_depth_stencil
#endif
/* GL_EXT_stencil_clear_tag */
#ifdef __GLEE_GL_EXT_stencil_clear_tag
#ifndef GLEE_C_DEFINED_glStencilClearTagEXT
#define GLEE_C_DEFINED_glStencilClearTagEXT
void __stdcall GLee_Lazy_glStencilClearTagEXT(GLsizei stencilTagBits, GLuint stencilClearTag) {if (GLeeInit()) glStencilClearTagEXT(stencilTagBits, stencilClearTag);}
GLEEPFNGLSTENCILCLEARTAGEXTPROC GLeeFuncPtr_glStencilClearTagEXT=GLee_Lazy_glStencilClearTagEXT;
#endif
#endif
/* GL_EXT_texture_sRGB */
#ifdef __GLEE_GL_EXT_texture_sRGB
#endif
/* GL_EXT_framebuffer_blit */
#ifdef __GLEE_GL_EXT_framebuffer_blit
#ifndef GLEE_C_DEFINED_glBlitFramebufferEXT
#define GLEE_C_DEFINED_glBlitFramebufferEXT
void __stdcall GLee_Lazy_glBlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) {if (GLeeInit()) glBlitFramebufferEXT(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);}
GLEEPFNGLBLITFRAMEBUFFEREXTPROC GLeeFuncPtr_glBlitFramebufferEXT=GLee_Lazy_glBlitFramebufferEXT;
#endif
#endif
/* GL_EXT_framebuffer_multisample */
#ifdef __GLEE_GL_EXT_framebuffer_multisample
#ifndef GLEE_C_DEFINED_glRenderbufferStorageMultisampleEXT
#define GLEE_C_DEFINED_glRenderbufferStorageMultisampleEXT
void __stdcall GLee_Lazy_glRenderbufferStorageMultisampleEXT(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) {if (GLeeInit()) glRenderbufferStorageMultisampleEXT(target, samples, internalformat, width, height);}
GLEEPFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC GLeeFuncPtr_glRenderbufferStorageMultisampleEXT=GLee_Lazy_glRenderbufferStorageMultisampleEXT;
#endif
#endif
/* GL_MESAX_texture_stack */
#ifdef __GLEE_GL_MESAX_texture_stack
#endif
/* GL_EXT_timer_query */
#ifdef __GLEE_GL_EXT_timer_query
#ifndef GLEE_C_DEFINED_glGetQueryObjecti64vEXT
#define GLEE_C_DEFINED_glGetQueryObjecti64vEXT
void __stdcall GLee_Lazy_glGetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64EXT * params) {if (GLeeInit()) glGetQueryObjecti64vEXT(id, pname, params);}
GLEEPFNGLGETQUERYOBJECTI64VEXTPROC GLeeFuncPtr_glGetQueryObjecti64vEXT=GLee_Lazy_glGetQueryObjecti64vEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetQueryObjectui64vEXT
#define GLEE_C_DEFINED_glGetQueryObjectui64vEXT
void __stdcall GLee_Lazy_glGetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64EXT * params) {if (GLeeInit()) glGetQueryObjectui64vEXT(id, pname, params);}
GLEEPFNGLGETQUERYOBJECTUI64VEXTPROC GLeeFuncPtr_glGetQueryObjectui64vEXT=GLee_Lazy_glGetQueryObjectui64vEXT;
#endif
#endif
/* GL_EXT_gpu_program_parameters */
#ifdef __GLEE_GL_EXT_gpu_program_parameters
#ifndef GLEE_C_DEFINED_glProgramEnvParameters4fvEXT
#define GLEE_C_DEFINED_glProgramEnvParameters4fvEXT
void __stdcall GLee_Lazy_glProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count, const GLfloat * params) {if (GLeeInit()) glProgramEnvParameters4fvEXT(target, index, count, params);}
GLEEPFNGLPROGRAMENVPARAMETERS4FVEXTPROC GLeeFuncPtr_glProgramEnvParameters4fvEXT=GLee_Lazy_glProgramEnvParameters4fvEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramLocalParameters4fvEXT
#define GLEE_C_DEFINED_glProgramLocalParameters4fvEXT
void __stdcall GLee_Lazy_glProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count, const GLfloat * params) {if (GLeeInit()) glProgramLocalParameters4fvEXT(target, index, count, params);}
GLEEPFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC GLeeFuncPtr_glProgramLocalParameters4fvEXT=GLee_Lazy_glProgramLocalParameters4fvEXT;
#endif
#endif
/* GL_APPLE_flush_buffer_range */
#ifdef __GLEE_GL_APPLE_flush_buffer_range
#ifndef GLEE_C_DEFINED_glBufferParameteriAPPLE
#define GLEE_C_DEFINED_glBufferParameteriAPPLE
void __stdcall GLee_Lazy_glBufferParameteriAPPLE(GLenum target, GLenum pname, GLint param) {if (GLeeInit()) glBufferParameteriAPPLE(target, pname, param);}
GLEEPFNGLBUFFERPARAMETERIAPPLEPROC GLeeFuncPtr_glBufferParameteriAPPLE=GLee_Lazy_glBufferParameteriAPPLE;
#endif
#ifndef GLEE_C_DEFINED_glFlushMappedBufferRangeAPPLE
#define GLEE_C_DEFINED_glFlushMappedBufferRangeAPPLE
void __stdcall GLee_Lazy_glFlushMappedBufferRangeAPPLE(GLenum target, GLintptr offset, GLsizeiptr size) {if (GLeeInit()) glFlushMappedBufferRangeAPPLE(target, offset, size);}
GLEEPFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC GLeeFuncPtr_glFlushMappedBufferRangeAPPLE=GLee_Lazy_glFlushMappedBufferRangeAPPLE;
#endif
#endif
/* GL_EXT_gpu_shader4 */
#ifdef __GLEE_GL_EXT_gpu_shader4
#ifndef GLEE_C_DEFINED_glGetUniformuivEXT
#define GLEE_C_DEFINED_glGetUniformuivEXT
void __stdcall GLee_Lazy_glGetUniformuivEXT(GLuint program, GLint location, GLuint * params) {if (GLeeInit()) glGetUniformuivEXT(program, location, params);}
GLEEPFNGLGETUNIFORMUIVEXTPROC GLeeFuncPtr_glGetUniformuivEXT=GLee_Lazy_glGetUniformuivEXT;
#endif
#ifndef GLEE_C_DEFINED_glBindFragDataLocationEXT
#define GLEE_C_DEFINED_glBindFragDataLocationEXT
void __stdcall GLee_Lazy_glBindFragDataLocationEXT(GLuint program, GLuint color, const GLchar * name) {if (GLeeInit()) glBindFragDataLocationEXT(program, color, name);}
GLEEPFNGLBINDFRAGDATALOCATIONEXTPROC GLeeFuncPtr_glBindFragDataLocationEXT=GLee_Lazy_glBindFragDataLocationEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetFragDataLocationEXT
#define GLEE_C_DEFINED_glGetFragDataLocationEXT
GLint __stdcall GLee_Lazy_glGetFragDataLocationEXT(GLuint program, const GLchar * name) {if (GLeeInit()) return glGetFragDataLocationEXT(program, name); return (GLint)0;}
GLEEPFNGLGETFRAGDATALOCATIONEXTPROC GLeeFuncPtr_glGetFragDataLocationEXT=GLee_Lazy_glGetFragDataLocationEXT;
#endif
#ifndef GLEE_C_DEFINED_glUniform1uiEXT
#define GLEE_C_DEFINED_glUniform1uiEXT
void __stdcall GLee_Lazy_glUniform1uiEXT(GLint location, GLuint v0) {if (GLeeInit()) glUniform1uiEXT(location, v0);}
GLEEPFNGLUNIFORM1UIEXTPROC GLeeFuncPtr_glUniform1uiEXT=GLee_Lazy_glUniform1uiEXT;
#endif
#ifndef GLEE_C_DEFINED_glUniform2uiEXT
#define GLEE_C_DEFINED_glUniform2uiEXT
void __stdcall GLee_Lazy_glUniform2uiEXT(GLint location, GLuint v0, GLuint v1) {if (GLeeInit()) glUniform2uiEXT(location, v0, v1);}
GLEEPFNGLUNIFORM2UIEXTPROC GLeeFuncPtr_glUniform2uiEXT=GLee_Lazy_glUniform2uiEXT;
#endif
#ifndef GLEE_C_DEFINED_glUniform3uiEXT
#define GLEE_C_DEFINED_glUniform3uiEXT
void __stdcall GLee_Lazy_glUniform3uiEXT(GLint location, GLuint v0, GLuint v1, GLuint v2) {if (GLeeInit()) glUniform3uiEXT(location, v0, v1, v2);}
GLEEPFNGLUNIFORM3UIEXTPROC GLeeFuncPtr_glUniform3uiEXT=GLee_Lazy_glUniform3uiEXT;
#endif
#ifndef GLEE_C_DEFINED_glUniform4uiEXT
#define GLEE_C_DEFINED_glUniform4uiEXT
void __stdcall GLee_Lazy_glUniform4uiEXT(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) {if (GLeeInit()) glUniform4uiEXT(location, v0, v1, v2, v3);}
GLEEPFNGLUNIFORM4UIEXTPROC GLeeFuncPtr_glUniform4uiEXT=GLee_Lazy_glUniform4uiEXT;
#endif
#ifndef GLEE_C_DEFINED_glUniform1uivEXT
#define GLEE_C_DEFINED_glUniform1uivEXT
void __stdcall GLee_Lazy_glUniform1uivEXT(GLint location, GLsizei count, const GLuint * value) {if (GLeeInit()) glUniform1uivEXT(location, count, value);}
GLEEPFNGLUNIFORM1UIVEXTPROC GLeeFuncPtr_glUniform1uivEXT=GLee_Lazy_glUniform1uivEXT;
#endif
#ifndef GLEE_C_DEFINED_glUniform2uivEXT
#define GLEE_C_DEFINED_glUniform2uivEXT
void __stdcall GLee_Lazy_glUniform2uivEXT(GLint location, GLsizei count, const GLuint * value) {if (GLeeInit()) glUniform2uivEXT(location, count, value);}
GLEEPFNGLUNIFORM2UIVEXTPROC GLeeFuncPtr_glUniform2uivEXT=GLee_Lazy_glUniform2uivEXT;
#endif
#ifndef GLEE_C_DEFINED_glUniform3uivEXT
#define GLEE_C_DEFINED_glUniform3uivEXT
void __stdcall GLee_Lazy_glUniform3uivEXT(GLint location, GLsizei count, const GLuint * value) {if (GLeeInit()) glUniform3uivEXT(location, count, value);}
GLEEPFNGLUNIFORM3UIVEXTPROC GLeeFuncPtr_glUniform3uivEXT=GLee_Lazy_glUniform3uivEXT;
#endif
#ifndef GLEE_C_DEFINED_glUniform4uivEXT
#define GLEE_C_DEFINED_glUniform4uivEXT
void __stdcall GLee_Lazy_glUniform4uivEXT(GLint location, GLsizei count, const GLuint * value) {if (GLeeInit()) glUniform4uivEXT(location, count, value);}
GLEEPFNGLUNIFORM4UIVEXTPROC GLeeFuncPtr_glUniform4uivEXT=GLee_Lazy_glUniform4uivEXT;
#endif
#endif
/* GL_EXT_draw_instanced */
#ifdef __GLEE_GL_EXT_draw_instanced
#ifndef GLEE_C_DEFINED_glDrawArraysInstancedEXT
#define GLEE_C_DEFINED_glDrawArraysInstancedEXT
void __stdcall GLee_Lazy_glDrawArraysInstancedEXT(GLenum mode, GLint start, GLsizei count, GLsizei primcount) {if (GLeeInit()) glDrawArraysInstancedEXT(mode, start, count, primcount);}
GLEEPFNGLDRAWARRAYSINSTANCEDEXTPROC GLeeFuncPtr_glDrawArraysInstancedEXT=GLee_Lazy_glDrawArraysInstancedEXT;
#endif
#ifndef GLEE_C_DEFINED_glDrawElementsInstancedEXT
#define GLEE_C_DEFINED_glDrawElementsInstancedEXT
void __stdcall GLee_Lazy_glDrawElementsInstancedEXT(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices, GLsizei primcount) {if (GLeeInit()) glDrawElementsInstancedEXT(mode, count, type, indices, primcount);}
GLEEPFNGLDRAWELEMENTSINSTANCEDEXTPROC GLeeFuncPtr_glDrawElementsInstancedEXT=GLee_Lazy_glDrawElementsInstancedEXT;
#endif
#endif
/* GL_EXT_packed_float */
#ifdef __GLEE_GL_EXT_packed_float
#endif
/* GL_EXT_texture_array */
#ifdef __GLEE_GL_EXT_texture_array
#endif
/* GL_EXT_texture_buffer_object */
#ifdef __GLEE_GL_EXT_texture_buffer_object
#ifndef GLEE_C_DEFINED_glTexBufferEXT
#define GLEE_C_DEFINED_glTexBufferEXT
void __stdcall GLee_Lazy_glTexBufferEXT(GLenum target, GLenum internalformat, GLuint buffer) {if (GLeeInit()) glTexBufferEXT(target, internalformat, buffer);}
GLEEPFNGLTEXBUFFEREXTPROC GLeeFuncPtr_glTexBufferEXT=GLee_Lazy_glTexBufferEXT;
#endif
#endif
/* GL_EXT_texture_compression_latc */
#ifdef __GLEE_GL_EXT_texture_compression_latc
#endif
/* GL_EXT_texture_compression_rgtc */
#ifdef __GLEE_GL_EXT_texture_compression_rgtc
#endif
/* GL_EXT_texture_shared_exponent */
#ifdef __GLEE_GL_EXT_texture_shared_exponent
#endif
/* GL_NV_depth_buffer_float */
#ifdef __GLEE_GL_NV_depth_buffer_float
#ifndef GLEE_C_DEFINED_glDepthRangedNV
#define GLEE_C_DEFINED_glDepthRangedNV
void __stdcall GLee_Lazy_glDepthRangedNV(GLdouble zNear, GLdouble zFar) {if (GLeeInit()) glDepthRangedNV(zNear, zFar);}
GLEEPFNGLDEPTHRANGEDNVPROC GLeeFuncPtr_glDepthRangedNV=GLee_Lazy_glDepthRangedNV;
#endif
#ifndef GLEE_C_DEFINED_glClearDepthdNV
#define GLEE_C_DEFINED_glClearDepthdNV
void __stdcall GLee_Lazy_glClearDepthdNV(GLdouble depth) {if (GLeeInit()) glClearDepthdNV(depth);}
GLEEPFNGLCLEARDEPTHDNVPROC GLeeFuncPtr_glClearDepthdNV=GLee_Lazy_glClearDepthdNV;
#endif
#ifndef GLEE_C_DEFINED_glDepthBoundsdNV
#define GLEE_C_DEFINED_glDepthBoundsdNV
void __stdcall GLee_Lazy_glDepthBoundsdNV(GLdouble zmin, GLdouble zmax) {if (GLeeInit()) glDepthBoundsdNV(zmin, zmax);}
GLEEPFNGLDEPTHBOUNDSDNVPROC GLeeFuncPtr_glDepthBoundsdNV=GLee_Lazy_glDepthBoundsdNV;
#endif
#endif
/* GL_NV_framebuffer_multisample_coverage */
#ifdef __GLEE_GL_NV_framebuffer_multisample_coverage
#ifndef GLEE_C_DEFINED_glRenderbufferStorageMultisampleCoverageNV
#define GLEE_C_DEFINED_glRenderbufferStorageMultisampleCoverageNV
void __stdcall GLee_Lazy_glRenderbufferStorageMultisampleCoverageNV(GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height) {if (GLeeInit()) glRenderbufferStorageMultisampleCoverageNV(target, coverageSamples, colorSamples, internalformat, width, height);}
GLEEPFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC GLeeFuncPtr_glRenderbufferStorageMultisampleCoverageNV=GLee_Lazy_glRenderbufferStorageMultisampleCoverageNV;
#endif
#endif
/* GL_EXT_framebuffer_sRGB */
#ifdef __GLEE_GL_EXT_framebuffer_sRGB
#endif
/* GL_NV_geometry_shader4 */
#ifdef __GLEE_GL_NV_geometry_shader4
#endif
/* GL_NV_parameter_buffer_object */
#ifdef __GLEE_GL_NV_parameter_buffer_object
#ifndef GLEE_C_DEFINED_glProgramBufferParametersfvNV
#define GLEE_C_DEFINED_glProgramBufferParametersfvNV
void __stdcall GLee_Lazy_glProgramBufferParametersfvNV(GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLfloat * params) {if (GLeeInit()) glProgramBufferParametersfvNV(target, buffer, index, count, params);}
GLEEPFNGLPROGRAMBUFFERPARAMETERSFVNVPROC GLeeFuncPtr_glProgramBufferParametersfvNV=GLee_Lazy_glProgramBufferParametersfvNV;
#endif
#ifndef GLEE_C_DEFINED_glProgramBufferParametersIivNV
#define GLEE_C_DEFINED_glProgramBufferParametersIivNV
void __stdcall GLee_Lazy_glProgramBufferParametersIivNV(GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLint * params) {if (GLeeInit()) glProgramBufferParametersIivNV(target, buffer, index, count, params);}
GLEEPFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC GLeeFuncPtr_glProgramBufferParametersIivNV=GLee_Lazy_glProgramBufferParametersIivNV;
#endif
#ifndef GLEE_C_DEFINED_glProgramBufferParametersIuivNV
#define GLEE_C_DEFINED_glProgramBufferParametersIuivNV
void __stdcall GLee_Lazy_glProgramBufferParametersIuivNV(GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLuint * params) {if (GLeeInit()) glProgramBufferParametersIuivNV(target, buffer, index, count, params);}
GLEEPFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC GLeeFuncPtr_glProgramBufferParametersIuivNV=GLee_Lazy_glProgramBufferParametersIuivNV;
#endif
#endif
/* GL_EXT_draw_buffers2 */
#ifdef __GLEE_GL_EXT_draw_buffers2
#ifndef GLEE_C_DEFINED_glColorMaskIndexedEXT
#define GLEE_C_DEFINED_glColorMaskIndexedEXT
void __stdcall GLee_Lazy_glColorMaskIndexedEXT(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) {if (GLeeInit()) glColorMaskIndexedEXT(index, r, g, b, a);}
GLEEPFNGLCOLORMASKINDEXEDEXTPROC GLeeFuncPtr_glColorMaskIndexedEXT=GLee_Lazy_glColorMaskIndexedEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetBooleanIndexedvEXT
#define GLEE_C_DEFINED_glGetBooleanIndexedvEXT
void __stdcall GLee_Lazy_glGetBooleanIndexedvEXT(GLenum target, GLuint index, GLboolean * data) {if (GLeeInit()) glGetBooleanIndexedvEXT(target, index, data);}
GLEEPFNGLGETBOOLEANINDEXEDVEXTPROC GLeeFuncPtr_glGetBooleanIndexedvEXT=GLee_Lazy_glGetBooleanIndexedvEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetIntegerIndexedvEXT
#define GLEE_C_DEFINED_glGetIntegerIndexedvEXT
void __stdcall GLee_Lazy_glGetIntegerIndexedvEXT(GLenum target, GLuint index, GLint * data) {if (GLeeInit()) glGetIntegerIndexedvEXT(target, index, data);}
GLEEPFNGLGETINTEGERINDEXEDVEXTPROC GLeeFuncPtr_glGetIntegerIndexedvEXT=GLee_Lazy_glGetIntegerIndexedvEXT;
#endif
#ifndef GLEE_C_DEFINED_glEnableIndexedEXT
#define GLEE_C_DEFINED_glEnableIndexedEXT
void __stdcall GLee_Lazy_glEnableIndexedEXT(GLenum target, GLuint index) {if (GLeeInit()) glEnableIndexedEXT(target, index);}
GLEEPFNGLENABLEINDEXEDEXTPROC GLeeFuncPtr_glEnableIndexedEXT=GLee_Lazy_glEnableIndexedEXT;
#endif
#ifndef GLEE_C_DEFINED_glDisableIndexedEXT
#define GLEE_C_DEFINED_glDisableIndexedEXT
void __stdcall GLee_Lazy_glDisableIndexedEXT(GLenum target, GLuint index) {if (GLeeInit()) glDisableIndexedEXT(target, index);}
GLEEPFNGLDISABLEINDEXEDEXTPROC GLeeFuncPtr_glDisableIndexedEXT=GLee_Lazy_glDisableIndexedEXT;
#endif
#ifndef GLEE_C_DEFINED_glIsEnabledIndexedEXT
#define GLEE_C_DEFINED_glIsEnabledIndexedEXT
GLboolean __stdcall GLee_Lazy_glIsEnabledIndexedEXT(GLenum target, GLuint index) {if (GLeeInit()) return glIsEnabledIndexedEXT(target, index); return (GLboolean)0;}
GLEEPFNGLISENABLEDINDEXEDEXTPROC GLeeFuncPtr_glIsEnabledIndexedEXT=GLee_Lazy_glIsEnabledIndexedEXT;
#endif
#endif
/* GL_NV_transform_feedback */
#ifdef __GLEE_GL_NV_transform_feedback
#ifndef GLEE_C_DEFINED_glBeginTransformFeedbackNV
#define GLEE_C_DEFINED_glBeginTransformFeedbackNV
void __stdcall GLee_Lazy_glBeginTransformFeedbackNV(GLenum primitiveMode) {if (GLeeInit()) glBeginTransformFeedbackNV(primitiveMode);}
GLEEPFNGLBEGINTRANSFORMFEEDBACKNVPROC GLeeFuncPtr_glBeginTransformFeedbackNV=GLee_Lazy_glBeginTransformFeedbackNV;
#endif
#ifndef GLEE_C_DEFINED_glEndTransformFeedbackNV
#define GLEE_C_DEFINED_glEndTransformFeedbackNV
void __stdcall GLee_Lazy_glEndTransformFeedbackNV(void) {if (GLeeInit()) glEndTransformFeedbackNV();}
GLEEPFNGLENDTRANSFORMFEEDBACKNVPROC GLeeFuncPtr_glEndTransformFeedbackNV=GLee_Lazy_glEndTransformFeedbackNV;
#endif
#ifndef GLEE_C_DEFINED_glTransformFeedbackAttribsNV
#define GLEE_C_DEFINED_glTransformFeedbackAttribsNV
void __stdcall GLee_Lazy_glTransformFeedbackAttribsNV(GLuint count, const GLint * attribs, GLenum bufferMode) {if (GLeeInit()) glTransformFeedbackAttribsNV(count, attribs, bufferMode);}
GLEEPFNGLTRANSFORMFEEDBACKATTRIBSNVPROC GLeeFuncPtr_glTransformFeedbackAttribsNV=GLee_Lazy_glTransformFeedbackAttribsNV;
#endif
#ifndef GLEE_C_DEFINED_glBindBufferRangeNV
#define GLEE_C_DEFINED_glBindBufferRangeNV
void __stdcall GLee_Lazy_glBindBufferRangeNV(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) {if (GLeeInit()) glBindBufferRangeNV(target, index, buffer, offset, size);}
GLEEPFNGLBINDBUFFERRANGENVPROC GLeeFuncPtr_glBindBufferRangeNV=GLee_Lazy_glBindBufferRangeNV;
#endif
#ifndef GLEE_C_DEFINED_glBindBufferOffsetNV
#define GLEE_C_DEFINED_glBindBufferOffsetNV
void __stdcall GLee_Lazy_glBindBufferOffsetNV(GLenum target, GLuint index, GLuint buffer, GLintptr offset) {if (GLeeInit()) glBindBufferOffsetNV(target, index, buffer, offset);}
GLEEPFNGLBINDBUFFEROFFSETNVPROC GLeeFuncPtr_glBindBufferOffsetNV=GLee_Lazy_glBindBufferOffsetNV;
#endif
#ifndef GLEE_C_DEFINED_glBindBufferBaseNV
#define GLEE_C_DEFINED_glBindBufferBaseNV
void __stdcall GLee_Lazy_glBindBufferBaseNV(GLenum target, GLuint index, GLuint buffer) {if (GLeeInit()) glBindBufferBaseNV(target, index, buffer);}
GLEEPFNGLBINDBUFFERBASENVPROC GLeeFuncPtr_glBindBufferBaseNV=GLee_Lazy_glBindBufferBaseNV;
#endif
#ifndef GLEE_C_DEFINED_glTransformFeedbackVaryingsNV
#define GLEE_C_DEFINED_glTransformFeedbackVaryingsNV
void __stdcall GLee_Lazy_glTransformFeedbackVaryingsNV(GLuint program, GLsizei count, const GLint * locations, GLenum bufferMode) {if (GLeeInit()) glTransformFeedbackVaryingsNV(program, count, locations, bufferMode);}
GLEEPFNGLTRANSFORMFEEDBACKVARYINGSNVPROC GLeeFuncPtr_glTransformFeedbackVaryingsNV=GLee_Lazy_glTransformFeedbackVaryingsNV;
#endif
#ifndef GLEE_C_DEFINED_glActiveVaryingNV
#define GLEE_C_DEFINED_glActiveVaryingNV
void __stdcall GLee_Lazy_glActiveVaryingNV(GLuint program, const GLchar * name) {if (GLeeInit()) glActiveVaryingNV(program, name);}
GLEEPFNGLACTIVEVARYINGNVPROC GLeeFuncPtr_glActiveVaryingNV=GLee_Lazy_glActiveVaryingNV;
#endif
#ifndef GLEE_C_DEFINED_glGetVaryingLocationNV
#define GLEE_C_DEFINED_glGetVaryingLocationNV
GLint __stdcall GLee_Lazy_glGetVaryingLocationNV(GLuint program, const GLchar * name) {if (GLeeInit()) return glGetVaryingLocationNV(program, name); return (GLint)0;}
GLEEPFNGLGETVARYINGLOCATIONNVPROC GLeeFuncPtr_glGetVaryingLocationNV=GLee_Lazy_glGetVaryingLocationNV;
#endif
#ifndef GLEE_C_DEFINED_glGetActiveVaryingNV
#define GLEE_C_DEFINED_glGetActiveVaryingNV
void __stdcall GLee_Lazy_glGetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name) {if (GLeeInit()) glGetActiveVaryingNV(program, index, bufSize, length, size, type, name);}
GLEEPFNGLGETACTIVEVARYINGNVPROC GLeeFuncPtr_glGetActiveVaryingNV=GLee_Lazy_glGetActiveVaryingNV;
#endif
#ifndef GLEE_C_DEFINED_glGetTransformFeedbackVaryingNV
#define GLEE_C_DEFINED_glGetTransformFeedbackVaryingNV
void __stdcall GLee_Lazy_glGetTransformFeedbackVaryingNV(GLuint program, GLuint index, GLint * location) {if (GLeeInit()) glGetTransformFeedbackVaryingNV(program, index, location);}
GLEEPFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC GLeeFuncPtr_glGetTransformFeedbackVaryingNV=GLee_Lazy_glGetTransformFeedbackVaryingNV;
#endif
#endif
/* GL_EXT_bindable_uniform */
#ifdef __GLEE_GL_EXT_bindable_uniform
#ifndef GLEE_C_DEFINED_glUniformBufferEXT
#define GLEE_C_DEFINED_glUniformBufferEXT
void __stdcall GLee_Lazy_glUniformBufferEXT(GLuint program, GLint location, GLuint buffer) {if (GLeeInit()) glUniformBufferEXT(program, location, buffer);}
GLEEPFNGLUNIFORMBUFFEREXTPROC GLeeFuncPtr_glUniformBufferEXT=GLee_Lazy_glUniformBufferEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetUniformBufferSizeEXT
#define GLEE_C_DEFINED_glGetUniformBufferSizeEXT
GLint __stdcall GLee_Lazy_glGetUniformBufferSizeEXT(GLuint program, GLint location) {if (GLeeInit()) return glGetUniformBufferSizeEXT(program, location); return (GLint)0;}
GLEEPFNGLGETUNIFORMBUFFERSIZEEXTPROC GLeeFuncPtr_glGetUniformBufferSizeEXT=GLee_Lazy_glGetUniformBufferSizeEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetUniformOffsetEXT
#define GLEE_C_DEFINED_glGetUniformOffsetEXT
GLintptr __stdcall GLee_Lazy_glGetUniformOffsetEXT(GLuint program, GLint location) {if (GLeeInit()) return glGetUniformOffsetEXT(program, location); return (GLintptr)0;}
GLEEPFNGLGETUNIFORMOFFSETEXTPROC GLeeFuncPtr_glGetUniformOffsetEXT=GLee_Lazy_glGetUniformOffsetEXT;
#endif
#endif
/* GL_EXT_texture_integer */
#ifdef __GLEE_GL_EXT_texture_integer
#ifndef GLEE_C_DEFINED_glTexParameterIivEXT
#define GLEE_C_DEFINED_glTexParameterIivEXT
void __stdcall GLee_Lazy_glTexParameterIivEXT(GLenum target, GLenum pname, const GLint * params) {if (GLeeInit()) glTexParameterIivEXT(target, pname, params);}
GLEEPFNGLTEXPARAMETERIIVEXTPROC GLeeFuncPtr_glTexParameterIivEXT=GLee_Lazy_glTexParameterIivEXT;
#endif
#ifndef GLEE_C_DEFINED_glTexParameterIuivEXT
#define GLEE_C_DEFINED_glTexParameterIuivEXT
void __stdcall GLee_Lazy_glTexParameterIuivEXT(GLenum target, GLenum pname, const GLuint * params) {if (GLeeInit()) glTexParameterIuivEXT(target, pname, params);}
GLEEPFNGLTEXPARAMETERIUIVEXTPROC GLeeFuncPtr_glTexParameterIuivEXT=GLee_Lazy_glTexParameterIuivEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetTexParameterIivEXT
#define GLEE_C_DEFINED_glGetTexParameterIivEXT
void __stdcall GLee_Lazy_glGetTexParameterIivEXT(GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetTexParameterIivEXT(target, pname, params);}
GLEEPFNGLGETTEXPARAMETERIIVEXTPROC GLeeFuncPtr_glGetTexParameterIivEXT=GLee_Lazy_glGetTexParameterIivEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetTexParameterIuivEXT
#define GLEE_C_DEFINED_glGetTexParameterIuivEXT
void __stdcall GLee_Lazy_glGetTexParameterIuivEXT(GLenum target, GLenum pname, GLuint * params) {if (GLeeInit()) glGetTexParameterIuivEXT(target, pname, params);}
GLEEPFNGLGETTEXPARAMETERIUIVEXTPROC GLeeFuncPtr_glGetTexParameterIuivEXT=GLee_Lazy_glGetTexParameterIuivEXT;
#endif
#ifndef GLEE_C_DEFINED_glClearColorIiEXT
#define GLEE_C_DEFINED_glClearColorIiEXT
void __stdcall GLee_Lazy_glClearColorIiEXT(GLint red, GLint green, GLint blue, GLint alpha) {if (GLeeInit()) glClearColorIiEXT(red, green, blue, alpha);}
GLEEPFNGLCLEARCOLORIIEXTPROC GLeeFuncPtr_glClearColorIiEXT=GLee_Lazy_glClearColorIiEXT;
#endif
#ifndef GLEE_C_DEFINED_glClearColorIuiEXT
#define GLEE_C_DEFINED_glClearColorIuiEXT
void __stdcall GLee_Lazy_glClearColorIuiEXT(GLuint red, GLuint green, GLuint blue, GLuint alpha) {if (GLeeInit()) glClearColorIuiEXT(red, green, blue, alpha);}
GLEEPFNGLCLEARCOLORIUIEXTPROC GLeeFuncPtr_glClearColorIuiEXT=GLee_Lazy_glClearColorIuiEXT;
#endif
#endif
/* GL_GREMEDY_frame_terminator */
#ifdef __GLEE_GL_GREMEDY_frame_terminator
#ifndef GLEE_C_DEFINED_glFrameTerminatorGREMEDY
#define GLEE_C_DEFINED_glFrameTerminatorGREMEDY
void __stdcall GLee_Lazy_glFrameTerminatorGREMEDY(void) {if (GLeeInit()) glFrameTerminatorGREMEDY();}
GLEEPFNGLFRAMETERMINATORGREMEDYPROC GLeeFuncPtr_glFrameTerminatorGREMEDY=GLee_Lazy_glFrameTerminatorGREMEDY;
#endif
#endif
/* GL_NV_conditional_render */
#ifdef __GLEE_GL_NV_conditional_render
#ifndef GLEE_C_DEFINED_glBeginConditionalRenderNV
#define GLEE_C_DEFINED_glBeginConditionalRenderNV
void __stdcall GLee_Lazy_glBeginConditionalRenderNV(GLuint id, GLenum mode) {if (GLeeInit()) glBeginConditionalRenderNV(id, mode);}
GLEEPFNGLBEGINCONDITIONALRENDERNVPROC GLeeFuncPtr_glBeginConditionalRenderNV=GLee_Lazy_glBeginConditionalRenderNV;
#endif
#ifndef GLEE_C_DEFINED_glEndConditionalRenderNV
#define GLEE_C_DEFINED_glEndConditionalRenderNV
void __stdcall GLee_Lazy_glEndConditionalRenderNV(void) {if (GLeeInit()) glEndConditionalRenderNV();}
GLEEPFNGLENDCONDITIONALRENDERNVPROC GLeeFuncPtr_glEndConditionalRenderNV=GLee_Lazy_glEndConditionalRenderNV;
#endif
#endif
/* GL_NV_present_video */
#ifdef __GLEE_GL_NV_present_video
#endif
/* GL_EXT_transform_feedback */
#ifdef __GLEE_GL_EXT_transform_feedback
#ifndef GLEE_C_DEFINED_glBeginTransformFeedbackEXT
#define GLEE_C_DEFINED_glBeginTransformFeedbackEXT
void __stdcall GLee_Lazy_glBeginTransformFeedbackEXT(GLenum primitiveMode) {if (GLeeInit()) glBeginTransformFeedbackEXT(primitiveMode);}
GLEEPFNGLBEGINTRANSFORMFEEDBACKEXTPROC GLeeFuncPtr_glBeginTransformFeedbackEXT=GLee_Lazy_glBeginTransformFeedbackEXT;
#endif
#ifndef GLEE_C_DEFINED_glEndTransformFeedbackEXT
#define GLEE_C_DEFINED_glEndTransformFeedbackEXT
void __stdcall GLee_Lazy_glEndTransformFeedbackEXT(void) {if (GLeeInit()) glEndTransformFeedbackEXT();}
GLEEPFNGLENDTRANSFORMFEEDBACKEXTPROC GLeeFuncPtr_glEndTransformFeedbackEXT=GLee_Lazy_glEndTransformFeedbackEXT;
#endif
#ifndef GLEE_C_DEFINED_glBindBufferRangeEXT
#define GLEE_C_DEFINED_glBindBufferRangeEXT
void __stdcall GLee_Lazy_glBindBufferRangeEXT(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) {if (GLeeInit()) glBindBufferRangeEXT(target, index, buffer, offset, size);}
GLEEPFNGLBINDBUFFERRANGEEXTPROC GLeeFuncPtr_glBindBufferRangeEXT=GLee_Lazy_glBindBufferRangeEXT;
#endif
#ifndef GLEE_C_DEFINED_glBindBufferOffsetEXT
#define GLEE_C_DEFINED_glBindBufferOffsetEXT
void __stdcall GLee_Lazy_glBindBufferOffsetEXT(GLenum target, GLuint index, GLuint buffer, GLintptr offset) {if (GLeeInit()) glBindBufferOffsetEXT(target, index, buffer, offset);}
GLEEPFNGLBINDBUFFEROFFSETEXTPROC GLeeFuncPtr_glBindBufferOffsetEXT=GLee_Lazy_glBindBufferOffsetEXT;
#endif
#ifndef GLEE_C_DEFINED_glBindBufferBaseEXT
#define GLEE_C_DEFINED_glBindBufferBaseEXT
void __stdcall GLee_Lazy_glBindBufferBaseEXT(GLenum target, GLuint index, GLuint buffer) {if (GLeeInit()) glBindBufferBaseEXT(target, index, buffer);}
GLEEPFNGLBINDBUFFERBASEEXTPROC GLeeFuncPtr_glBindBufferBaseEXT=GLee_Lazy_glBindBufferBaseEXT;
#endif
#ifndef GLEE_C_DEFINED_glTransformFeedbackVaryingsEXT
#define GLEE_C_DEFINED_glTransformFeedbackVaryingsEXT
void __stdcall GLee_Lazy_glTransformFeedbackVaryingsEXT(GLuint program, GLsizei count, const GLint * locations, GLenum bufferMode) {if (GLeeInit()) glTransformFeedbackVaryingsEXT(program, count, locations, bufferMode);}
GLEEPFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC GLeeFuncPtr_glTransformFeedbackVaryingsEXT=GLee_Lazy_glTransformFeedbackVaryingsEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetTransformFeedbackVaryingEXT
#define GLEE_C_DEFINED_glGetTransformFeedbackVaryingEXT
void __stdcall GLee_Lazy_glGetTransformFeedbackVaryingEXT(GLuint program, GLuint index, GLint * location) {if (GLeeInit()) glGetTransformFeedbackVaryingEXT(program, index, location);}
GLEEPFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC GLeeFuncPtr_glGetTransformFeedbackVaryingEXT=GLee_Lazy_glGetTransformFeedbackVaryingEXT;
#endif
#endif
/* GL_EXT_direct_state_access */
#ifdef __GLEE_GL_EXT_direct_state_access
#ifndef GLEE_C_DEFINED_glClientAttribDefaultEXT
#define GLEE_C_DEFINED_glClientAttribDefaultEXT
void __stdcall GLee_Lazy_glClientAttribDefaultEXT(GLbitfield mask) {if (GLeeInit()) glClientAttribDefaultEXT(mask);}
GLEEPFNGLCLIENTATTRIBDEFAULTEXTPROC GLeeFuncPtr_glClientAttribDefaultEXT=GLee_Lazy_glClientAttribDefaultEXT;
#endif
#ifndef GLEE_C_DEFINED_glPushClientAttribDefaultEXT
#define GLEE_C_DEFINED_glPushClientAttribDefaultEXT
void __stdcall GLee_Lazy_glPushClientAttribDefaultEXT(GLbitfield mask) {if (GLeeInit()) glPushClientAttribDefaultEXT(mask);}
GLEEPFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC GLeeFuncPtr_glPushClientAttribDefaultEXT=GLee_Lazy_glPushClientAttribDefaultEXT;
#endif
#ifndef GLEE_C_DEFINED_glMatrixLoadfEXT
#define GLEE_C_DEFINED_glMatrixLoadfEXT
void __stdcall GLee_Lazy_glMatrixLoadfEXT(GLenum mode, const GLfloat * m) {if (GLeeInit()) glMatrixLoadfEXT(mode, m);}
GLEEPFNGLMATRIXLOADFEXTPROC GLeeFuncPtr_glMatrixLoadfEXT=GLee_Lazy_glMatrixLoadfEXT;
#endif
#ifndef GLEE_C_DEFINED_glMatrixLoaddEXT
#define GLEE_C_DEFINED_glMatrixLoaddEXT
void __stdcall GLee_Lazy_glMatrixLoaddEXT(GLenum mode, const GLdouble * m) {if (GLeeInit()) glMatrixLoaddEXT(mode, m);}
GLEEPFNGLMATRIXLOADDEXTPROC GLeeFuncPtr_glMatrixLoaddEXT=GLee_Lazy_glMatrixLoaddEXT;
#endif
#ifndef GLEE_C_DEFINED_glMatrixMultfEXT
#define GLEE_C_DEFINED_glMatrixMultfEXT
void __stdcall GLee_Lazy_glMatrixMultfEXT(GLenum mode, const GLfloat * m) {if (GLeeInit()) glMatrixMultfEXT(mode, m);}
GLEEPFNGLMATRIXMULTFEXTPROC GLeeFuncPtr_glMatrixMultfEXT=GLee_Lazy_glMatrixMultfEXT;
#endif
#ifndef GLEE_C_DEFINED_glMatrixMultdEXT
#define GLEE_C_DEFINED_glMatrixMultdEXT
void __stdcall GLee_Lazy_glMatrixMultdEXT(GLenum mode, const GLdouble * m) {if (GLeeInit()) glMatrixMultdEXT(mode, m);}
GLEEPFNGLMATRIXMULTDEXTPROC GLeeFuncPtr_glMatrixMultdEXT=GLee_Lazy_glMatrixMultdEXT;
#endif
#ifndef GLEE_C_DEFINED_glMatrixLoadIdentityEXT
#define GLEE_C_DEFINED_glMatrixLoadIdentityEXT
void __stdcall GLee_Lazy_glMatrixLoadIdentityEXT(GLenum mode) {if (GLeeInit()) glMatrixLoadIdentityEXT(mode);}
GLEEPFNGLMATRIXLOADIDENTITYEXTPROC GLeeFuncPtr_glMatrixLoadIdentityEXT=GLee_Lazy_glMatrixLoadIdentityEXT;
#endif
#ifndef GLEE_C_DEFINED_glMatrixRotatefEXT
#define GLEE_C_DEFINED_glMatrixRotatefEXT
void __stdcall GLee_Lazy_glMatrixRotatefEXT(GLenum mode, GLfloat angle, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glMatrixRotatefEXT(mode, angle, x, y, z);}
GLEEPFNGLMATRIXROTATEFEXTPROC GLeeFuncPtr_glMatrixRotatefEXT=GLee_Lazy_glMatrixRotatefEXT;
#endif
#ifndef GLEE_C_DEFINED_glMatrixRotatedEXT
#define GLEE_C_DEFINED_glMatrixRotatedEXT
void __stdcall GLee_Lazy_glMatrixRotatedEXT(GLenum mode, GLdouble angle, GLdouble x, GLdouble y, GLdouble z) {if (GLeeInit()) glMatrixRotatedEXT(mode, angle, x, y, z);}
GLEEPFNGLMATRIXROTATEDEXTPROC GLeeFuncPtr_glMatrixRotatedEXT=GLee_Lazy_glMatrixRotatedEXT;
#endif
#ifndef GLEE_C_DEFINED_glMatrixScalefEXT
#define GLEE_C_DEFINED_glMatrixScalefEXT
void __stdcall GLee_Lazy_glMatrixScalefEXT(GLenum mode, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glMatrixScalefEXT(mode, x, y, z);}
GLEEPFNGLMATRIXSCALEFEXTPROC GLeeFuncPtr_glMatrixScalefEXT=GLee_Lazy_glMatrixScalefEXT;
#endif
#ifndef GLEE_C_DEFINED_glMatrixScaledEXT
#define GLEE_C_DEFINED_glMatrixScaledEXT
void __stdcall GLee_Lazy_glMatrixScaledEXT(GLenum mode, GLdouble x, GLdouble y, GLdouble z) {if (GLeeInit()) glMatrixScaledEXT(mode, x, y, z);}
GLEEPFNGLMATRIXSCALEDEXTPROC GLeeFuncPtr_glMatrixScaledEXT=GLee_Lazy_glMatrixScaledEXT;
#endif
#ifndef GLEE_C_DEFINED_glMatrixTranslatefEXT
#define GLEE_C_DEFINED_glMatrixTranslatefEXT
void __stdcall GLee_Lazy_glMatrixTranslatefEXT(GLenum mode, GLfloat x, GLfloat y, GLfloat z) {if (GLeeInit()) glMatrixTranslatefEXT(mode, x, y, z);}
GLEEPFNGLMATRIXTRANSLATEFEXTPROC GLeeFuncPtr_glMatrixTranslatefEXT=GLee_Lazy_glMatrixTranslatefEXT;
#endif
#ifndef GLEE_C_DEFINED_glMatrixTranslatedEXT
#define GLEE_C_DEFINED_glMatrixTranslatedEXT
void __stdcall GLee_Lazy_glMatrixTranslatedEXT(GLenum mode, GLdouble x, GLdouble y, GLdouble z) {if (GLeeInit()) glMatrixTranslatedEXT(mode, x, y, z);}
GLEEPFNGLMATRIXTRANSLATEDEXTPROC GLeeFuncPtr_glMatrixTranslatedEXT=GLee_Lazy_glMatrixTranslatedEXT;
#endif
#ifndef GLEE_C_DEFINED_glMatrixFrustumEXT
#define GLEE_C_DEFINED_glMatrixFrustumEXT
void __stdcall GLee_Lazy_glMatrixFrustumEXT(GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) {if (GLeeInit()) glMatrixFrustumEXT(mode, left, right, bottom, top, zNear, zFar);}
GLEEPFNGLMATRIXFRUSTUMEXTPROC GLeeFuncPtr_glMatrixFrustumEXT=GLee_Lazy_glMatrixFrustumEXT;
#endif
#ifndef GLEE_C_DEFINED_glMatrixOrthoEXT
#define GLEE_C_DEFINED_glMatrixOrthoEXT
void __stdcall GLee_Lazy_glMatrixOrthoEXT(GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) {if (GLeeInit()) glMatrixOrthoEXT(mode, left, right, bottom, top, zNear, zFar);}
GLEEPFNGLMATRIXORTHOEXTPROC GLeeFuncPtr_glMatrixOrthoEXT=GLee_Lazy_glMatrixOrthoEXT;
#endif
#ifndef GLEE_C_DEFINED_glMatrixPopEXT
#define GLEE_C_DEFINED_glMatrixPopEXT
void __stdcall GLee_Lazy_glMatrixPopEXT(GLenum mode) {if (GLeeInit()) glMatrixPopEXT(mode);}
GLEEPFNGLMATRIXPOPEXTPROC GLeeFuncPtr_glMatrixPopEXT=GLee_Lazy_glMatrixPopEXT;
#endif
#ifndef GLEE_C_DEFINED_glMatrixPushEXT
#define GLEE_C_DEFINED_glMatrixPushEXT
void __stdcall GLee_Lazy_glMatrixPushEXT(GLenum mode) {if (GLeeInit()) glMatrixPushEXT(mode);}
GLEEPFNGLMATRIXPUSHEXTPROC GLeeFuncPtr_glMatrixPushEXT=GLee_Lazy_glMatrixPushEXT;
#endif
#ifndef GLEE_C_DEFINED_glMatrixLoadTransposefEXT
#define GLEE_C_DEFINED_glMatrixLoadTransposefEXT
void __stdcall GLee_Lazy_glMatrixLoadTransposefEXT(GLenum mode, const GLfloat * m) {if (GLeeInit()) glMatrixLoadTransposefEXT(mode, m);}
GLEEPFNGLMATRIXLOADTRANSPOSEFEXTPROC GLeeFuncPtr_glMatrixLoadTransposefEXT=GLee_Lazy_glMatrixLoadTransposefEXT;
#endif
#ifndef GLEE_C_DEFINED_glMatrixLoadTransposedEXT
#define GLEE_C_DEFINED_glMatrixLoadTransposedEXT
void __stdcall GLee_Lazy_glMatrixLoadTransposedEXT(GLenum mode, const GLdouble * m) {if (GLeeInit()) glMatrixLoadTransposedEXT(mode, m);}
GLEEPFNGLMATRIXLOADTRANSPOSEDEXTPROC GLeeFuncPtr_glMatrixLoadTransposedEXT=GLee_Lazy_glMatrixLoadTransposedEXT;
#endif
#ifndef GLEE_C_DEFINED_glMatrixMultTransposefEXT
#define GLEE_C_DEFINED_glMatrixMultTransposefEXT
void __stdcall GLee_Lazy_glMatrixMultTransposefEXT(GLenum mode, const GLfloat * m) {if (GLeeInit()) glMatrixMultTransposefEXT(mode, m);}
GLEEPFNGLMATRIXMULTTRANSPOSEFEXTPROC GLeeFuncPtr_glMatrixMultTransposefEXT=GLee_Lazy_glMatrixMultTransposefEXT;
#endif
#ifndef GLEE_C_DEFINED_glMatrixMultTransposedEXT
#define GLEE_C_DEFINED_glMatrixMultTransposedEXT
void __stdcall GLee_Lazy_glMatrixMultTransposedEXT(GLenum mode, const GLdouble * m) {if (GLeeInit()) glMatrixMultTransposedEXT(mode, m);}
GLEEPFNGLMATRIXMULTTRANSPOSEDEXTPROC GLeeFuncPtr_glMatrixMultTransposedEXT=GLee_Lazy_glMatrixMultTransposedEXT;
#endif
#ifndef GLEE_C_DEFINED_glTextureParameterfEXT
#define GLEE_C_DEFINED_glTextureParameterfEXT
void __stdcall GLee_Lazy_glTextureParameterfEXT(GLuint texture, GLenum target, GLenum pname, GLfloat param) {if (GLeeInit()) glTextureParameterfEXT(texture, target, pname, param);}
GLEEPFNGLTEXTUREPARAMETERFEXTPROC GLeeFuncPtr_glTextureParameterfEXT=GLee_Lazy_glTextureParameterfEXT;
#endif
#ifndef GLEE_C_DEFINED_glTextureParameterfvEXT
#define GLEE_C_DEFINED_glTextureParameterfvEXT
void __stdcall GLee_Lazy_glTextureParameterfvEXT(GLuint texture, GLenum target, GLenum pname, const GLfloat * params) {if (GLeeInit()) glTextureParameterfvEXT(texture, target, pname, params);}
GLEEPFNGLTEXTUREPARAMETERFVEXTPROC GLeeFuncPtr_glTextureParameterfvEXT=GLee_Lazy_glTextureParameterfvEXT;
#endif
#ifndef GLEE_C_DEFINED_glTextureParameteriEXT
#define GLEE_C_DEFINED_glTextureParameteriEXT
void __stdcall GLee_Lazy_glTextureParameteriEXT(GLuint texture, GLenum target, GLenum pname, GLint param) {if (GLeeInit()) glTextureParameteriEXT(texture, target, pname, param);}
GLEEPFNGLTEXTUREPARAMETERIEXTPROC GLeeFuncPtr_glTextureParameteriEXT=GLee_Lazy_glTextureParameteriEXT;
#endif
#ifndef GLEE_C_DEFINED_glTextureParameterivEXT
#define GLEE_C_DEFINED_glTextureParameterivEXT
void __stdcall GLee_Lazy_glTextureParameterivEXT(GLuint texture, GLenum target, GLenum pname, const GLint * params) {if (GLeeInit()) glTextureParameterivEXT(texture, target, pname, params);}
GLEEPFNGLTEXTUREPARAMETERIVEXTPROC GLeeFuncPtr_glTextureParameterivEXT=GLee_Lazy_glTextureParameterivEXT;
#endif
#ifndef GLEE_C_DEFINED_glTextureImage1DEXT
#define GLEE_C_DEFINED_glTextureImage1DEXT
void __stdcall GLee_Lazy_glTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glTextureImage1DEXT(texture, target, level, internalformat, width, border, format, type, pixels);}
GLEEPFNGLTEXTUREIMAGE1DEXTPROC GLeeFuncPtr_glTextureImage1DEXT=GLee_Lazy_glTextureImage1DEXT;
#endif
#ifndef GLEE_C_DEFINED_glTextureImage2DEXT
#define GLEE_C_DEFINED_glTextureImage2DEXT
void __stdcall GLee_Lazy_glTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glTextureImage2DEXT(texture, target, level, internalformat, width, height, border, format, type, pixels);}
GLEEPFNGLTEXTUREIMAGE2DEXTPROC GLeeFuncPtr_glTextureImage2DEXT=GLee_Lazy_glTextureImage2DEXT;
#endif
#ifndef GLEE_C_DEFINED_glTextureSubImage1DEXT
#define GLEE_C_DEFINED_glTextureSubImage1DEXT
void __stdcall GLee_Lazy_glTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glTextureSubImage1DEXT(texture, target, level, xoffset, width, format, type, pixels);}
GLEEPFNGLTEXTURESUBIMAGE1DEXTPROC GLeeFuncPtr_glTextureSubImage1DEXT=GLee_Lazy_glTextureSubImage1DEXT;
#endif
#ifndef GLEE_C_DEFINED_glTextureSubImage2DEXT
#define GLEE_C_DEFINED_glTextureSubImage2DEXT
void __stdcall GLee_Lazy_glTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, type, pixels);}
GLEEPFNGLTEXTURESUBIMAGE2DEXTPROC GLeeFuncPtr_glTextureSubImage2DEXT=GLee_Lazy_glTextureSubImage2DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCopyTextureImage1DEXT
#define GLEE_C_DEFINED_glCopyTextureImage1DEXT
void __stdcall GLee_Lazy_glCopyTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) {if (GLeeInit()) glCopyTextureImage1DEXT(texture, target, level, internalformat, x, y, width, border);}
GLEEPFNGLCOPYTEXTUREIMAGE1DEXTPROC GLeeFuncPtr_glCopyTextureImage1DEXT=GLee_Lazy_glCopyTextureImage1DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCopyTextureImage2DEXT
#define GLEE_C_DEFINED_glCopyTextureImage2DEXT
void __stdcall GLee_Lazy_glCopyTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {if (GLeeInit()) glCopyTextureImage2DEXT(texture, target, level, internalformat, x, y, width, height, border);}
GLEEPFNGLCOPYTEXTUREIMAGE2DEXTPROC GLeeFuncPtr_glCopyTextureImage2DEXT=GLee_Lazy_glCopyTextureImage2DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCopyTextureSubImage1DEXT
#define GLEE_C_DEFINED_glCopyTextureSubImage1DEXT
void __stdcall GLee_Lazy_glCopyTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) {if (GLeeInit()) glCopyTextureSubImage1DEXT(texture, target, level, xoffset, x, y, width);}
GLEEPFNGLCOPYTEXTURESUBIMAGE1DEXTPROC GLeeFuncPtr_glCopyTextureSubImage1DEXT=GLee_Lazy_glCopyTextureSubImage1DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCopyTextureSubImage2DEXT
#define GLEE_C_DEFINED_glCopyTextureSubImage2DEXT
void __stdcall GLee_Lazy_glCopyTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {if (GLeeInit()) glCopyTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, x, y, width, height);}
GLEEPFNGLCOPYTEXTURESUBIMAGE2DEXTPROC GLeeFuncPtr_glCopyTextureSubImage2DEXT=GLee_Lazy_glCopyTextureSubImage2DEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetTextureImageEXT
#define GLEE_C_DEFINED_glGetTextureImageEXT
void __stdcall GLee_Lazy_glGetTextureImageEXT(GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels) {if (GLeeInit()) glGetTextureImageEXT(texture, target, level, format, type, pixels);}
GLEEPFNGLGETTEXTUREIMAGEEXTPROC GLeeFuncPtr_glGetTextureImageEXT=GLee_Lazy_glGetTextureImageEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetTextureParameterfvEXT
#define GLEE_C_DEFINED_glGetTextureParameterfvEXT
void __stdcall GLee_Lazy_glGetTextureParameterfvEXT(GLuint texture, GLenum target, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetTextureParameterfvEXT(texture, target, pname, params);}
GLEEPFNGLGETTEXTUREPARAMETERFVEXTPROC GLeeFuncPtr_glGetTextureParameterfvEXT=GLee_Lazy_glGetTextureParameterfvEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetTextureParameterivEXT
#define GLEE_C_DEFINED_glGetTextureParameterivEXT
void __stdcall GLee_Lazy_glGetTextureParameterivEXT(GLuint texture, GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetTextureParameterivEXT(texture, target, pname, params);}
GLEEPFNGLGETTEXTUREPARAMETERIVEXTPROC GLeeFuncPtr_glGetTextureParameterivEXT=GLee_Lazy_glGetTextureParameterivEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetTextureLevelParameterfvEXT
#define GLEE_C_DEFINED_glGetTextureLevelParameterfvEXT
void __stdcall GLee_Lazy_glGetTextureLevelParameterfvEXT(GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetTextureLevelParameterfvEXT(texture, target, level, pname, params);}
GLEEPFNGLGETTEXTURELEVELPARAMETERFVEXTPROC GLeeFuncPtr_glGetTextureLevelParameterfvEXT=GLee_Lazy_glGetTextureLevelParameterfvEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetTextureLevelParameterivEXT
#define GLEE_C_DEFINED_glGetTextureLevelParameterivEXT
void __stdcall GLee_Lazy_glGetTextureLevelParameterivEXT(GLuint texture, GLenum target, GLint level, GLenum pname, GLint * params) {if (GLeeInit()) glGetTextureLevelParameterivEXT(texture, target, level, pname, params);}
GLEEPFNGLGETTEXTURELEVELPARAMETERIVEXTPROC GLeeFuncPtr_glGetTextureLevelParameterivEXT=GLee_Lazy_glGetTextureLevelParameterivEXT;
#endif
#ifndef GLEE_C_DEFINED_glTextureImage3DEXT
#define GLEE_C_DEFINED_glTextureImage3DEXT
void __stdcall GLee_Lazy_glTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glTextureImage3DEXT(texture, target, level, internalformat, width, height, depth, border, format, type, pixels);}
GLEEPFNGLTEXTUREIMAGE3DEXTPROC GLeeFuncPtr_glTextureImage3DEXT=GLee_Lazy_glTextureImage3DEXT;
#endif
#ifndef GLEE_C_DEFINED_glTextureSubImage3DEXT
#define GLEE_C_DEFINED_glTextureSubImage3DEXT
void __stdcall GLee_Lazy_glTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);}
GLEEPFNGLTEXTURESUBIMAGE3DEXTPROC GLeeFuncPtr_glTextureSubImage3DEXT=GLee_Lazy_glTextureSubImage3DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCopyTextureSubImage3DEXT
#define GLEE_C_DEFINED_glCopyTextureSubImage3DEXT
void __stdcall GLee_Lazy_glCopyTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) {if (GLeeInit()) glCopyTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, x, y, width, height);}
GLEEPFNGLCOPYTEXTURESUBIMAGE3DEXTPROC GLeeFuncPtr_glCopyTextureSubImage3DEXT=GLee_Lazy_glCopyTextureSubImage3DEXT;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexParameterfEXT
#define GLEE_C_DEFINED_glMultiTexParameterfEXT
void __stdcall GLee_Lazy_glMultiTexParameterfEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat param) {if (GLeeInit()) glMultiTexParameterfEXT(texunit, target, pname, param);}
GLEEPFNGLMULTITEXPARAMETERFEXTPROC GLeeFuncPtr_glMultiTexParameterfEXT=GLee_Lazy_glMultiTexParameterfEXT;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexParameterfvEXT
#define GLEE_C_DEFINED_glMultiTexParameterfvEXT
void __stdcall GLee_Lazy_glMultiTexParameterfvEXT(GLenum texunit, GLenum target, GLenum pname, const GLfloat * params) {if (GLeeInit()) glMultiTexParameterfvEXT(texunit, target, pname, params);}
GLEEPFNGLMULTITEXPARAMETERFVEXTPROC GLeeFuncPtr_glMultiTexParameterfvEXT=GLee_Lazy_glMultiTexParameterfvEXT;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexParameteriEXT
#define GLEE_C_DEFINED_glMultiTexParameteriEXT
void __stdcall GLee_Lazy_glMultiTexParameteriEXT(GLenum texunit, GLenum target, GLenum pname, GLint param) {if (GLeeInit()) glMultiTexParameteriEXT(texunit, target, pname, param);}
GLEEPFNGLMULTITEXPARAMETERIEXTPROC GLeeFuncPtr_glMultiTexParameteriEXT=GLee_Lazy_glMultiTexParameteriEXT;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexParameterivEXT
#define GLEE_C_DEFINED_glMultiTexParameterivEXT
void __stdcall GLee_Lazy_glMultiTexParameterivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint * params) {if (GLeeInit()) glMultiTexParameterivEXT(texunit, target, pname, params);}
GLEEPFNGLMULTITEXPARAMETERIVEXTPROC GLeeFuncPtr_glMultiTexParameterivEXT=GLee_Lazy_glMultiTexParameterivEXT;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexImage1DEXT
#define GLEE_C_DEFINED_glMultiTexImage1DEXT
void __stdcall GLee_Lazy_glMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glMultiTexImage1DEXT(texunit, target, level, internalformat, width, border, format, type, pixels);}
GLEEPFNGLMULTITEXIMAGE1DEXTPROC GLeeFuncPtr_glMultiTexImage1DEXT=GLee_Lazy_glMultiTexImage1DEXT;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexImage2DEXT
#define GLEE_C_DEFINED_glMultiTexImage2DEXT
void __stdcall GLee_Lazy_glMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glMultiTexImage2DEXT(texunit, target, level, internalformat, width, height, border, format, type, pixels);}
GLEEPFNGLMULTITEXIMAGE2DEXTPROC GLeeFuncPtr_glMultiTexImage2DEXT=GLee_Lazy_glMultiTexImage2DEXT;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexSubImage1DEXT
#define GLEE_C_DEFINED_glMultiTexSubImage1DEXT
void __stdcall GLee_Lazy_glMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glMultiTexSubImage1DEXT(texunit, target, level, xoffset, width, format, type, pixels);}
GLEEPFNGLMULTITEXSUBIMAGE1DEXTPROC GLeeFuncPtr_glMultiTexSubImage1DEXT=GLee_Lazy_glMultiTexSubImage1DEXT;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexSubImage2DEXT
#define GLEE_C_DEFINED_glMultiTexSubImage2DEXT
void __stdcall GLee_Lazy_glMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glMultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, width, height, format, type, pixels);}
GLEEPFNGLMULTITEXSUBIMAGE2DEXTPROC GLeeFuncPtr_glMultiTexSubImage2DEXT=GLee_Lazy_glMultiTexSubImage2DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCopyMultiTexImage1DEXT
#define GLEE_C_DEFINED_glCopyMultiTexImage1DEXT
void __stdcall GLee_Lazy_glCopyMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) {if (GLeeInit()) glCopyMultiTexImage1DEXT(texunit, target, level, internalformat, x, y, width, border);}
GLEEPFNGLCOPYMULTITEXIMAGE1DEXTPROC GLeeFuncPtr_glCopyMultiTexImage1DEXT=GLee_Lazy_glCopyMultiTexImage1DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCopyMultiTexImage2DEXT
#define GLEE_C_DEFINED_glCopyMultiTexImage2DEXT
void __stdcall GLee_Lazy_glCopyMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {if (GLeeInit()) glCopyMultiTexImage2DEXT(texunit, target, level, internalformat, x, y, width, height, border);}
GLEEPFNGLCOPYMULTITEXIMAGE2DEXTPROC GLeeFuncPtr_glCopyMultiTexImage2DEXT=GLee_Lazy_glCopyMultiTexImage2DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCopyMultiTexSubImage1DEXT
#define GLEE_C_DEFINED_glCopyMultiTexSubImage1DEXT
void __stdcall GLee_Lazy_glCopyMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) {if (GLeeInit()) glCopyMultiTexSubImage1DEXT(texunit, target, level, xoffset, x, y, width);}
GLEEPFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC GLeeFuncPtr_glCopyMultiTexSubImage1DEXT=GLee_Lazy_glCopyMultiTexSubImage1DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCopyMultiTexSubImage2DEXT
#define GLEE_C_DEFINED_glCopyMultiTexSubImage2DEXT
void __stdcall GLee_Lazy_glCopyMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {if (GLeeInit()) glCopyMultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, x, y, width, height);}
GLEEPFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC GLeeFuncPtr_glCopyMultiTexSubImage2DEXT=GLee_Lazy_glCopyMultiTexSubImage2DEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetMultiTexImageEXT
#define GLEE_C_DEFINED_glGetMultiTexImageEXT
void __stdcall GLee_Lazy_glGetMultiTexImageEXT(GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels) {if (GLeeInit()) glGetMultiTexImageEXT(texunit, target, level, format, type, pixels);}
GLEEPFNGLGETMULTITEXIMAGEEXTPROC GLeeFuncPtr_glGetMultiTexImageEXT=GLee_Lazy_glGetMultiTexImageEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetMultiTexParameterfvEXT
#define GLEE_C_DEFINED_glGetMultiTexParameterfvEXT
void __stdcall GLee_Lazy_glGetMultiTexParameterfvEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetMultiTexParameterfvEXT(texunit, target, pname, params);}
GLEEPFNGLGETMULTITEXPARAMETERFVEXTPROC GLeeFuncPtr_glGetMultiTexParameterfvEXT=GLee_Lazy_glGetMultiTexParameterfvEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetMultiTexParameterivEXT
#define GLEE_C_DEFINED_glGetMultiTexParameterivEXT
void __stdcall GLee_Lazy_glGetMultiTexParameterivEXT(GLenum texunit, GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetMultiTexParameterivEXT(texunit, target, pname, params);}
GLEEPFNGLGETMULTITEXPARAMETERIVEXTPROC GLeeFuncPtr_glGetMultiTexParameterivEXT=GLee_Lazy_glGetMultiTexParameterivEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetMultiTexLevelParameterfvEXT
#define GLEE_C_DEFINED_glGetMultiTexLevelParameterfvEXT
void __stdcall GLee_Lazy_glGetMultiTexLevelParameterfvEXT(GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetMultiTexLevelParameterfvEXT(texunit, target, level, pname, params);}
GLEEPFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC GLeeFuncPtr_glGetMultiTexLevelParameterfvEXT=GLee_Lazy_glGetMultiTexLevelParameterfvEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetMultiTexLevelParameterivEXT
#define GLEE_C_DEFINED_glGetMultiTexLevelParameterivEXT
void __stdcall GLee_Lazy_glGetMultiTexLevelParameterivEXT(GLenum texunit, GLenum target, GLint level, GLenum pname, GLint * params) {if (GLeeInit()) glGetMultiTexLevelParameterivEXT(texunit, target, level, pname, params);}
GLEEPFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC GLeeFuncPtr_glGetMultiTexLevelParameterivEXT=GLee_Lazy_glGetMultiTexLevelParameterivEXT;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexImage3DEXT
#define GLEE_C_DEFINED_glMultiTexImage3DEXT
void __stdcall GLee_Lazy_glMultiTexImage3DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glMultiTexImage3DEXT(texunit, target, level, internalformat, width, height, depth, border, format, type, pixels);}
GLEEPFNGLMULTITEXIMAGE3DEXTPROC GLeeFuncPtr_glMultiTexImage3DEXT=GLee_Lazy_glMultiTexImage3DEXT;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexSubImage3DEXT
#define GLEE_C_DEFINED_glMultiTexSubImage3DEXT
void __stdcall GLee_Lazy_glMultiTexSubImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels) {if (GLeeInit()) glMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);}
GLEEPFNGLMULTITEXSUBIMAGE3DEXTPROC GLeeFuncPtr_glMultiTexSubImage3DEXT=GLee_Lazy_glMultiTexSubImage3DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCopyMultiTexSubImage3DEXT
#define GLEE_C_DEFINED_glCopyMultiTexSubImage3DEXT
void __stdcall GLee_Lazy_glCopyMultiTexSubImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) {if (GLeeInit()) glCopyMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, x, y, width, height);}
GLEEPFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC GLeeFuncPtr_glCopyMultiTexSubImage3DEXT=GLee_Lazy_glCopyMultiTexSubImage3DEXT;
#endif
#ifndef GLEE_C_DEFINED_glBindMultiTextureEXT
#define GLEE_C_DEFINED_glBindMultiTextureEXT
void __stdcall GLee_Lazy_glBindMultiTextureEXT(GLenum texunit, GLenum target, GLuint texture) {if (GLeeInit()) glBindMultiTextureEXT(texunit, target, texture);}
GLEEPFNGLBINDMULTITEXTUREEXTPROC GLeeFuncPtr_glBindMultiTextureEXT=GLee_Lazy_glBindMultiTextureEXT;
#endif
#ifndef GLEE_C_DEFINED_glEnableClientStateIndexedEXT
#define GLEE_C_DEFINED_glEnableClientStateIndexedEXT
void __stdcall GLee_Lazy_glEnableClientStateIndexedEXT(GLenum array, GLuint index) {if (GLeeInit()) glEnableClientStateIndexedEXT(array, index);}
GLEEPFNGLENABLECLIENTSTATEINDEXEDEXTPROC GLeeFuncPtr_glEnableClientStateIndexedEXT=GLee_Lazy_glEnableClientStateIndexedEXT;
#endif
#ifndef GLEE_C_DEFINED_glDisableClientStateIndexedEXT
#define GLEE_C_DEFINED_glDisableClientStateIndexedEXT
void __stdcall GLee_Lazy_glDisableClientStateIndexedEXT(GLenum array, GLuint index) {if (GLeeInit()) glDisableClientStateIndexedEXT(array, index);}
GLEEPFNGLDISABLECLIENTSTATEINDEXEDEXTPROC GLeeFuncPtr_glDisableClientStateIndexedEXT=GLee_Lazy_glDisableClientStateIndexedEXT;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexCoordPointerEXT
#define GLEE_C_DEFINED_glMultiTexCoordPointerEXT
void __stdcall GLee_Lazy_glMultiTexCoordPointerEXT(GLenum texunit, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer) {if (GLeeInit()) glMultiTexCoordPointerEXT(texunit, size, type, stride, pointer);}
GLEEPFNGLMULTITEXCOORDPOINTEREXTPROC GLeeFuncPtr_glMultiTexCoordPointerEXT=GLee_Lazy_glMultiTexCoordPointerEXT;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexEnvfEXT
#define GLEE_C_DEFINED_glMultiTexEnvfEXT
void __stdcall GLee_Lazy_glMultiTexEnvfEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat param) {if (GLeeInit()) glMultiTexEnvfEXT(texunit, target, pname, param);}
GLEEPFNGLMULTITEXENVFEXTPROC GLeeFuncPtr_glMultiTexEnvfEXT=GLee_Lazy_glMultiTexEnvfEXT;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexEnvfvEXT
#define GLEE_C_DEFINED_glMultiTexEnvfvEXT
void __stdcall GLee_Lazy_glMultiTexEnvfvEXT(GLenum texunit, GLenum target, GLenum pname, const GLfloat * params) {if (GLeeInit()) glMultiTexEnvfvEXT(texunit, target, pname, params);}
GLEEPFNGLMULTITEXENVFVEXTPROC GLeeFuncPtr_glMultiTexEnvfvEXT=GLee_Lazy_glMultiTexEnvfvEXT;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexEnviEXT
#define GLEE_C_DEFINED_glMultiTexEnviEXT
void __stdcall GLee_Lazy_glMultiTexEnviEXT(GLenum texunit, GLenum target, GLenum pname, GLint param) {if (GLeeInit()) glMultiTexEnviEXT(texunit, target, pname, param);}
GLEEPFNGLMULTITEXENVIEXTPROC GLeeFuncPtr_glMultiTexEnviEXT=GLee_Lazy_glMultiTexEnviEXT;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexEnvivEXT
#define GLEE_C_DEFINED_glMultiTexEnvivEXT
void __stdcall GLee_Lazy_glMultiTexEnvivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint * params) {if (GLeeInit()) glMultiTexEnvivEXT(texunit, target, pname, params);}
GLEEPFNGLMULTITEXENVIVEXTPROC GLeeFuncPtr_glMultiTexEnvivEXT=GLee_Lazy_glMultiTexEnvivEXT;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexGendEXT
#define GLEE_C_DEFINED_glMultiTexGendEXT
void __stdcall GLee_Lazy_glMultiTexGendEXT(GLenum texunit, GLenum coord, GLenum pname, GLdouble param) {if (GLeeInit()) glMultiTexGendEXT(texunit, coord, pname, param);}
GLEEPFNGLMULTITEXGENDEXTPROC GLeeFuncPtr_glMultiTexGendEXT=GLee_Lazy_glMultiTexGendEXT;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexGendvEXT
#define GLEE_C_DEFINED_glMultiTexGendvEXT
void __stdcall GLee_Lazy_glMultiTexGendvEXT(GLenum texunit, GLenum coord, GLenum pname, const GLdouble * params) {if (GLeeInit()) glMultiTexGendvEXT(texunit, coord, pname, params);}
GLEEPFNGLMULTITEXGENDVEXTPROC GLeeFuncPtr_glMultiTexGendvEXT=GLee_Lazy_glMultiTexGendvEXT;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexGenfEXT
#define GLEE_C_DEFINED_glMultiTexGenfEXT
void __stdcall GLee_Lazy_glMultiTexGenfEXT(GLenum texunit, GLenum coord, GLenum pname, GLfloat param) {if (GLeeInit()) glMultiTexGenfEXT(texunit, coord, pname, param);}
GLEEPFNGLMULTITEXGENFEXTPROC GLeeFuncPtr_glMultiTexGenfEXT=GLee_Lazy_glMultiTexGenfEXT;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexGenfvEXT
#define GLEE_C_DEFINED_glMultiTexGenfvEXT
void __stdcall GLee_Lazy_glMultiTexGenfvEXT(GLenum texunit, GLenum coord, GLenum pname, const GLfloat * params) {if (GLeeInit()) glMultiTexGenfvEXT(texunit, coord, pname, params);}
GLEEPFNGLMULTITEXGENFVEXTPROC GLeeFuncPtr_glMultiTexGenfvEXT=GLee_Lazy_glMultiTexGenfvEXT;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexGeniEXT
#define GLEE_C_DEFINED_glMultiTexGeniEXT
void __stdcall GLee_Lazy_glMultiTexGeniEXT(GLenum texunit, GLenum coord, GLenum pname, GLint param) {if (GLeeInit()) glMultiTexGeniEXT(texunit, coord, pname, param);}
GLEEPFNGLMULTITEXGENIEXTPROC GLeeFuncPtr_glMultiTexGeniEXT=GLee_Lazy_glMultiTexGeniEXT;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexGenivEXT
#define GLEE_C_DEFINED_glMultiTexGenivEXT
void __stdcall GLee_Lazy_glMultiTexGenivEXT(GLenum texunit, GLenum coord, GLenum pname, const GLint * params) {if (GLeeInit()) glMultiTexGenivEXT(texunit, coord, pname, params);}
GLEEPFNGLMULTITEXGENIVEXTPROC GLeeFuncPtr_glMultiTexGenivEXT=GLee_Lazy_glMultiTexGenivEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetMultiTexEnvfvEXT
#define GLEE_C_DEFINED_glGetMultiTexEnvfvEXT
void __stdcall GLee_Lazy_glGetMultiTexEnvfvEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetMultiTexEnvfvEXT(texunit, target, pname, params);}
GLEEPFNGLGETMULTITEXENVFVEXTPROC GLeeFuncPtr_glGetMultiTexEnvfvEXT=GLee_Lazy_glGetMultiTexEnvfvEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetMultiTexEnvivEXT
#define GLEE_C_DEFINED_glGetMultiTexEnvivEXT
void __stdcall GLee_Lazy_glGetMultiTexEnvivEXT(GLenum texunit, GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetMultiTexEnvivEXT(texunit, target, pname, params);}
GLEEPFNGLGETMULTITEXENVIVEXTPROC GLeeFuncPtr_glGetMultiTexEnvivEXT=GLee_Lazy_glGetMultiTexEnvivEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetMultiTexGendvEXT
#define GLEE_C_DEFINED_glGetMultiTexGendvEXT
void __stdcall GLee_Lazy_glGetMultiTexGendvEXT(GLenum texunit, GLenum coord, GLenum pname, GLdouble * params) {if (GLeeInit()) glGetMultiTexGendvEXT(texunit, coord, pname, params);}
GLEEPFNGLGETMULTITEXGENDVEXTPROC GLeeFuncPtr_glGetMultiTexGendvEXT=GLee_Lazy_glGetMultiTexGendvEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetMultiTexGenfvEXT
#define GLEE_C_DEFINED_glGetMultiTexGenfvEXT
void __stdcall GLee_Lazy_glGetMultiTexGenfvEXT(GLenum texunit, GLenum coord, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetMultiTexGenfvEXT(texunit, coord, pname, params);}
GLEEPFNGLGETMULTITEXGENFVEXTPROC GLeeFuncPtr_glGetMultiTexGenfvEXT=GLee_Lazy_glGetMultiTexGenfvEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetMultiTexGenivEXT
#define GLEE_C_DEFINED_glGetMultiTexGenivEXT
void __stdcall GLee_Lazy_glGetMultiTexGenivEXT(GLenum texunit, GLenum coord, GLenum pname, GLint * params) {if (GLeeInit()) glGetMultiTexGenivEXT(texunit, coord, pname, params);}
GLEEPFNGLGETMULTITEXGENIVEXTPROC GLeeFuncPtr_glGetMultiTexGenivEXT=GLee_Lazy_glGetMultiTexGenivEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetFloatIndexedvEXT
#define GLEE_C_DEFINED_glGetFloatIndexedvEXT
void __stdcall GLee_Lazy_glGetFloatIndexedvEXT(GLenum target, GLuint index, GLfloat * data) {if (GLeeInit()) glGetFloatIndexedvEXT(target, index, data);}
GLEEPFNGLGETFLOATINDEXEDVEXTPROC GLeeFuncPtr_glGetFloatIndexedvEXT=GLee_Lazy_glGetFloatIndexedvEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetDoubleIndexedvEXT
#define GLEE_C_DEFINED_glGetDoubleIndexedvEXT
void __stdcall GLee_Lazy_glGetDoubleIndexedvEXT(GLenum target, GLuint index, GLdouble * data) {if (GLeeInit()) glGetDoubleIndexedvEXT(target, index, data);}
GLEEPFNGLGETDOUBLEINDEXEDVEXTPROC GLeeFuncPtr_glGetDoubleIndexedvEXT=GLee_Lazy_glGetDoubleIndexedvEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetPointerIndexedvEXT
#define GLEE_C_DEFINED_glGetPointerIndexedvEXT
void __stdcall GLee_Lazy_glGetPointerIndexedvEXT(GLenum target, GLuint index, GLvoid* * data) {if (GLeeInit()) glGetPointerIndexedvEXT(target, index, data);}
GLEEPFNGLGETPOINTERINDEXEDVEXTPROC GLeeFuncPtr_glGetPointerIndexedvEXT=GLee_Lazy_glGetPointerIndexedvEXT;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTextureImage3DEXT
#define GLEE_C_DEFINED_glCompressedTextureImage3DEXT
void __stdcall GLee_Lazy_glCompressedTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * bits) {if (GLeeInit()) glCompressedTextureImage3DEXT(texture, target, level, internalformat, width, height, depth, border, imageSize, bits);}
GLEEPFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC GLeeFuncPtr_glCompressedTextureImage3DEXT=GLee_Lazy_glCompressedTextureImage3DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTextureImage2DEXT
#define GLEE_C_DEFINED_glCompressedTextureImage2DEXT
void __stdcall GLee_Lazy_glCompressedTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * bits) {if (GLeeInit()) glCompressedTextureImage2DEXT(texture, target, level, internalformat, width, height, border, imageSize, bits);}
GLEEPFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC GLeeFuncPtr_glCompressedTextureImage2DEXT=GLee_Lazy_glCompressedTextureImage2DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTextureImage1DEXT
#define GLEE_C_DEFINED_glCompressedTextureImage1DEXT
void __stdcall GLee_Lazy_glCompressedTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid * bits) {if (GLeeInit()) glCompressedTextureImage1DEXT(texture, target, level, internalformat, width, border, imageSize, bits);}
GLEEPFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC GLeeFuncPtr_glCompressedTextureImage1DEXT=GLee_Lazy_glCompressedTextureImage1DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTextureSubImage3DEXT
#define GLEE_C_DEFINED_glCompressedTextureSubImage3DEXT
void __stdcall GLee_Lazy_glCompressedTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * bits) {if (GLeeInit()) glCompressedTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);}
GLEEPFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC GLeeFuncPtr_glCompressedTextureSubImage3DEXT=GLee_Lazy_glCompressedTextureSubImage3DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTextureSubImage2DEXT
#define GLEE_C_DEFINED_glCompressedTextureSubImage2DEXT
void __stdcall GLee_Lazy_glCompressedTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * bits) {if (GLeeInit()) glCompressedTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits);}
GLEEPFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC GLeeFuncPtr_glCompressedTextureSubImage2DEXT=GLee_Lazy_glCompressedTextureSubImage2DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCompressedTextureSubImage1DEXT
#define GLEE_C_DEFINED_glCompressedTextureSubImage1DEXT
void __stdcall GLee_Lazy_glCompressedTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * bits) {if (GLeeInit()) glCompressedTextureSubImage1DEXT(texture, target, level, xoffset, width, format, imageSize, bits);}
GLEEPFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC GLeeFuncPtr_glCompressedTextureSubImage1DEXT=GLee_Lazy_glCompressedTextureSubImage1DEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetCompressedTextureImageEXT
#define GLEE_C_DEFINED_glGetCompressedTextureImageEXT
void __stdcall GLee_Lazy_glGetCompressedTextureImageEXT(GLuint texture, GLenum target, GLint lod, GLvoid * img) {if (GLeeInit()) glGetCompressedTextureImageEXT(texture, target, lod, img);}
GLEEPFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC GLeeFuncPtr_glGetCompressedTextureImageEXT=GLee_Lazy_glGetCompressedTextureImageEXT;
#endif
#ifndef GLEE_C_DEFINED_glCompressedMultiTexImage3DEXT
#define GLEE_C_DEFINED_glCompressedMultiTexImage3DEXT
void __stdcall GLee_Lazy_glCompressedMultiTexImage3DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * bits) {if (GLeeInit()) glCompressedMultiTexImage3DEXT(texunit, target, level, internalformat, width, height, depth, border, imageSize, bits);}
GLEEPFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC GLeeFuncPtr_glCompressedMultiTexImage3DEXT=GLee_Lazy_glCompressedMultiTexImage3DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCompressedMultiTexImage2DEXT
#define GLEE_C_DEFINED_glCompressedMultiTexImage2DEXT
void __stdcall GLee_Lazy_glCompressedMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * bits) {if (GLeeInit()) glCompressedMultiTexImage2DEXT(texunit, target, level, internalformat, width, height, border, imageSize, bits);}
GLEEPFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC GLeeFuncPtr_glCompressedMultiTexImage2DEXT=GLee_Lazy_glCompressedMultiTexImage2DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCompressedMultiTexImage1DEXT
#define GLEE_C_DEFINED_glCompressedMultiTexImage1DEXT
void __stdcall GLee_Lazy_glCompressedMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid * bits) {if (GLeeInit()) glCompressedMultiTexImage1DEXT(texunit, target, level, internalformat, width, border, imageSize, bits);}
GLEEPFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC GLeeFuncPtr_glCompressedMultiTexImage1DEXT=GLee_Lazy_glCompressedMultiTexImage1DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCompressedMultiTexSubImage3DEXT
#define GLEE_C_DEFINED_glCompressedMultiTexSubImage3DEXT
void __stdcall GLee_Lazy_glCompressedMultiTexSubImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * bits) {if (GLeeInit()) glCompressedMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);}
GLEEPFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC GLeeFuncPtr_glCompressedMultiTexSubImage3DEXT=GLee_Lazy_glCompressedMultiTexSubImage3DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCompressedMultiTexSubImage2DEXT
#define GLEE_C_DEFINED_glCompressedMultiTexSubImage2DEXT
void __stdcall GLee_Lazy_glCompressedMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * bits) {if (GLeeInit()) glCompressedMultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, width, height, format, imageSize, bits);}
GLEEPFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC GLeeFuncPtr_glCompressedMultiTexSubImage2DEXT=GLee_Lazy_glCompressedMultiTexSubImage2DEXT;
#endif
#ifndef GLEE_C_DEFINED_glCompressedMultiTexSubImage1DEXT
#define GLEE_C_DEFINED_glCompressedMultiTexSubImage1DEXT
void __stdcall GLee_Lazy_glCompressedMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * bits) {if (GLeeInit()) glCompressedMultiTexSubImage1DEXT(texunit, target, level, xoffset, width, format, imageSize, bits);}
GLEEPFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC GLeeFuncPtr_glCompressedMultiTexSubImage1DEXT=GLee_Lazy_glCompressedMultiTexSubImage1DEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetCompressedMultiTexImageEXT
#define GLEE_C_DEFINED_glGetCompressedMultiTexImageEXT
void __stdcall GLee_Lazy_glGetCompressedMultiTexImageEXT(GLenum texunit, GLenum target, GLint lod, GLvoid * img) {if (GLeeInit()) glGetCompressedMultiTexImageEXT(texunit, target, lod, img);}
GLEEPFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC GLeeFuncPtr_glGetCompressedMultiTexImageEXT=GLee_Lazy_glGetCompressedMultiTexImageEXT;
#endif
#ifndef GLEE_C_DEFINED_glNamedProgramStringEXT
#define GLEE_C_DEFINED_glNamedProgramStringEXT
void __stdcall GLee_Lazy_glNamedProgramStringEXT(GLuint program, GLenum target, GLenum format, GLsizei len, const GLvoid * string) {if (GLeeInit()) glNamedProgramStringEXT(program, target, format, len, string);}
GLEEPFNGLNAMEDPROGRAMSTRINGEXTPROC GLeeFuncPtr_glNamedProgramStringEXT=GLee_Lazy_glNamedProgramStringEXT;
#endif
#ifndef GLEE_C_DEFINED_glNamedProgramLocalParameter4dEXT
#define GLEE_C_DEFINED_glNamedProgramLocalParameter4dEXT
void __stdcall GLee_Lazy_glNamedProgramLocalParameter4dEXT(GLuint program, GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {if (GLeeInit()) glNamedProgramLocalParameter4dEXT(program, target, index, x, y, z, w);}
GLEEPFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC GLeeFuncPtr_glNamedProgramLocalParameter4dEXT=GLee_Lazy_glNamedProgramLocalParameter4dEXT;
#endif
#ifndef GLEE_C_DEFINED_glNamedProgramLocalParameter4dvEXT
#define GLEE_C_DEFINED_glNamedProgramLocalParameter4dvEXT
void __stdcall GLee_Lazy_glNamedProgramLocalParameter4dvEXT(GLuint program, GLenum target, GLuint index, const GLdouble * params) {if (GLeeInit()) glNamedProgramLocalParameter4dvEXT(program, target, index, params);}
GLEEPFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC GLeeFuncPtr_glNamedProgramLocalParameter4dvEXT=GLee_Lazy_glNamedProgramLocalParameter4dvEXT;
#endif
#ifndef GLEE_C_DEFINED_glNamedProgramLocalParameter4fEXT
#define GLEE_C_DEFINED_glNamedProgramLocalParameter4fEXT
void __stdcall GLee_Lazy_glNamedProgramLocalParameter4fEXT(GLuint program, GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {if (GLeeInit()) glNamedProgramLocalParameter4fEXT(program, target, index, x, y, z, w);}
GLEEPFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC GLeeFuncPtr_glNamedProgramLocalParameter4fEXT=GLee_Lazy_glNamedProgramLocalParameter4fEXT;
#endif
#ifndef GLEE_C_DEFINED_glNamedProgramLocalParameter4fvEXT
#define GLEE_C_DEFINED_glNamedProgramLocalParameter4fvEXT
void __stdcall GLee_Lazy_glNamedProgramLocalParameter4fvEXT(GLuint program, GLenum target, GLuint index, const GLfloat * params) {if (GLeeInit()) glNamedProgramLocalParameter4fvEXT(program, target, index, params);}
GLEEPFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC GLeeFuncPtr_glNamedProgramLocalParameter4fvEXT=GLee_Lazy_glNamedProgramLocalParameter4fvEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetNamedProgramLocalParameterdvEXT
#define GLEE_C_DEFINED_glGetNamedProgramLocalParameterdvEXT
void __stdcall GLee_Lazy_glGetNamedProgramLocalParameterdvEXT(GLuint program, GLenum target, GLuint index, GLdouble * params) {if (GLeeInit()) glGetNamedProgramLocalParameterdvEXT(program, target, index, params);}
GLEEPFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC GLeeFuncPtr_glGetNamedProgramLocalParameterdvEXT=GLee_Lazy_glGetNamedProgramLocalParameterdvEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetNamedProgramLocalParameterfvEXT
#define GLEE_C_DEFINED_glGetNamedProgramLocalParameterfvEXT
void __stdcall GLee_Lazy_glGetNamedProgramLocalParameterfvEXT(GLuint program, GLenum target, GLuint index, GLfloat * params) {if (GLeeInit()) glGetNamedProgramLocalParameterfvEXT(program, target, index, params);}
GLEEPFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC GLeeFuncPtr_glGetNamedProgramLocalParameterfvEXT=GLee_Lazy_glGetNamedProgramLocalParameterfvEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetNamedProgramivEXT
#define GLEE_C_DEFINED_glGetNamedProgramivEXT
void __stdcall GLee_Lazy_glGetNamedProgramivEXT(GLuint program, GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetNamedProgramivEXT(program, target, pname, params);}
GLEEPFNGLGETNAMEDPROGRAMIVEXTPROC GLeeFuncPtr_glGetNamedProgramivEXT=GLee_Lazy_glGetNamedProgramivEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetNamedProgramStringEXT
#define GLEE_C_DEFINED_glGetNamedProgramStringEXT
void __stdcall GLee_Lazy_glGetNamedProgramStringEXT(GLuint program, GLenum target, GLenum pname, GLvoid * string) {if (GLeeInit()) glGetNamedProgramStringEXT(program, target, pname, string);}
GLEEPFNGLGETNAMEDPROGRAMSTRINGEXTPROC GLeeFuncPtr_glGetNamedProgramStringEXT=GLee_Lazy_glGetNamedProgramStringEXT;
#endif
#ifndef GLEE_C_DEFINED_glNamedProgramLocalParameters4fvEXT
#define GLEE_C_DEFINED_glNamedProgramLocalParameters4fvEXT
void __stdcall GLee_Lazy_glNamedProgramLocalParameters4fvEXT(GLuint program, GLenum target, GLuint index, GLsizei count, const GLfloat * params) {if (GLeeInit()) glNamedProgramLocalParameters4fvEXT(program, target, index, count, params);}
GLEEPFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC GLeeFuncPtr_glNamedProgramLocalParameters4fvEXT=GLee_Lazy_glNamedProgramLocalParameters4fvEXT;
#endif
#ifndef GLEE_C_DEFINED_glNamedProgramLocalParameterI4iEXT
#define GLEE_C_DEFINED_glNamedProgramLocalParameterI4iEXT
void __stdcall GLee_Lazy_glNamedProgramLocalParameterI4iEXT(GLuint program, GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w) {if (GLeeInit()) glNamedProgramLocalParameterI4iEXT(program, target, index, x, y, z, w);}
GLEEPFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC GLeeFuncPtr_glNamedProgramLocalParameterI4iEXT=GLee_Lazy_glNamedProgramLocalParameterI4iEXT;
#endif
#ifndef GLEE_C_DEFINED_glNamedProgramLocalParameterI4ivEXT
#define GLEE_C_DEFINED_glNamedProgramLocalParameterI4ivEXT
void __stdcall GLee_Lazy_glNamedProgramLocalParameterI4ivEXT(GLuint program, GLenum target, GLuint index, const GLint * params) {if (GLeeInit()) glNamedProgramLocalParameterI4ivEXT(program, target, index, params);}
GLEEPFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC GLeeFuncPtr_glNamedProgramLocalParameterI4ivEXT=GLee_Lazy_glNamedProgramLocalParameterI4ivEXT;
#endif
#ifndef GLEE_C_DEFINED_glNamedProgramLocalParametersI4ivEXT
#define GLEE_C_DEFINED_glNamedProgramLocalParametersI4ivEXT
void __stdcall GLee_Lazy_glNamedProgramLocalParametersI4ivEXT(GLuint program, GLenum target, GLuint index, GLsizei count, const GLint * params) {if (GLeeInit()) glNamedProgramLocalParametersI4ivEXT(program, target, index, count, params);}
GLEEPFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC GLeeFuncPtr_glNamedProgramLocalParametersI4ivEXT=GLee_Lazy_glNamedProgramLocalParametersI4ivEXT;
#endif
#ifndef GLEE_C_DEFINED_glNamedProgramLocalParameterI4uiEXT
#define GLEE_C_DEFINED_glNamedProgramLocalParameterI4uiEXT
void __stdcall GLee_Lazy_glNamedProgramLocalParameterI4uiEXT(GLuint program, GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) {if (GLeeInit()) glNamedProgramLocalParameterI4uiEXT(program, target, index, x, y, z, w);}
GLEEPFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC GLeeFuncPtr_glNamedProgramLocalParameterI4uiEXT=GLee_Lazy_glNamedProgramLocalParameterI4uiEXT;
#endif
#ifndef GLEE_C_DEFINED_glNamedProgramLocalParameterI4uivEXT
#define GLEE_C_DEFINED_glNamedProgramLocalParameterI4uivEXT
void __stdcall GLee_Lazy_glNamedProgramLocalParameterI4uivEXT(GLuint program, GLenum target, GLuint index, const GLuint * params) {if (GLeeInit()) glNamedProgramLocalParameterI4uivEXT(program, target, index, params);}
GLEEPFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC GLeeFuncPtr_glNamedProgramLocalParameterI4uivEXT=GLee_Lazy_glNamedProgramLocalParameterI4uivEXT;
#endif
#ifndef GLEE_C_DEFINED_glNamedProgramLocalParametersI4uivEXT
#define GLEE_C_DEFINED_glNamedProgramLocalParametersI4uivEXT
void __stdcall GLee_Lazy_glNamedProgramLocalParametersI4uivEXT(GLuint program, GLenum target, GLuint index, GLsizei count, const GLuint * params) {if (GLeeInit()) glNamedProgramLocalParametersI4uivEXT(program, target, index, count, params);}
GLEEPFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC GLeeFuncPtr_glNamedProgramLocalParametersI4uivEXT=GLee_Lazy_glNamedProgramLocalParametersI4uivEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetNamedProgramLocalParameterIivEXT
#define GLEE_C_DEFINED_glGetNamedProgramLocalParameterIivEXT
void __stdcall GLee_Lazy_glGetNamedProgramLocalParameterIivEXT(GLuint program, GLenum target, GLuint index, GLint * params) {if (GLeeInit()) glGetNamedProgramLocalParameterIivEXT(program, target, index, params);}
GLEEPFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC GLeeFuncPtr_glGetNamedProgramLocalParameterIivEXT=GLee_Lazy_glGetNamedProgramLocalParameterIivEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetNamedProgramLocalParameterIuivEXT
#define GLEE_C_DEFINED_glGetNamedProgramLocalParameterIuivEXT
void __stdcall GLee_Lazy_glGetNamedProgramLocalParameterIuivEXT(GLuint program, GLenum target, GLuint index, GLuint * params) {if (GLeeInit()) glGetNamedProgramLocalParameterIuivEXT(program, target, index, params);}
GLEEPFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC GLeeFuncPtr_glGetNamedProgramLocalParameterIuivEXT=GLee_Lazy_glGetNamedProgramLocalParameterIuivEXT;
#endif
#ifndef GLEE_C_DEFINED_glTextureParameterIivEXT
#define GLEE_C_DEFINED_glTextureParameterIivEXT
void __stdcall GLee_Lazy_glTextureParameterIivEXT(GLuint texture, GLenum target, GLenum pname, const GLint * params) {if (GLeeInit()) glTextureParameterIivEXT(texture, target, pname, params);}
GLEEPFNGLTEXTUREPARAMETERIIVEXTPROC GLeeFuncPtr_glTextureParameterIivEXT=GLee_Lazy_glTextureParameterIivEXT;
#endif
#ifndef GLEE_C_DEFINED_glTextureParameterIuivEXT
#define GLEE_C_DEFINED_glTextureParameterIuivEXT
void __stdcall GLee_Lazy_glTextureParameterIuivEXT(GLuint texture, GLenum target, GLenum pname, const GLuint * params) {if (GLeeInit()) glTextureParameterIuivEXT(texture, target, pname, params);}
GLEEPFNGLTEXTUREPARAMETERIUIVEXTPROC GLeeFuncPtr_glTextureParameterIuivEXT=GLee_Lazy_glTextureParameterIuivEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetTextureParameterIivEXT
#define GLEE_C_DEFINED_glGetTextureParameterIivEXT
void __stdcall GLee_Lazy_glGetTextureParameterIivEXT(GLuint texture, GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetTextureParameterIivEXT(texture, target, pname, params);}
GLEEPFNGLGETTEXTUREPARAMETERIIVEXTPROC GLeeFuncPtr_glGetTextureParameterIivEXT=GLee_Lazy_glGetTextureParameterIivEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetTextureParameterIuivEXT
#define GLEE_C_DEFINED_glGetTextureParameterIuivEXT
void __stdcall GLee_Lazy_glGetTextureParameterIuivEXT(GLuint texture, GLenum target, GLenum pname, GLuint * params) {if (GLeeInit()) glGetTextureParameterIuivEXT(texture, target, pname, params);}
GLEEPFNGLGETTEXTUREPARAMETERIUIVEXTPROC GLeeFuncPtr_glGetTextureParameterIuivEXT=GLee_Lazy_glGetTextureParameterIuivEXT;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexParameterIivEXT
#define GLEE_C_DEFINED_glMultiTexParameterIivEXT
void __stdcall GLee_Lazy_glMultiTexParameterIivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint * params) {if (GLeeInit()) glMultiTexParameterIivEXT(texunit, target, pname, params);}
GLEEPFNGLMULTITEXPARAMETERIIVEXTPROC GLeeFuncPtr_glMultiTexParameterIivEXT=GLee_Lazy_glMultiTexParameterIivEXT;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexParameterIuivEXT
#define GLEE_C_DEFINED_glMultiTexParameterIuivEXT
void __stdcall GLee_Lazy_glMultiTexParameterIuivEXT(GLenum texunit, GLenum target, GLenum pname, const GLuint * params) {if (GLeeInit()) glMultiTexParameterIuivEXT(texunit, target, pname, params);}
GLEEPFNGLMULTITEXPARAMETERIUIVEXTPROC GLeeFuncPtr_glMultiTexParameterIuivEXT=GLee_Lazy_glMultiTexParameterIuivEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetMultiTexParameterIivEXT
#define GLEE_C_DEFINED_glGetMultiTexParameterIivEXT
void __stdcall GLee_Lazy_glGetMultiTexParameterIivEXT(GLenum texunit, GLenum target, GLenum pname, GLint * params) {if (GLeeInit()) glGetMultiTexParameterIivEXT(texunit, target, pname, params);}
GLEEPFNGLGETMULTITEXPARAMETERIIVEXTPROC GLeeFuncPtr_glGetMultiTexParameterIivEXT=GLee_Lazy_glGetMultiTexParameterIivEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetMultiTexParameterIuivEXT
#define GLEE_C_DEFINED_glGetMultiTexParameterIuivEXT
void __stdcall GLee_Lazy_glGetMultiTexParameterIuivEXT(GLenum texunit, GLenum target, GLenum pname, GLuint * params) {if (GLeeInit()) glGetMultiTexParameterIuivEXT(texunit, target, pname, params);}
GLEEPFNGLGETMULTITEXPARAMETERIUIVEXTPROC GLeeFuncPtr_glGetMultiTexParameterIuivEXT=GLee_Lazy_glGetMultiTexParameterIuivEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniform1fEXT
#define GLEE_C_DEFINED_glProgramUniform1fEXT
void __stdcall GLee_Lazy_glProgramUniform1fEXT(GLuint program, GLint location, GLfloat v0) {if (GLeeInit()) glProgramUniform1fEXT(program, location, v0);}
GLEEPFNGLPROGRAMUNIFORM1FEXTPROC GLeeFuncPtr_glProgramUniform1fEXT=GLee_Lazy_glProgramUniform1fEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniform2fEXT
#define GLEE_C_DEFINED_glProgramUniform2fEXT
void __stdcall GLee_Lazy_glProgramUniform2fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1) {if (GLeeInit()) glProgramUniform2fEXT(program, location, v0, v1);}
GLEEPFNGLPROGRAMUNIFORM2FEXTPROC GLeeFuncPtr_glProgramUniform2fEXT=GLee_Lazy_glProgramUniform2fEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniform3fEXT
#define GLEE_C_DEFINED_glProgramUniform3fEXT
void __stdcall GLee_Lazy_glProgramUniform3fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {if (GLeeInit()) glProgramUniform3fEXT(program, location, v0, v1, v2);}
GLEEPFNGLPROGRAMUNIFORM3FEXTPROC GLeeFuncPtr_glProgramUniform3fEXT=GLee_Lazy_glProgramUniform3fEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniform4fEXT
#define GLEE_C_DEFINED_glProgramUniform4fEXT
void __stdcall GLee_Lazy_glProgramUniform4fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {if (GLeeInit()) glProgramUniform4fEXT(program, location, v0, v1, v2, v3);}
GLEEPFNGLPROGRAMUNIFORM4FEXTPROC GLeeFuncPtr_glProgramUniform4fEXT=GLee_Lazy_glProgramUniform4fEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniform1iEXT
#define GLEE_C_DEFINED_glProgramUniform1iEXT
void __stdcall GLee_Lazy_glProgramUniform1iEXT(GLuint program, GLint location, GLint v0) {if (GLeeInit()) glProgramUniform1iEXT(program, location, v0);}
GLEEPFNGLPROGRAMUNIFORM1IEXTPROC GLeeFuncPtr_glProgramUniform1iEXT=GLee_Lazy_glProgramUniform1iEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniform2iEXT
#define GLEE_C_DEFINED_glProgramUniform2iEXT
void __stdcall GLee_Lazy_glProgramUniform2iEXT(GLuint program, GLint location, GLint v0, GLint v1) {if (GLeeInit()) glProgramUniform2iEXT(program, location, v0, v1);}
GLEEPFNGLPROGRAMUNIFORM2IEXTPROC GLeeFuncPtr_glProgramUniform2iEXT=GLee_Lazy_glProgramUniform2iEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniform3iEXT
#define GLEE_C_DEFINED_glProgramUniform3iEXT
void __stdcall GLee_Lazy_glProgramUniform3iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2) {if (GLeeInit()) glProgramUniform3iEXT(program, location, v0, v1, v2);}
GLEEPFNGLPROGRAMUNIFORM3IEXTPROC GLeeFuncPtr_glProgramUniform3iEXT=GLee_Lazy_glProgramUniform3iEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniform4iEXT
#define GLEE_C_DEFINED_glProgramUniform4iEXT
void __stdcall GLee_Lazy_glProgramUniform4iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {if (GLeeInit()) glProgramUniform4iEXT(program, location, v0, v1, v2, v3);}
GLEEPFNGLPROGRAMUNIFORM4IEXTPROC GLeeFuncPtr_glProgramUniform4iEXT=GLee_Lazy_glProgramUniform4iEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniform1fvEXT
#define GLEE_C_DEFINED_glProgramUniform1fvEXT
void __stdcall GLee_Lazy_glProgramUniform1fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat * value) {if (GLeeInit()) glProgramUniform1fvEXT(program, location, count, value);}
GLEEPFNGLPROGRAMUNIFORM1FVEXTPROC GLeeFuncPtr_glProgramUniform1fvEXT=GLee_Lazy_glProgramUniform1fvEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniform2fvEXT
#define GLEE_C_DEFINED_glProgramUniform2fvEXT
void __stdcall GLee_Lazy_glProgramUniform2fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat * value) {if (GLeeInit()) glProgramUniform2fvEXT(program, location, count, value);}
GLEEPFNGLPROGRAMUNIFORM2FVEXTPROC GLeeFuncPtr_glProgramUniform2fvEXT=GLee_Lazy_glProgramUniform2fvEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniform3fvEXT
#define GLEE_C_DEFINED_glProgramUniform3fvEXT
void __stdcall GLee_Lazy_glProgramUniform3fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat * value) {if (GLeeInit()) glProgramUniform3fvEXT(program, location, count, value);}
GLEEPFNGLPROGRAMUNIFORM3FVEXTPROC GLeeFuncPtr_glProgramUniform3fvEXT=GLee_Lazy_glProgramUniform3fvEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniform4fvEXT
#define GLEE_C_DEFINED_glProgramUniform4fvEXT
void __stdcall GLee_Lazy_glProgramUniform4fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat * value) {if (GLeeInit()) glProgramUniform4fvEXT(program, location, count, value);}
GLEEPFNGLPROGRAMUNIFORM4FVEXTPROC GLeeFuncPtr_glProgramUniform4fvEXT=GLee_Lazy_glProgramUniform4fvEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniform1ivEXT
#define GLEE_C_DEFINED_glProgramUniform1ivEXT
void __stdcall GLee_Lazy_glProgramUniform1ivEXT(GLuint program, GLint location, GLsizei count, const GLint * value) {if (GLeeInit()) glProgramUniform1ivEXT(program, location, count, value);}
GLEEPFNGLPROGRAMUNIFORM1IVEXTPROC GLeeFuncPtr_glProgramUniform1ivEXT=GLee_Lazy_glProgramUniform1ivEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniform2ivEXT
#define GLEE_C_DEFINED_glProgramUniform2ivEXT
void __stdcall GLee_Lazy_glProgramUniform2ivEXT(GLuint program, GLint location, GLsizei count, const GLint * value) {if (GLeeInit()) glProgramUniform2ivEXT(program, location, count, value);}
GLEEPFNGLPROGRAMUNIFORM2IVEXTPROC GLeeFuncPtr_glProgramUniform2ivEXT=GLee_Lazy_glProgramUniform2ivEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniform3ivEXT
#define GLEE_C_DEFINED_glProgramUniform3ivEXT
void __stdcall GLee_Lazy_glProgramUniform3ivEXT(GLuint program, GLint location, GLsizei count, const GLint * value) {if (GLeeInit()) glProgramUniform3ivEXT(program, location, count, value);}
GLEEPFNGLPROGRAMUNIFORM3IVEXTPROC GLeeFuncPtr_glProgramUniform3ivEXT=GLee_Lazy_glProgramUniform3ivEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniform4ivEXT
#define GLEE_C_DEFINED_glProgramUniform4ivEXT
void __stdcall GLee_Lazy_glProgramUniform4ivEXT(GLuint program, GLint location, GLsizei count, const GLint * value) {if (GLeeInit()) glProgramUniform4ivEXT(program, location, count, value);}
GLEEPFNGLPROGRAMUNIFORM4IVEXTPROC GLeeFuncPtr_glProgramUniform4ivEXT=GLee_Lazy_glProgramUniform4ivEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniformMatrix2fvEXT
#define GLEE_C_DEFINED_glProgramUniformMatrix2fvEXT
void __stdcall GLee_Lazy_glProgramUniformMatrix2fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glProgramUniformMatrix2fvEXT(program, location, count, transpose, value);}
GLEEPFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC GLeeFuncPtr_glProgramUniformMatrix2fvEXT=GLee_Lazy_glProgramUniformMatrix2fvEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniformMatrix3fvEXT
#define GLEE_C_DEFINED_glProgramUniformMatrix3fvEXT
void __stdcall GLee_Lazy_glProgramUniformMatrix3fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glProgramUniformMatrix3fvEXT(program, location, count, transpose, value);}
GLEEPFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC GLeeFuncPtr_glProgramUniformMatrix3fvEXT=GLee_Lazy_glProgramUniformMatrix3fvEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniformMatrix4fvEXT
#define GLEE_C_DEFINED_glProgramUniformMatrix4fvEXT
void __stdcall GLee_Lazy_glProgramUniformMatrix4fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glProgramUniformMatrix4fvEXT(program, location, count, transpose, value);}
GLEEPFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC GLeeFuncPtr_glProgramUniformMatrix4fvEXT=GLee_Lazy_glProgramUniformMatrix4fvEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniformMatrix2x3fvEXT
#define GLEE_C_DEFINED_glProgramUniformMatrix2x3fvEXT
void __stdcall GLee_Lazy_glProgramUniformMatrix2x3fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glProgramUniformMatrix2x3fvEXT(program, location, count, transpose, value);}
GLEEPFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC GLeeFuncPtr_glProgramUniformMatrix2x3fvEXT=GLee_Lazy_glProgramUniformMatrix2x3fvEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniformMatrix3x2fvEXT
#define GLEE_C_DEFINED_glProgramUniformMatrix3x2fvEXT
void __stdcall GLee_Lazy_glProgramUniformMatrix3x2fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glProgramUniformMatrix3x2fvEXT(program, location, count, transpose, value);}
GLEEPFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC GLeeFuncPtr_glProgramUniformMatrix3x2fvEXT=GLee_Lazy_glProgramUniformMatrix3x2fvEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniformMatrix2x4fvEXT
#define GLEE_C_DEFINED_glProgramUniformMatrix2x4fvEXT
void __stdcall GLee_Lazy_glProgramUniformMatrix2x4fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glProgramUniformMatrix2x4fvEXT(program, location, count, transpose, value);}
GLEEPFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC GLeeFuncPtr_glProgramUniformMatrix2x4fvEXT=GLee_Lazy_glProgramUniformMatrix2x4fvEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniformMatrix4x2fvEXT
#define GLEE_C_DEFINED_glProgramUniformMatrix4x2fvEXT
void __stdcall GLee_Lazy_glProgramUniformMatrix4x2fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glProgramUniformMatrix4x2fvEXT(program, location, count, transpose, value);}
GLEEPFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC GLeeFuncPtr_glProgramUniformMatrix4x2fvEXT=GLee_Lazy_glProgramUniformMatrix4x2fvEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniformMatrix3x4fvEXT
#define GLEE_C_DEFINED_glProgramUniformMatrix3x4fvEXT
void __stdcall GLee_Lazy_glProgramUniformMatrix3x4fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glProgramUniformMatrix3x4fvEXT(program, location, count, transpose, value);}
GLEEPFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC GLeeFuncPtr_glProgramUniformMatrix3x4fvEXT=GLee_Lazy_glProgramUniformMatrix3x4fvEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniformMatrix4x3fvEXT
#define GLEE_C_DEFINED_glProgramUniformMatrix4x3fvEXT
void __stdcall GLee_Lazy_glProgramUniformMatrix4x3fvEXT(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) {if (GLeeInit()) glProgramUniformMatrix4x3fvEXT(program, location, count, transpose, value);}
GLEEPFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC GLeeFuncPtr_glProgramUniformMatrix4x3fvEXT=GLee_Lazy_glProgramUniformMatrix4x3fvEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniform1uiEXT
#define GLEE_C_DEFINED_glProgramUniform1uiEXT
void __stdcall GLee_Lazy_glProgramUniform1uiEXT(GLuint program, GLint location, GLuint v0) {if (GLeeInit()) glProgramUniform1uiEXT(program, location, v0);}
GLEEPFNGLPROGRAMUNIFORM1UIEXTPROC GLeeFuncPtr_glProgramUniform1uiEXT=GLee_Lazy_glProgramUniform1uiEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniform2uiEXT
#define GLEE_C_DEFINED_glProgramUniform2uiEXT
void __stdcall GLee_Lazy_glProgramUniform2uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1) {if (GLeeInit()) glProgramUniform2uiEXT(program, location, v0, v1);}
GLEEPFNGLPROGRAMUNIFORM2UIEXTPROC GLeeFuncPtr_glProgramUniform2uiEXT=GLee_Lazy_glProgramUniform2uiEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniform3uiEXT
#define GLEE_C_DEFINED_glProgramUniform3uiEXT
void __stdcall GLee_Lazy_glProgramUniform3uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2) {if (GLeeInit()) glProgramUniform3uiEXT(program, location, v0, v1, v2);}
GLEEPFNGLPROGRAMUNIFORM3UIEXTPROC GLeeFuncPtr_glProgramUniform3uiEXT=GLee_Lazy_glProgramUniform3uiEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniform4uiEXT
#define GLEE_C_DEFINED_glProgramUniform4uiEXT
void __stdcall GLee_Lazy_glProgramUniform4uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) {if (GLeeInit()) glProgramUniform4uiEXT(program, location, v0, v1, v2, v3);}
GLEEPFNGLPROGRAMUNIFORM4UIEXTPROC GLeeFuncPtr_glProgramUniform4uiEXT=GLee_Lazy_glProgramUniform4uiEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniform1uivEXT
#define GLEE_C_DEFINED_glProgramUniform1uivEXT
void __stdcall GLee_Lazy_glProgramUniform1uivEXT(GLuint program, GLint location, GLsizei count, const GLuint * value) {if (GLeeInit()) glProgramUniform1uivEXT(program, location, count, value);}
GLEEPFNGLPROGRAMUNIFORM1UIVEXTPROC GLeeFuncPtr_glProgramUniform1uivEXT=GLee_Lazy_glProgramUniform1uivEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniform2uivEXT
#define GLEE_C_DEFINED_glProgramUniform2uivEXT
void __stdcall GLee_Lazy_glProgramUniform2uivEXT(GLuint program, GLint location, GLsizei count, const GLuint * value) {if (GLeeInit()) glProgramUniform2uivEXT(program, location, count, value);}
GLEEPFNGLPROGRAMUNIFORM2UIVEXTPROC GLeeFuncPtr_glProgramUniform2uivEXT=GLee_Lazy_glProgramUniform2uivEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniform3uivEXT
#define GLEE_C_DEFINED_glProgramUniform3uivEXT
void __stdcall GLee_Lazy_glProgramUniform3uivEXT(GLuint program, GLint location, GLsizei count, const GLuint * value) {if (GLeeInit()) glProgramUniform3uivEXT(program, location, count, value);}
GLEEPFNGLPROGRAMUNIFORM3UIVEXTPROC GLeeFuncPtr_glProgramUniform3uivEXT=GLee_Lazy_glProgramUniform3uivEXT;
#endif
#ifndef GLEE_C_DEFINED_glProgramUniform4uivEXT
#define GLEE_C_DEFINED_glProgramUniform4uivEXT
void __stdcall GLee_Lazy_glProgramUniform4uivEXT(GLuint program, GLint location, GLsizei count, const GLuint * value) {if (GLeeInit()) glProgramUniform4uivEXT(program, location, count, value);}
GLEEPFNGLPROGRAMUNIFORM4UIVEXTPROC GLeeFuncPtr_glProgramUniform4uivEXT=GLee_Lazy_glProgramUniform4uivEXT;
#endif
#ifndef GLEE_C_DEFINED_glNamedBufferDataEXT
#define GLEE_C_DEFINED_glNamedBufferDataEXT
void __stdcall GLee_Lazy_glNamedBufferDataEXT(GLuint buffer, GLsizeiptr size, const GLvoid * data, GLenum usage) {if (GLeeInit()) glNamedBufferDataEXT(buffer, size, data, usage);}
GLEEPFNGLNAMEDBUFFERDATAEXTPROC GLeeFuncPtr_glNamedBufferDataEXT=GLee_Lazy_glNamedBufferDataEXT;
#endif
#ifndef GLEE_C_DEFINED_glNamedBufferSubDataEXT
#define GLEE_C_DEFINED_glNamedBufferSubDataEXT
void __stdcall GLee_Lazy_glNamedBufferSubDataEXT(GLuint buffer, GLintptr offset, GLsizeiptr size, const GLvoid * data) {if (GLeeInit()) glNamedBufferSubDataEXT(buffer, offset, size, data);}
GLEEPFNGLNAMEDBUFFERSUBDATAEXTPROC GLeeFuncPtr_glNamedBufferSubDataEXT=GLee_Lazy_glNamedBufferSubDataEXT;
#endif
#ifndef GLEE_C_DEFINED_glMapNamedBufferEXT
#define GLEE_C_DEFINED_glMapNamedBufferEXT
GLvoid* __stdcall GLee_Lazy_glMapNamedBufferEXT(GLuint buffer, GLenum access) {if (GLeeInit()) return glMapNamedBufferEXT(buffer, access); return (GLvoid*)0;}
GLEEPFNGLMAPNAMEDBUFFEREXTPROC GLeeFuncPtr_glMapNamedBufferEXT=GLee_Lazy_glMapNamedBufferEXT;
#endif
#ifndef GLEE_C_DEFINED_glUnmapNamedBufferEXT
#define GLEE_C_DEFINED_glUnmapNamedBufferEXT
GLboolean __stdcall GLee_Lazy_glUnmapNamedBufferEXT(GLuint buffer) {if (GLeeInit()) return glUnmapNamedBufferEXT(buffer); return (GLboolean)0;}
GLEEPFNGLUNMAPNAMEDBUFFEREXTPROC GLeeFuncPtr_glUnmapNamedBufferEXT=GLee_Lazy_glUnmapNamedBufferEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetNamedBufferParameterivEXT
#define GLEE_C_DEFINED_glGetNamedBufferParameterivEXT
void __stdcall GLee_Lazy_glGetNamedBufferParameterivEXT(GLuint buffer, GLenum pname, GLint * params) {if (GLeeInit()) glGetNamedBufferParameterivEXT(buffer, pname, params);}
GLEEPFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC GLeeFuncPtr_glGetNamedBufferParameterivEXT=GLee_Lazy_glGetNamedBufferParameterivEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetNamedBufferPointervEXT
#define GLEE_C_DEFINED_glGetNamedBufferPointervEXT
void __stdcall GLee_Lazy_glGetNamedBufferPointervEXT(GLuint buffer, GLenum pname, GLvoid* * params) {if (GLeeInit()) glGetNamedBufferPointervEXT(buffer, pname, params);}
GLEEPFNGLGETNAMEDBUFFERPOINTERVEXTPROC GLeeFuncPtr_glGetNamedBufferPointervEXT=GLee_Lazy_glGetNamedBufferPointervEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetNamedBufferSubDataEXT
#define GLEE_C_DEFINED_glGetNamedBufferSubDataEXT
void __stdcall GLee_Lazy_glGetNamedBufferSubDataEXT(GLuint buffer, GLintptr offset, GLsizeiptr size, GLvoid * data) {if (GLeeInit()) glGetNamedBufferSubDataEXT(buffer, offset, size, data);}
GLEEPFNGLGETNAMEDBUFFERSUBDATAEXTPROC GLeeFuncPtr_glGetNamedBufferSubDataEXT=GLee_Lazy_glGetNamedBufferSubDataEXT;
#endif
#ifndef GLEE_C_DEFINED_glTextureBufferEXT
#define GLEE_C_DEFINED_glTextureBufferEXT
void __stdcall GLee_Lazy_glTextureBufferEXT(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer) {if (GLeeInit()) glTextureBufferEXT(texture, target, internalformat, buffer);}
GLEEPFNGLTEXTUREBUFFEREXTPROC GLeeFuncPtr_glTextureBufferEXT=GLee_Lazy_glTextureBufferEXT;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexBufferEXT
#define GLEE_C_DEFINED_glMultiTexBufferEXT
void __stdcall GLee_Lazy_glMultiTexBufferEXT(GLenum texunit, GLenum target, GLenum internalformat, GLuint buffer) {if (GLeeInit()) glMultiTexBufferEXT(texunit, target, internalformat, buffer);}
GLEEPFNGLMULTITEXBUFFEREXTPROC GLeeFuncPtr_glMultiTexBufferEXT=GLee_Lazy_glMultiTexBufferEXT;
#endif
#ifndef GLEE_C_DEFINED_glNamedRenderbufferStorageEXT
#define GLEE_C_DEFINED_glNamedRenderbufferStorageEXT
void __stdcall GLee_Lazy_glNamedRenderbufferStorageEXT(GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height) {if (GLeeInit()) glNamedRenderbufferStorageEXT(renderbuffer, internalformat, width, height);}
GLEEPFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC GLeeFuncPtr_glNamedRenderbufferStorageEXT=GLee_Lazy_glNamedRenderbufferStorageEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetNamedRenderbufferParameterivEXT
#define GLEE_C_DEFINED_glGetNamedRenderbufferParameterivEXT
void __stdcall GLee_Lazy_glGetNamedRenderbufferParameterivEXT(GLuint renderbuffer, GLenum pname, GLint * params) {if (GLeeInit()) glGetNamedRenderbufferParameterivEXT(renderbuffer, pname, params);}
GLEEPFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC GLeeFuncPtr_glGetNamedRenderbufferParameterivEXT=GLee_Lazy_glGetNamedRenderbufferParameterivEXT;
#endif
#ifndef GLEE_C_DEFINED_glCheckNamedFramebufferStatusEXT
#define GLEE_C_DEFINED_glCheckNamedFramebufferStatusEXT
GLenum __stdcall GLee_Lazy_glCheckNamedFramebufferStatusEXT(GLuint framebuffer, GLenum target) {if (GLeeInit()) return glCheckNamedFramebufferStatusEXT(framebuffer, target); return (GLenum)0;}
GLEEPFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC GLeeFuncPtr_glCheckNamedFramebufferStatusEXT=GLee_Lazy_glCheckNamedFramebufferStatusEXT;
#endif
#ifndef GLEE_C_DEFINED_glNamedFramebufferTexture1DEXT
#define GLEE_C_DEFINED_glNamedFramebufferTexture1DEXT
void __stdcall GLee_Lazy_glNamedFramebufferTexture1DEXT(GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {if (GLeeInit()) glNamedFramebufferTexture1DEXT(framebuffer, attachment, textarget, texture, level);}
GLEEPFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC GLeeFuncPtr_glNamedFramebufferTexture1DEXT=GLee_Lazy_glNamedFramebufferTexture1DEXT;
#endif
#ifndef GLEE_C_DEFINED_glNamedFramebufferTexture2DEXT
#define GLEE_C_DEFINED_glNamedFramebufferTexture2DEXT
void __stdcall GLee_Lazy_glNamedFramebufferTexture2DEXT(GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level) {if (GLeeInit()) glNamedFramebufferTexture2DEXT(framebuffer, attachment, textarget, texture, level);}
GLEEPFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC GLeeFuncPtr_glNamedFramebufferTexture2DEXT=GLee_Lazy_glNamedFramebufferTexture2DEXT;
#endif
#ifndef GLEE_C_DEFINED_glNamedFramebufferTexture3DEXT
#define GLEE_C_DEFINED_glNamedFramebufferTexture3DEXT
void __stdcall GLee_Lazy_glNamedFramebufferTexture3DEXT(GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) {if (GLeeInit()) glNamedFramebufferTexture3DEXT(framebuffer, attachment, textarget, texture, level, zoffset);}
GLEEPFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC GLeeFuncPtr_glNamedFramebufferTexture3DEXT=GLee_Lazy_glNamedFramebufferTexture3DEXT;
#endif
#ifndef GLEE_C_DEFINED_glNamedFramebufferRenderbufferEXT
#define GLEE_C_DEFINED_glNamedFramebufferRenderbufferEXT
void __stdcall GLee_Lazy_glNamedFramebufferRenderbufferEXT(GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) {if (GLeeInit()) glNamedFramebufferRenderbufferEXT(framebuffer, attachment, renderbuffertarget, renderbuffer);}
GLEEPFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC GLeeFuncPtr_glNamedFramebufferRenderbufferEXT=GLee_Lazy_glNamedFramebufferRenderbufferEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetNamedFramebufferAttachmentParameterivEXT
#define GLEE_C_DEFINED_glGetNamedFramebufferAttachmentParameterivEXT
void __stdcall GLee_Lazy_glGetNamedFramebufferAttachmentParameterivEXT(GLuint framebuffer, GLenum attachment, GLenum pname, GLint * params) {if (GLeeInit()) glGetNamedFramebufferAttachmentParameterivEXT(framebuffer, attachment, pname, params);}
GLEEPFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC GLeeFuncPtr_glGetNamedFramebufferAttachmentParameterivEXT=GLee_Lazy_glGetNamedFramebufferAttachmentParameterivEXT;
#endif
#ifndef GLEE_C_DEFINED_glGenerateTextureMipmapEXT
#define GLEE_C_DEFINED_glGenerateTextureMipmapEXT
void __stdcall GLee_Lazy_glGenerateTextureMipmapEXT(GLuint texture, GLenum target) {if (GLeeInit()) glGenerateTextureMipmapEXT(texture, target);}
GLEEPFNGLGENERATETEXTUREMIPMAPEXTPROC GLeeFuncPtr_glGenerateTextureMipmapEXT=GLee_Lazy_glGenerateTextureMipmapEXT;
#endif
#ifndef GLEE_C_DEFINED_glGenerateMultiTexMipmapEXT
#define GLEE_C_DEFINED_glGenerateMultiTexMipmapEXT
void __stdcall GLee_Lazy_glGenerateMultiTexMipmapEXT(GLenum texunit, GLenum target) {if (GLeeInit()) glGenerateMultiTexMipmapEXT(texunit, target);}
GLEEPFNGLGENERATEMULTITEXMIPMAPEXTPROC GLeeFuncPtr_glGenerateMultiTexMipmapEXT=GLee_Lazy_glGenerateMultiTexMipmapEXT;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferDrawBufferEXT
#define GLEE_C_DEFINED_glFramebufferDrawBufferEXT
void __stdcall GLee_Lazy_glFramebufferDrawBufferEXT(GLuint framebuffer, GLenum mode) {if (GLeeInit()) glFramebufferDrawBufferEXT(framebuffer, mode);}
GLEEPFNGLFRAMEBUFFERDRAWBUFFEREXTPROC GLeeFuncPtr_glFramebufferDrawBufferEXT=GLee_Lazy_glFramebufferDrawBufferEXT;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferDrawBuffersEXT
#define GLEE_C_DEFINED_glFramebufferDrawBuffersEXT
void __stdcall GLee_Lazy_glFramebufferDrawBuffersEXT(GLuint framebuffer, GLsizei n, const GLenum * bufs) {if (GLeeInit()) glFramebufferDrawBuffersEXT(framebuffer, n, bufs);}
GLEEPFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC GLeeFuncPtr_glFramebufferDrawBuffersEXT=GLee_Lazy_glFramebufferDrawBuffersEXT;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferReadBufferEXT
#define GLEE_C_DEFINED_glFramebufferReadBufferEXT
void __stdcall GLee_Lazy_glFramebufferReadBufferEXT(GLuint framebuffer, GLenum mode) {if (GLeeInit()) glFramebufferReadBufferEXT(framebuffer, mode);}
GLEEPFNGLFRAMEBUFFERREADBUFFEREXTPROC GLeeFuncPtr_glFramebufferReadBufferEXT=GLee_Lazy_glFramebufferReadBufferEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetFramebufferParameterivEXT
#define GLEE_C_DEFINED_glGetFramebufferParameterivEXT
void __stdcall GLee_Lazy_glGetFramebufferParameterivEXT(GLuint framebuffer, GLenum pname, GLint * params) {if (GLeeInit()) glGetFramebufferParameterivEXT(framebuffer, pname, params);}
GLEEPFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC GLeeFuncPtr_glGetFramebufferParameterivEXT=GLee_Lazy_glGetFramebufferParameterivEXT;
#endif
#ifndef GLEE_C_DEFINED_glNamedRenderbufferStorageMultisampleEXT
#define GLEE_C_DEFINED_glNamedRenderbufferStorageMultisampleEXT
void __stdcall GLee_Lazy_glNamedRenderbufferStorageMultisampleEXT(GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) {if (GLeeInit()) glNamedRenderbufferStorageMultisampleEXT(renderbuffer, samples, internalformat, width, height);}
GLEEPFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC GLeeFuncPtr_glNamedRenderbufferStorageMultisampleEXT=GLee_Lazy_glNamedRenderbufferStorageMultisampleEXT;
#endif
#ifndef GLEE_C_DEFINED_glNamedRenderbufferStorageMultisampleCoverageEXT
#define GLEE_C_DEFINED_glNamedRenderbufferStorageMultisampleCoverageEXT
void __stdcall GLee_Lazy_glNamedRenderbufferStorageMultisampleCoverageEXT(GLuint renderbuffer, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height) {if (GLeeInit()) glNamedRenderbufferStorageMultisampleCoverageEXT(renderbuffer, coverageSamples, colorSamples, internalformat, width, height);}
GLEEPFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC GLeeFuncPtr_glNamedRenderbufferStorageMultisampleCoverageEXT=GLee_Lazy_glNamedRenderbufferStorageMultisampleCoverageEXT;
#endif
#ifndef GLEE_C_DEFINED_glNamedFramebufferTextureEXT
#define GLEE_C_DEFINED_glNamedFramebufferTextureEXT
void __stdcall GLee_Lazy_glNamedFramebufferTextureEXT(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level) {if (GLeeInit()) glNamedFramebufferTextureEXT(framebuffer, attachment, texture, level);}
GLEEPFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC GLeeFuncPtr_glNamedFramebufferTextureEXT=GLee_Lazy_glNamedFramebufferTextureEXT;
#endif
#ifndef GLEE_C_DEFINED_glNamedFramebufferTextureLayerEXT
#define GLEE_C_DEFINED_glNamedFramebufferTextureLayerEXT
void __stdcall GLee_Lazy_glNamedFramebufferTextureLayerEXT(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer) {if (GLeeInit()) glNamedFramebufferTextureLayerEXT(framebuffer, attachment, texture, level, layer);}
GLEEPFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC GLeeFuncPtr_glNamedFramebufferTextureLayerEXT=GLee_Lazy_glNamedFramebufferTextureLayerEXT;
#endif
#ifndef GLEE_C_DEFINED_glNamedFramebufferTextureFaceEXT
#define GLEE_C_DEFINED_glNamedFramebufferTextureFaceEXT
void __stdcall GLee_Lazy_glNamedFramebufferTextureFaceEXT(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLenum face) {if (GLeeInit()) glNamedFramebufferTextureFaceEXT(framebuffer, attachment, texture, level, face);}
GLEEPFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC GLeeFuncPtr_glNamedFramebufferTextureFaceEXT=GLee_Lazy_glNamedFramebufferTextureFaceEXT;
#endif
#ifndef GLEE_C_DEFINED_glTextureRenderbufferEXT
#define GLEE_C_DEFINED_glTextureRenderbufferEXT
void __stdcall GLee_Lazy_glTextureRenderbufferEXT(GLuint texture, GLenum target, GLuint renderbuffer) {if (GLeeInit()) glTextureRenderbufferEXT(texture, target, renderbuffer);}
GLEEPFNGLTEXTURERENDERBUFFEREXTPROC GLeeFuncPtr_glTextureRenderbufferEXT=GLee_Lazy_glTextureRenderbufferEXT;
#endif
#ifndef GLEE_C_DEFINED_glMultiTexRenderbufferEXT
#define GLEE_C_DEFINED_glMultiTexRenderbufferEXT
void __stdcall GLee_Lazy_glMultiTexRenderbufferEXT(GLenum texunit, GLenum target, GLuint renderbuffer) {if (GLeeInit()) glMultiTexRenderbufferEXT(texunit, target, renderbuffer);}
GLEEPFNGLMULTITEXRENDERBUFFEREXTPROC GLeeFuncPtr_glMultiTexRenderbufferEXT=GLee_Lazy_glMultiTexRenderbufferEXT;
#endif
#endif
/* GL_EXT_vertex_array_bgra */
#ifdef __GLEE_GL_EXT_vertex_array_bgra
#endif
/* GL_EXT_texture_swizzle */
#ifdef __GLEE_GL_EXT_texture_swizzle
#endif
/* GL_NV_explicit_multisample */
#ifdef __GLEE_GL_NV_explicit_multisample
#ifndef GLEE_C_DEFINED_glGetMultisamplefvNV
#define GLEE_C_DEFINED_glGetMultisamplefvNV
void __stdcall GLee_Lazy_glGetMultisamplefvNV(GLenum pname, GLuint index, GLfloat * val) {if (GLeeInit()) glGetMultisamplefvNV(pname, index, val);}
GLEEPFNGLGETMULTISAMPLEFVNVPROC GLeeFuncPtr_glGetMultisamplefvNV=GLee_Lazy_glGetMultisamplefvNV;
#endif
#ifndef GLEE_C_DEFINED_glSampleMaskIndexedNV
#define GLEE_C_DEFINED_glSampleMaskIndexedNV
void __stdcall GLee_Lazy_glSampleMaskIndexedNV(GLuint index, GLbitfield mask) {if (GLeeInit()) glSampleMaskIndexedNV(index, mask);}
GLEEPFNGLSAMPLEMASKINDEXEDNVPROC GLeeFuncPtr_glSampleMaskIndexedNV=GLee_Lazy_glSampleMaskIndexedNV;
#endif
#ifndef GLEE_C_DEFINED_glTexRenderbufferNV
#define GLEE_C_DEFINED_glTexRenderbufferNV
void __stdcall GLee_Lazy_glTexRenderbufferNV(GLenum target, GLuint renderbuffer) {if (GLeeInit()) glTexRenderbufferNV(target, renderbuffer);}
GLEEPFNGLTEXRENDERBUFFERNVPROC GLeeFuncPtr_glTexRenderbufferNV=GLee_Lazy_glTexRenderbufferNV;
#endif
#endif
/* GL_NV_transform_feedback2 */
#ifdef __GLEE_GL_NV_transform_feedback2
#ifndef GLEE_C_DEFINED_glBindTransformFeedbackNV
#define GLEE_C_DEFINED_glBindTransformFeedbackNV
void __stdcall GLee_Lazy_glBindTransformFeedbackNV(GLenum target, GLuint id) {if (GLeeInit()) glBindTransformFeedbackNV(target, id);}
GLEEPFNGLBINDTRANSFORMFEEDBACKNVPROC GLeeFuncPtr_glBindTransformFeedbackNV=GLee_Lazy_glBindTransformFeedbackNV;
#endif
#ifndef GLEE_C_DEFINED_glDeleteTransformFeedbacksNV
#define GLEE_C_DEFINED_glDeleteTransformFeedbacksNV
void __stdcall GLee_Lazy_glDeleteTransformFeedbacksNV(GLsizei n, const GLuint * ids) {if (GLeeInit()) glDeleteTransformFeedbacksNV(n, ids);}
GLEEPFNGLDELETETRANSFORMFEEDBACKSNVPROC GLeeFuncPtr_glDeleteTransformFeedbacksNV=GLee_Lazy_glDeleteTransformFeedbacksNV;
#endif
#ifndef GLEE_C_DEFINED_glGenTransformFeedbacksNV
#define GLEE_C_DEFINED_glGenTransformFeedbacksNV
void __stdcall GLee_Lazy_glGenTransformFeedbacksNV(GLsizei n, GLuint * ids) {if (GLeeInit()) glGenTransformFeedbacksNV(n, ids);}
GLEEPFNGLGENTRANSFORMFEEDBACKSNVPROC GLeeFuncPtr_glGenTransformFeedbacksNV=GLee_Lazy_glGenTransformFeedbacksNV;
#endif
#ifndef GLEE_C_DEFINED_glIsTransformFeedbackNV
#define GLEE_C_DEFINED_glIsTransformFeedbackNV
GLboolean __stdcall GLee_Lazy_glIsTransformFeedbackNV(GLuint id) {if (GLeeInit()) return glIsTransformFeedbackNV(id); return (GLboolean)0;}
GLEEPFNGLISTRANSFORMFEEDBACKNVPROC GLeeFuncPtr_glIsTransformFeedbackNV=GLee_Lazy_glIsTransformFeedbackNV;
#endif
#ifndef GLEE_C_DEFINED_glPauseTransformFeedbackNV
#define GLEE_C_DEFINED_glPauseTransformFeedbackNV
void __stdcall GLee_Lazy_glPauseTransformFeedbackNV(void) {if (GLeeInit()) glPauseTransformFeedbackNV();}
GLEEPFNGLPAUSETRANSFORMFEEDBACKNVPROC GLeeFuncPtr_glPauseTransformFeedbackNV=GLee_Lazy_glPauseTransformFeedbackNV;
#endif
#ifndef GLEE_C_DEFINED_glResumeTransformFeedbackNV
#define GLEE_C_DEFINED_glResumeTransformFeedbackNV
void __stdcall GLee_Lazy_glResumeTransformFeedbackNV(void) {if (GLeeInit()) glResumeTransformFeedbackNV();}
GLEEPFNGLRESUMETRANSFORMFEEDBACKNVPROC GLeeFuncPtr_glResumeTransformFeedbackNV=GLee_Lazy_glResumeTransformFeedbackNV;
#endif
#ifndef GLEE_C_DEFINED_glDrawTransformFeedbackNV
#define GLEE_C_DEFINED_glDrawTransformFeedbackNV
void __stdcall GLee_Lazy_glDrawTransformFeedbackNV(GLenum mode, GLuint id) {if (GLeeInit()) glDrawTransformFeedbackNV(mode, id);}
GLEEPFNGLDRAWTRANSFORMFEEDBACKNVPROC GLeeFuncPtr_glDrawTransformFeedbackNV=GLee_Lazy_glDrawTransformFeedbackNV;
#endif
#endif
/* GL_SGIX_texture_select */
#ifdef __GLEE_GL_SGIX_texture_select
#endif
/* GL_INGR_blend_func_separate */
#ifdef __GLEE_GL_INGR_blend_func_separate
#ifndef GLEE_C_DEFINED_glBlendFuncSeparateINGR
#define GLEE_C_DEFINED_glBlendFuncSeparateINGR
void __stdcall GLee_Lazy_glBlendFuncSeparateINGR(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) {if (GLeeInit()) glBlendFuncSeparateINGR(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);}
GLEEPFNGLBLENDFUNCSEPARATEINGRPROC GLeeFuncPtr_glBlendFuncSeparateINGR=GLee_Lazy_glBlendFuncSeparateINGR;
#endif
#endif
/* GL_SGIX_depth_pass_instrument */
#ifdef __GLEE_GL_SGIX_depth_pass_instrument
#endif
/* GL_SGIX_igloo_interface */
#ifdef __GLEE_GL_SGIX_igloo_interface
#ifndef GLEE_C_DEFINED_glIglooInterfaceSGIX
#define GLEE_C_DEFINED_glIglooInterfaceSGIX
void __stdcall GLee_Lazy_glIglooInterfaceSGIX(GLenum pname, const GLvoid * params) {if (GLeeInit()) glIglooInterfaceSGIX(pname, params);}
GLEEPFNGLIGLOOINTERFACESGIXPROC GLeeFuncPtr_glIglooInterfaceSGIX=GLee_Lazy_glIglooInterfaceSGIX;
#endif
#endif
/* GL_EXT_fragment_lighting */
#ifdef __GLEE_GL_EXT_fragment_lighting
#ifndef GLEE_C_DEFINED_glFragmentLightModeliEXT
#define GLEE_C_DEFINED_glFragmentLightModeliEXT
GLvoid __stdcall GLee_Lazy_glFragmentLightModeliEXT(GLenum pname, GLint param) {if (GLeeInit()) glFragmentLightModeliEXT(pname, param);}
GLEEPFNGLFRAGMENTLIGHTMODELIEXTPROC GLeeFuncPtr_glFragmentLightModeliEXT=GLee_Lazy_glFragmentLightModeliEXT;
#endif
#ifndef GLEE_C_DEFINED_glFragmentLightModelfEXT
#define GLEE_C_DEFINED_glFragmentLightModelfEXT
GLvoid __stdcall GLee_Lazy_glFragmentLightModelfEXT(GLenum pname, GLfloat param) {if (GLeeInit()) glFragmentLightModelfEXT(pname, param);}
GLEEPFNGLFRAGMENTLIGHTMODELFEXTPROC GLeeFuncPtr_glFragmentLightModelfEXT=GLee_Lazy_glFragmentLightModelfEXT;
#endif
#ifndef GLEE_C_DEFINED_glFragmentLightModelivEXT
#define GLEE_C_DEFINED_glFragmentLightModelivEXT
GLvoid __stdcall GLee_Lazy_glFragmentLightModelivEXT(GLenum pname, GLint * params) {if (GLeeInit()) glFragmentLightModelivEXT(pname, params);}
GLEEPFNGLFRAGMENTLIGHTMODELIVEXTPROC GLeeFuncPtr_glFragmentLightModelivEXT=GLee_Lazy_glFragmentLightModelivEXT;
#endif
#ifndef GLEE_C_DEFINED_glFragmentLightModelfvEXT
#define GLEE_C_DEFINED_glFragmentLightModelfvEXT
GLvoid __stdcall GLee_Lazy_glFragmentLightModelfvEXT(GLenum pname, GLfloat * params) {if (GLeeInit()) glFragmentLightModelfvEXT(pname, params);}
GLEEPFNGLFRAGMENTLIGHTMODELFVEXTPROC GLeeFuncPtr_glFragmentLightModelfvEXT=GLee_Lazy_glFragmentLightModelfvEXT;
#endif
#ifndef GLEE_C_DEFINED_glFragmentLightiEXT
#define GLEE_C_DEFINED_glFragmentLightiEXT
GLvoid __stdcall GLee_Lazy_glFragmentLightiEXT(GLenum light, GLenum pname, GLint param) {if (GLeeInit()) glFragmentLightiEXT(light, pname, param);}
GLEEPFNGLFRAGMENTLIGHTIEXTPROC GLeeFuncPtr_glFragmentLightiEXT=GLee_Lazy_glFragmentLightiEXT;
#endif
#ifndef GLEE_C_DEFINED_glFragmentLightfEXT
#define GLEE_C_DEFINED_glFragmentLightfEXT
GLvoid __stdcall GLee_Lazy_glFragmentLightfEXT(GLenum light, GLenum pname, GLfloat param) {if (GLeeInit()) glFragmentLightfEXT(light, pname, param);}
GLEEPFNGLFRAGMENTLIGHTFEXTPROC GLeeFuncPtr_glFragmentLightfEXT=GLee_Lazy_glFragmentLightfEXT;
#endif
#ifndef GLEE_C_DEFINED_glFragmentLightivEXT
#define GLEE_C_DEFINED_glFragmentLightivEXT
GLvoid __stdcall GLee_Lazy_glFragmentLightivEXT(GLenum light, GLenum pname, GLint * params) {if (GLeeInit()) glFragmentLightivEXT(light, pname, params);}
GLEEPFNGLFRAGMENTLIGHTIVEXTPROC GLeeFuncPtr_glFragmentLightivEXT=GLee_Lazy_glFragmentLightivEXT;
#endif
#ifndef GLEE_C_DEFINED_glFragmentLightfvEXT
#define GLEE_C_DEFINED_glFragmentLightfvEXT
GLvoid __stdcall GLee_Lazy_glFragmentLightfvEXT(GLenum light, GLenum pname, GLfloat * params) {if (GLeeInit()) glFragmentLightfvEXT(light, pname, params);}
GLEEPFNGLFRAGMENTLIGHTFVEXTPROC GLeeFuncPtr_glFragmentLightfvEXT=GLee_Lazy_glFragmentLightfvEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetFragmentLightivEXT
#define GLEE_C_DEFINED_glGetFragmentLightivEXT
GLvoid __stdcall GLee_Lazy_glGetFragmentLightivEXT(GLenum light, GLenum pname, GLint * params) {if (GLeeInit()) glGetFragmentLightivEXT(light, pname, params);}
GLEEPFNGLGETFRAGMENTLIGHTIVEXTPROC GLeeFuncPtr_glGetFragmentLightivEXT=GLee_Lazy_glGetFragmentLightivEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetFragmentLightfvEXT
#define GLEE_C_DEFINED_glGetFragmentLightfvEXT
GLvoid __stdcall GLee_Lazy_glGetFragmentLightfvEXT(GLenum light, GLenum pname, GLfloat * params) {if (GLeeInit()) glGetFragmentLightfvEXT(light, pname, params);}
GLEEPFNGLGETFRAGMENTLIGHTFVEXTPROC GLeeFuncPtr_glGetFragmentLightfvEXT=GLee_Lazy_glGetFragmentLightfvEXT;
#endif
#ifndef GLEE_C_DEFINED_glFragmentMaterialfEXT
#define GLEE_C_DEFINED_glFragmentMaterialfEXT
GLvoid __stdcall GLee_Lazy_glFragmentMaterialfEXT(GLenum face, GLenum pname, const GLfloat param) {if (GLeeInit()) glFragmentMaterialfEXT(face, pname, param);}
GLEEPFNGLFRAGMENTMATERIALFEXTPROC GLeeFuncPtr_glFragmentMaterialfEXT=GLee_Lazy_glFragmentMaterialfEXT;
#endif
#ifndef GLEE_C_DEFINED_glFragmentMaterialiEXT
#define GLEE_C_DEFINED_glFragmentMaterialiEXT
GLvoid __stdcall GLee_Lazy_glFragmentMaterialiEXT(GLenum face, GLenum pname, const GLint param) {if (GLeeInit()) glFragmentMaterialiEXT(face, pname, param);}
GLEEPFNGLFRAGMENTMATERIALIEXTPROC GLeeFuncPtr_glFragmentMaterialiEXT=GLee_Lazy_glFragmentMaterialiEXT;
#endif
#ifndef GLEE_C_DEFINED_glFragmentMaterialfvEXT
#define GLEE_C_DEFINED_glFragmentMaterialfvEXT
GLvoid __stdcall GLee_Lazy_glFragmentMaterialfvEXT(GLenum face, GLenum pname, const GLfloat * params) {if (GLeeInit()) glFragmentMaterialfvEXT(face, pname, params);}
GLEEPFNGLFRAGMENTMATERIALFVEXTPROC GLeeFuncPtr_glFragmentMaterialfvEXT=GLee_Lazy_glFragmentMaterialfvEXT;
#endif
#ifndef GLEE_C_DEFINED_glFragmentMaterialivEXT
#define GLEE_C_DEFINED_glFragmentMaterialivEXT
GLvoid __stdcall GLee_Lazy_glFragmentMaterialivEXT(GLenum face, GLenum pname, const GLint * params) {if (GLeeInit()) glFragmentMaterialivEXT(face, pname, params);}
GLEEPFNGLFRAGMENTMATERIALIVEXTPROC GLeeFuncPtr_glFragmentMaterialivEXT=GLee_Lazy_glFragmentMaterialivEXT;
#endif
#ifndef GLEE_C_DEFINED_glFragmentColorMaterialEXT
#define GLEE_C_DEFINED_glFragmentColorMaterialEXT
GLvoid __stdcall GLee_Lazy_glFragmentColorMaterialEXT(GLenum face, GLenum mode) {if (GLeeInit()) glFragmentColorMaterialEXT(face, mode);}
GLEEPFNGLFRAGMENTCOLORMATERIALEXTPROC GLeeFuncPtr_glFragmentColorMaterialEXT=GLee_Lazy_glFragmentColorMaterialEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetFragmentMaterialfvEXT
#define GLEE_C_DEFINED_glGetFragmentMaterialfvEXT
GLvoid __stdcall GLee_Lazy_glGetFragmentMaterialfvEXT(GLenum face, GLenum pname, const GLfloat * params) {if (GLeeInit()) glGetFragmentMaterialfvEXT(face, pname, params);}
GLEEPFNGLGETFRAGMENTMATERIALFVEXTPROC GLeeFuncPtr_glGetFragmentMaterialfvEXT=GLee_Lazy_glGetFragmentMaterialfvEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetFragmentMaterialivEXT
#define GLEE_C_DEFINED_glGetFragmentMaterialivEXT
GLvoid __stdcall GLee_Lazy_glGetFragmentMaterialivEXT(GLenum face, GLenum pname, const GLint * params) {if (GLeeInit()) glGetFragmentMaterialivEXT(face, pname, params);}
GLEEPFNGLGETFRAGMENTMATERIALIVEXTPROC GLeeFuncPtr_glGetFragmentMaterialivEXT=GLee_Lazy_glGetFragmentMaterialivEXT;
#endif
#ifndef GLEE_C_DEFINED_glLightEnviEXT
#define GLEE_C_DEFINED_glLightEnviEXT
GLvoid __stdcall GLee_Lazy_glLightEnviEXT(GLenum pname, GLint param) {if (GLeeInit()) glLightEnviEXT(pname, param);}
GLEEPFNGLLIGHTENVIEXTPROC GLeeFuncPtr_glLightEnviEXT=GLee_Lazy_glLightEnviEXT;
#endif
#endif
/* GL_EXT_geometry_shader4 */
#ifdef __GLEE_GL_EXT_geometry_shader4
#ifndef GLEE_C_DEFINED_glProgramParameteriEXT
#define GLEE_C_DEFINED_glProgramParameteriEXT
GLvoid __stdcall GLee_Lazy_glProgramParameteriEXT(GLuint program, GLenum pname, GLint value) {if (GLeeInit()) glProgramParameteriEXT(program, pname, value);}
GLEEPFNGLPROGRAMPARAMETERIEXTPROC GLeeFuncPtr_glProgramParameteriEXT=GLee_Lazy_glProgramParameteriEXT;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferTextureEXT
#define GLEE_C_DEFINED_glFramebufferTextureEXT
GLvoid __stdcall GLee_Lazy_glFramebufferTextureEXT(GLenum target, GLenum attachment, GLuint texture, GLint level) {if (GLeeInit()) glFramebufferTextureEXT(target, attachment, texture, level);}
GLEEPFNGLFRAMEBUFFERTEXTUREEXTPROC GLeeFuncPtr_glFramebufferTextureEXT=GLee_Lazy_glFramebufferTextureEXT;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferTextureLayerEXT
#define GLEE_C_DEFINED_glFramebufferTextureLayerEXT
GLvoid __stdcall GLee_Lazy_glFramebufferTextureLayerEXT(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) {if (GLeeInit()) glFramebufferTextureLayerEXT(target, attachment, texture, level, layer);}
GLEEPFNGLFRAMEBUFFERTEXTURELAYEREXTPROC GLeeFuncPtr_glFramebufferTextureLayerEXT=GLee_Lazy_glFramebufferTextureLayerEXT;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferTextureFaceEXT
#define GLEE_C_DEFINED_glFramebufferTextureFaceEXT
GLvoid __stdcall GLee_Lazy_glFramebufferTextureFaceEXT(GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face) {if (GLeeInit()) glFramebufferTextureFaceEXT(target, attachment, texture, level, face);}
GLEEPFNGLFRAMEBUFFERTEXTUREFACEEXTPROC GLeeFuncPtr_glFramebufferTextureFaceEXT=GLee_Lazy_glFramebufferTextureFaceEXT;
#endif
#endif
/* GL_EXT_scene_marker */
#ifdef __GLEE_GL_EXT_scene_marker
#ifndef GLEE_C_DEFINED_glBeginSceneEXT
#define GLEE_C_DEFINED_glBeginSceneEXT
GLvoid __stdcall GLee_Lazy_glBeginSceneEXT(void) {if (GLeeInit()) glBeginSceneEXT();}
GLEEPFNGLBEGINSCENEEXTPROC GLeeFuncPtr_glBeginSceneEXT=GLee_Lazy_glBeginSceneEXT;
#endif
#ifndef GLEE_C_DEFINED_glEndSceneEXT
#define GLEE_C_DEFINED_glEndSceneEXT
GLvoid __stdcall GLee_Lazy_glEndSceneEXT(void) {if (GLeeInit()) glEndSceneEXT();}
GLEEPFNGLENDSCENEEXTPROC GLeeFuncPtr_glEndSceneEXT=GLee_Lazy_glEndSceneEXT;
#endif
#endif
/* GL_EXT_texture_compression_dxt1 */
#ifdef __GLEE_GL_EXT_texture_compression_dxt1
#endif
/* GL_EXT_texture_env */
#ifdef __GLEE_GL_EXT_texture_env
#endif
/* GL_IBM_static_data */
#ifdef __GLEE_GL_IBM_static_data
#endif
/* GL_NV_gpu_program4 */
#ifdef __GLEE_GL_NV_gpu_program4
#ifndef GLEE_C_DEFINED_glProgramLocalParameterI4iNV
#define GLEE_C_DEFINED_glProgramLocalParameterI4iNV
GLvoid __stdcall GLee_Lazy_glProgramLocalParameterI4iNV(GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w) {if (GLeeInit()) glProgramLocalParameterI4iNV(target, index, x, y, z, w);}
GLEEPFNGLPROGRAMLOCALPARAMETERI4INVPROC GLeeFuncPtr_glProgramLocalParameterI4iNV=GLee_Lazy_glProgramLocalParameterI4iNV;
#endif
#ifndef GLEE_C_DEFINED_glProgramLocalParameterI4ivNV
#define GLEE_C_DEFINED_glProgramLocalParameterI4ivNV
GLvoid __stdcall GLee_Lazy_glProgramLocalParameterI4ivNV(GLenum target, GLuint index, const GLint * params) {if (GLeeInit()) glProgramLocalParameterI4ivNV(target, index, params);}
GLEEPFNGLPROGRAMLOCALPARAMETERI4IVNVPROC GLeeFuncPtr_glProgramLocalParameterI4ivNV=GLee_Lazy_glProgramLocalParameterI4ivNV;
#endif
#ifndef GLEE_C_DEFINED_glProgramLocalParametersI4ivNV
#define GLEE_C_DEFINED_glProgramLocalParametersI4ivNV
GLvoid __stdcall GLee_Lazy_glProgramLocalParametersI4ivNV(GLenum target, GLuint index, GLsizei count, const GLint * params) {if (GLeeInit()) glProgramLocalParametersI4ivNV(target, index, count, params);}
GLEEPFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC GLeeFuncPtr_glProgramLocalParametersI4ivNV=GLee_Lazy_glProgramLocalParametersI4ivNV;
#endif
#ifndef GLEE_C_DEFINED_glProgramLocalParameterI4uiNV
#define GLEE_C_DEFINED_glProgramLocalParameterI4uiNV
GLvoid __stdcall GLee_Lazy_glProgramLocalParameterI4uiNV(GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) {if (GLeeInit()) glProgramLocalParameterI4uiNV(target, index, x, y, z, w);}
GLEEPFNGLPROGRAMLOCALPARAMETERI4UINVPROC GLeeFuncPtr_glProgramLocalParameterI4uiNV=GLee_Lazy_glProgramLocalParameterI4uiNV;
#endif
#ifndef GLEE_C_DEFINED_glProgramLocalParameterI4uivNV
#define GLEE_C_DEFINED_glProgramLocalParameterI4uivNV
GLvoid __stdcall GLee_Lazy_glProgramLocalParameterI4uivNV(GLenum target, GLuint index, const GLuint * params) {if (GLeeInit()) glProgramLocalParameterI4uivNV(target, index, params);}
GLEEPFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC GLeeFuncPtr_glProgramLocalParameterI4uivNV=GLee_Lazy_glProgramLocalParameterI4uivNV;
#endif
#ifndef GLEE_C_DEFINED_glProgramLocalParametersI4uivNV
#define GLEE_C_DEFINED_glProgramLocalParametersI4uivNV
GLvoid __stdcall GLee_Lazy_glProgramLocalParametersI4uivNV(GLenum target, GLuint index, GLsizei count, const GLuint * params) {if (GLeeInit()) glProgramLocalParametersI4uivNV(target, index, count, params);}
GLEEPFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC GLeeFuncPtr_glProgramLocalParametersI4uivNV=GLee_Lazy_glProgramLocalParametersI4uivNV;
#endif
#ifndef GLEE_C_DEFINED_glProgramEnvParameterI4iNV
#define GLEE_C_DEFINED_glProgramEnvParameterI4iNV
GLvoid __stdcall GLee_Lazy_glProgramEnvParameterI4iNV(GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w) {if (GLeeInit()) glProgramEnvParameterI4iNV(target, index, x, y, z, w);}
GLEEPFNGLPROGRAMENVPARAMETERI4INVPROC GLeeFuncPtr_glProgramEnvParameterI4iNV=GLee_Lazy_glProgramEnvParameterI4iNV;
#endif
#ifndef GLEE_C_DEFINED_glProgramEnvParameterI4ivNV
#define GLEE_C_DEFINED_glProgramEnvParameterI4ivNV
GLvoid __stdcall GLee_Lazy_glProgramEnvParameterI4ivNV(GLenum target, GLuint index, const GLint * params) {if (GLeeInit()) glProgramEnvParameterI4ivNV(target, index, params);}
GLEEPFNGLPROGRAMENVPARAMETERI4IVNVPROC GLeeFuncPtr_glProgramEnvParameterI4ivNV=GLee_Lazy_glProgramEnvParameterI4ivNV;
#endif
#ifndef GLEE_C_DEFINED_glProgramEnvParametersI4ivNV
#define GLEE_C_DEFINED_glProgramEnvParametersI4ivNV
GLvoid __stdcall GLee_Lazy_glProgramEnvParametersI4ivNV(GLenum target, GLuint index, GLsizei count, const GLint * params) {if (GLeeInit()) glProgramEnvParametersI4ivNV(target, index, count, params);}
GLEEPFNGLPROGRAMENVPARAMETERSI4IVNVPROC GLeeFuncPtr_glProgramEnvParametersI4ivNV=GLee_Lazy_glProgramEnvParametersI4ivNV;
#endif
#ifndef GLEE_C_DEFINED_glProgramEnvParameterI4uiNV
#define GLEE_C_DEFINED_glProgramEnvParameterI4uiNV
GLvoid __stdcall GLee_Lazy_glProgramEnvParameterI4uiNV(GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) {if (GLeeInit()) glProgramEnvParameterI4uiNV(target, index, x, y, z, w);}
GLEEPFNGLPROGRAMENVPARAMETERI4UINVPROC GLeeFuncPtr_glProgramEnvParameterI4uiNV=GLee_Lazy_glProgramEnvParameterI4uiNV;
#endif
#ifndef GLEE_C_DEFINED_glProgramEnvParameterI4uivNV
#define GLEE_C_DEFINED_glProgramEnvParameterI4uivNV
GLvoid __stdcall GLee_Lazy_glProgramEnvParameterI4uivNV(GLenum target, GLuint index, const GLuint * params) {if (GLeeInit()) glProgramEnvParameterI4uivNV(target, index, params);}
GLEEPFNGLPROGRAMENVPARAMETERI4UIVNVPROC GLeeFuncPtr_glProgramEnvParameterI4uivNV=GLee_Lazy_glProgramEnvParameterI4uivNV;
#endif
#ifndef GLEE_C_DEFINED_glProgramEnvParametersI4uivNV
#define GLEE_C_DEFINED_glProgramEnvParametersI4uivNV
GLvoid __stdcall GLee_Lazy_glProgramEnvParametersI4uivNV(GLenum target, GLuint index, GLsizei count, const GLuint * params) {if (GLeeInit()) glProgramEnvParametersI4uivNV(target, index, count, params);}
GLEEPFNGLPROGRAMENVPARAMETERSI4UIVNVPROC GLeeFuncPtr_glProgramEnvParametersI4uivNV=GLee_Lazy_glProgramEnvParametersI4uivNV;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramLocalParameterIivNV
#define GLEE_C_DEFINED_glGetProgramLocalParameterIivNV
GLvoid __stdcall GLee_Lazy_glGetProgramLocalParameterIivNV(GLenum target, GLuint index, GLint * params) {if (GLeeInit()) glGetProgramLocalParameterIivNV(target, index, params);}
GLEEPFNGLGETPROGRAMLOCALPARAMETERIIVNVPROC GLeeFuncPtr_glGetProgramLocalParameterIivNV=GLee_Lazy_glGetProgramLocalParameterIivNV;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramLocalParameterIuivNV
#define GLEE_C_DEFINED_glGetProgramLocalParameterIuivNV
GLvoid __stdcall GLee_Lazy_glGetProgramLocalParameterIuivNV(GLenum target, GLuint index, GLuint * params) {if (GLeeInit()) glGetProgramLocalParameterIuivNV(target, index, params);}
GLEEPFNGLGETPROGRAMLOCALPARAMETERIUIVNVPROC GLeeFuncPtr_glGetProgramLocalParameterIuivNV=GLee_Lazy_glGetProgramLocalParameterIuivNV;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramEnvParameterIivNV
#define GLEE_C_DEFINED_glGetProgramEnvParameterIivNV
GLvoid __stdcall GLee_Lazy_glGetProgramEnvParameterIivNV(GLenum target, GLuint index, GLint * params) {if (GLeeInit()) glGetProgramEnvParameterIivNV(target, index, params);}
GLEEPFNGLGETPROGRAMENVPARAMETERIIVNVPROC GLeeFuncPtr_glGetProgramEnvParameterIivNV=GLee_Lazy_glGetProgramEnvParameterIivNV;
#endif
#ifndef GLEE_C_DEFINED_glGetProgramEnvParameterIuivNV
#define GLEE_C_DEFINED_glGetProgramEnvParameterIuivNV
GLvoid __stdcall GLee_Lazy_glGetProgramEnvParameterIuivNV(GLenum target, GLuint index, GLuint * params) {if (GLeeInit()) glGetProgramEnvParameterIuivNV(target, index, params);}
GLEEPFNGLGETPROGRAMENVPARAMETERIUIVNVPROC GLeeFuncPtr_glGetProgramEnvParameterIuivNV=GLee_Lazy_glGetProgramEnvParameterIuivNV;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferTextureEXT
#define GLEE_C_DEFINED_glFramebufferTextureEXT
GLvoid __stdcall GLee_Lazy_glFramebufferTextureEXT(GLenum target, GLenum attachment, GLuint texture, GLint level) {if (GLeeInit()) glFramebufferTextureEXT(target, attachment, texture, level);}
GLEEPFNGLFRAMEBUFFERTEXTUREEXTPROC GLeeFuncPtr_glFramebufferTextureEXT=GLee_Lazy_glFramebufferTextureEXT;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferTextureLayerEXT
#define GLEE_C_DEFINED_glFramebufferTextureLayerEXT
GLvoid __stdcall GLee_Lazy_glFramebufferTextureLayerEXT(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) {if (GLeeInit()) glFramebufferTextureLayerEXT(target, attachment, texture, level, layer);}
GLEEPFNGLFRAMEBUFFERTEXTURELAYEREXTPROC GLeeFuncPtr_glFramebufferTextureLayerEXT=GLee_Lazy_glFramebufferTextureLayerEXT;
#endif
#ifndef GLEE_C_DEFINED_glFramebufferTextureFaceEXT
#define GLEE_C_DEFINED_glFramebufferTextureFaceEXT
GLvoid __stdcall GLee_Lazy_glFramebufferTextureFaceEXT(GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face) {if (GLeeInit()) glFramebufferTextureFaceEXT(target, attachment, texture, level, face);}
GLEEPFNGLFRAMEBUFFERTEXTUREFACEEXTPROC GLeeFuncPtr_glFramebufferTextureFaceEXT=GLee_Lazy_glFramebufferTextureFaceEXT;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI2iEXT
#define GLEE_C_DEFINED_glVertexAttribI2iEXT
GLvoid __stdcall GLee_Lazy_glVertexAttribI2iEXT(GLuint index, GLint x, GLint y) {if (GLeeInit()) glVertexAttribI2iEXT(index, x, y);}
GLEEPFNGLVERTEXATTRIBI2IEXTPROC GLeeFuncPtr_glVertexAttribI2iEXT=GLee_Lazy_glVertexAttribI2iEXT;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI3iEXT
#define GLEE_C_DEFINED_glVertexAttribI3iEXT
GLvoid __stdcall GLee_Lazy_glVertexAttribI3iEXT(GLuint index, GLint x, GLint y, GLint z) {if (GLeeInit()) glVertexAttribI3iEXT(index, x, y, z);}
GLEEPFNGLVERTEXATTRIBI3IEXTPROC GLeeFuncPtr_glVertexAttribI3iEXT=GLee_Lazy_glVertexAttribI3iEXT;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4iEXT
#define GLEE_C_DEFINED_glVertexAttribI4iEXT
GLvoid __stdcall GLee_Lazy_glVertexAttribI4iEXT(GLuint index, GLint x, GLint y, GLint z, GLint w) {if (GLeeInit()) glVertexAttribI4iEXT(index, x, y, z, w);}
GLEEPFNGLVERTEXATTRIBI4IEXTPROC GLeeFuncPtr_glVertexAttribI4iEXT=GLee_Lazy_glVertexAttribI4iEXT;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI1uiEXT
#define GLEE_C_DEFINED_glVertexAttribI1uiEXT
GLvoid __stdcall GLee_Lazy_glVertexAttribI1uiEXT(GLuint index, GLuint x) {if (GLeeInit()) glVertexAttribI1uiEXT(index, x);}
GLEEPFNGLVERTEXATTRIBI1UIEXTPROC GLeeFuncPtr_glVertexAttribI1uiEXT=GLee_Lazy_glVertexAttribI1uiEXT;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI2uiEXT
#define GLEE_C_DEFINED_glVertexAttribI2uiEXT
GLvoid __stdcall GLee_Lazy_glVertexAttribI2uiEXT(GLuint index, GLuint x, GLuint y) {if (GLeeInit()) glVertexAttribI2uiEXT(index, x, y);}
GLEEPFNGLVERTEXATTRIBI2UIEXTPROC GLeeFuncPtr_glVertexAttribI2uiEXT=GLee_Lazy_glVertexAttribI2uiEXT;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI3uiEXT
#define GLEE_C_DEFINED_glVertexAttribI3uiEXT
GLvoid __stdcall GLee_Lazy_glVertexAttribI3uiEXT(GLuint index, GLuint x, GLuint y, GLuint z) {if (GLeeInit()) glVertexAttribI3uiEXT(index, x, y, z);}
GLEEPFNGLVERTEXATTRIBI3UIEXTPROC GLeeFuncPtr_glVertexAttribI3uiEXT=GLee_Lazy_glVertexAttribI3uiEXT;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4uiEXT
#define GLEE_C_DEFINED_glVertexAttribI4uiEXT
GLvoid __stdcall GLee_Lazy_glVertexAttribI4uiEXT(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) {if (GLeeInit()) glVertexAttribI4uiEXT(index, x, y, z, w);}
GLEEPFNGLVERTEXATTRIBI4UIEXTPROC GLeeFuncPtr_glVertexAttribI4uiEXT=GLee_Lazy_glVertexAttribI4uiEXT;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI1ivEXT
#define GLEE_C_DEFINED_glVertexAttribI1ivEXT
GLvoid __stdcall GLee_Lazy_glVertexAttribI1ivEXT(GLuint index, const GLint * v) {if (GLeeInit()) glVertexAttribI1ivEXT(index, v);}
GLEEPFNGLVERTEXATTRIBI1IVEXTPROC GLeeFuncPtr_glVertexAttribI1ivEXT=GLee_Lazy_glVertexAttribI1ivEXT;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI2ivEXT
#define GLEE_C_DEFINED_glVertexAttribI2ivEXT
GLvoid __stdcall GLee_Lazy_glVertexAttribI2ivEXT(GLuint index, const GLint * v) {if (GLeeInit()) glVertexAttribI2ivEXT(index, v);}
GLEEPFNGLVERTEXATTRIBI2IVEXTPROC GLeeFuncPtr_glVertexAttribI2ivEXT=GLee_Lazy_glVertexAttribI2ivEXT;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI3ivEXT
#define GLEE_C_DEFINED_glVertexAttribI3ivEXT
GLvoid __stdcall GLee_Lazy_glVertexAttribI3ivEXT(GLuint index, const GLint * v) {if (GLeeInit()) glVertexAttribI3ivEXT(index, v);}
GLEEPFNGLVERTEXATTRIBI3IVEXTPROC GLeeFuncPtr_glVertexAttribI3ivEXT=GLee_Lazy_glVertexAttribI3ivEXT;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4ivEXT
#define GLEE_C_DEFINED_glVertexAttribI4ivEXT
GLvoid __stdcall GLee_Lazy_glVertexAttribI4ivEXT(GLuint index, const GLint * v) {if (GLeeInit()) glVertexAttribI4ivEXT(index, v);}
GLEEPFNGLVERTEXATTRIBI4IVEXTPROC GLeeFuncPtr_glVertexAttribI4ivEXT=GLee_Lazy_glVertexAttribI4ivEXT;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI1uivEXT
#define GLEE_C_DEFINED_glVertexAttribI1uivEXT
GLvoid __stdcall GLee_Lazy_glVertexAttribI1uivEXT(GLuint index, const GLuint * v) {if (GLeeInit()) glVertexAttribI1uivEXT(index, v);}
GLEEPFNGLVERTEXATTRIBI1UIVEXTPROC GLeeFuncPtr_glVertexAttribI1uivEXT=GLee_Lazy_glVertexAttribI1uivEXT;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI2uivEXT
#define GLEE_C_DEFINED_glVertexAttribI2uivEXT
GLvoid __stdcall GLee_Lazy_glVertexAttribI2uivEXT(GLuint index, const GLuint * v) {if (GLeeInit()) glVertexAttribI2uivEXT(index, v);}
GLEEPFNGLVERTEXATTRIBI2UIVEXTPROC GLeeFuncPtr_glVertexAttribI2uivEXT=GLee_Lazy_glVertexAttribI2uivEXT;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI3uivEXT
#define GLEE_C_DEFINED_glVertexAttribI3uivEXT
GLvoid __stdcall GLee_Lazy_glVertexAttribI3uivEXT(GLuint index, const GLuint * v) {if (GLeeInit()) glVertexAttribI3uivEXT(index, v);}
GLEEPFNGLVERTEXATTRIBI3UIVEXTPROC GLeeFuncPtr_glVertexAttribI3uivEXT=GLee_Lazy_glVertexAttribI3uivEXT;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4uivEXT
#define GLEE_C_DEFINED_glVertexAttribI4uivEXT
GLvoid __stdcall GLee_Lazy_glVertexAttribI4uivEXT(GLuint index, const GLuint * v) {if (GLeeInit()) glVertexAttribI4uivEXT(index, v);}
GLEEPFNGLVERTEXATTRIBI4UIVEXTPROC GLeeFuncPtr_glVertexAttribI4uivEXT=GLee_Lazy_glVertexAttribI4uivEXT;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4bvEXT
#define GLEE_C_DEFINED_glVertexAttribI4bvEXT
GLvoid __stdcall GLee_Lazy_glVertexAttribI4bvEXT(GLuint index, const GLbyte * v) {if (GLeeInit()) glVertexAttribI4bvEXT(index, v);}
GLEEPFNGLVERTEXATTRIBI4BVEXTPROC GLeeFuncPtr_glVertexAttribI4bvEXT=GLee_Lazy_glVertexAttribI4bvEXT;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4svEXT
#define GLEE_C_DEFINED_glVertexAttribI4svEXT
GLvoid __stdcall GLee_Lazy_glVertexAttribI4svEXT(GLuint index, const GLshort * v) {if (GLeeInit()) glVertexAttribI4svEXT(index, v);}
GLEEPFNGLVERTEXATTRIBI4SVEXTPROC GLeeFuncPtr_glVertexAttribI4svEXT=GLee_Lazy_glVertexAttribI4svEXT;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4ubvEXT
#define GLEE_C_DEFINED_glVertexAttribI4ubvEXT
GLvoid __stdcall GLee_Lazy_glVertexAttribI4ubvEXT(GLuint index, const GLubyte * v) {if (GLeeInit()) glVertexAttribI4ubvEXT(index, v);}
GLEEPFNGLVERTEXATTRIBI4UBVEXTPROC GLeeFuncPtr_glVertexAttribI4ubvEXT=GLee_Lazy_glVertexAttribI4ubvEXT;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribI4usvEXT
#define GLEE_C_DEFINED_glVertexAttribI4usvEXT
GLvoid __stdcall GLee_Lazy_glVertexAttribI4usvEXT(GLuint index, const GLushort * v) {if (GLeeInit()) glVertexAttribI4usvEXT(index, v);}
GLEEPFNGLVERTEXATTRIBI4USVEXTPROC GLeeFuncPtr_glVertexAttribI4usvEXT=GLee_Lazy_glVertexAttribI4usvEXT;
#endif
#ifndef GLEE_C_DEFINED_glVertexAttribIPointerEXT
#define GLEE_C_DEFINED_glVertexAttribIPointerEXT
GLvoid __stdcall GLee_Lazy_glVertexAttribIPointerEXT(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer) {if (GLeeInit()) glVertexAttribIPointerEXT(index, size, type, stride, pointer);}
GLEEPFNGLVERTEXATTRIBIPOINTEREXTPROC GLeeFuncPtr_glVertexAttribIPointerEXT=GLee_Lazy_glVertexAttribIPointerEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribIivEXT
#define GLEE_C_DEFINED_glGetVertexAttribIivEXT
GLvoid __stdcall GLee_Lazy_glGetVertexAttribIivEXT(GLuint index, GLenum pname, GLint * params) {if (GLeeInit()) glGetVertexAttribIivEXT(index, pname, params);}
GLEEPFNGLGETVERTEXATTRIBIIVEXTPROC GLeeFuncPtr_glGetVertexAttribIivEXT=GLee_Lazy_glGetVertexAttribIivEXT;
#endif
#ifndef GLEE_C_DEFINED_glGetVertexAttribIuivEXT
#define GLEE_C_DEFINED_glGetVertexAttribIuivEXT
GLvoid __stdcall GLee_Lazy_glGetVertexAttribIuivEXT(GLuint index, GLenum pname, GLuint * params) {if (GLeeInit()) glGetVertexAttribIuivEXT(index, pname, params);}
GLEEPFNGLGETVERTEXATTRIBIUIVEXTPROC GLeeFuncPtr_glGetVertexAttribIuivEXT=GLee_Lazy_glGetVertexAttribIuivEXT;
#endif
#endif
/* GL_OES_byte_coordinates */
#ifdef __GLEE_GL_OES_byte_coordinates
#endif
/* GL_OES_compressed_paletted_texture */
#ifdef __GLEE_GL_OES_compressed_paletted_texture
#endif
/* GL_OES_single_precision */
#ifdef __GLEE_GL_OES_single_precision
#ifndef GLEE_C_DEFINED_glDepthRangefOES
#define GLEE_C_DEFINED_glDepthRangefOES
GLvoid __stdcall GLee_Lazy_glDepthRangefOES(GLclampf n, GLclampf f) {if (GLeeInit()) glDepthRangefOES(n, f);}
GLEEPFNGLDEPTHRANGEFOESPROC GLeeFuncPtr_glDepthRangefOES=GLee_Lazy_glDepthRangefOES;
#endif
#ifndef GLEE_C_DEFINED_glFrustumfOES
#define GLEE_C_DEFINED_glFrustumfOES
GLvoid __stdcall GLee_Lazy_glFrustumfOES(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f) {if (GLeeInit()) glFrustumfOES(l, r, b, t, n, f);}
GLEEPFNGLFRUSTUMFOESPROC GLeeFuncPtr_glFrustumfOES=GLee_Lazy_glFrustumfOES;
#endif
#ifndef GLEE_C_DEFINED_glOrthofOES
#define GLEE_C_DEFINED_glOrthofOES
GLvoid __stdcall GLee_Lazy_glOrthofOES(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f) {if (GLeeInit()) glOrthofOES(l, r, b, t, n, f);}
GLEEPFNGLORTHOFOESPROC GLeeFuncPtr_glOrthofOES=GLee_Lazy_glOrthofOES;
#endif
#ifndef GLEE_C_DEFINED_glClipPlanefOES
#define GLEE_C_DEFINED_glClipPlanefOES
GLvoid __stdcall GLee_Lazy_glClipPlanefOES(GLenum plane, const GLfloat* equation) {if (GLeeInit()) glClipPlanefOES(plane, equation);}
GLEEPFNGLCLIPPLANEFOESPROC GLeeFuncPtr_glClipPlanefOES=GLee_Lazy_glClipPlanefOES;
#endif
#ifndef GLEE_C_DEFINED_glGetClipPlanefOES
#define GLEE_C_DEFINED_glGetClipPlanefOES
GLvoid __stdcall GLee_Lazy_glGetClipPlanefOES(GLenum plane, GLfloat* equation) {if (GLeeInit()) glGetClipPlanefOES(plane, equation);}
GLEEPFNGLGETCLIPPLANEFOESPROC GLeeFuncPtr_glGetClipPlanefOES=GLee_Lazy_glGetClipPlanefOES;
#endif
#ifndef GLEE_C_DEFINED_glClearDepthfOES
#define GLEE_C_DEFINED_glClearDepthfOES
GLvoid __stdcall GLee_Lazy_glClearDepthfOES(GLclampd depth) {if (GLeeInit()) glClearDepthfOES(depth);}
GLEEPFNGLCLEARDEPTHFOESPROC GLeeFuncPtr_glClearDepthfOES=GLee_Lazy_glClearDepthfOES;
#endif
#endif
/* GL_SGIX_pixel_texture_bits */
#ifdef __GLEE_GL_SGIX_pixel_texture_bits
#endif
/* GL_SGIX_texture_range */
#ifdef __GLEE_GL_SGIX_texture_range
#endif
/* WGL */
#ifdef WIN32
/* Extension querying variables */
GLboolean _GLEE_WGL_ARB_buffer_region = GL_FALSE;
GLboolean _GLEE_WGL_ARB_multisample = GL_FALSE;
GLboolean _GLEE_WGL_ARB_extensions_string = GL_FALSE;
GLboolean _GLEE_WGL_ARB_pixel_format = GL_FALSE;
GLboolean _GLEE_WGL_ARB_make_current_read = GL_FALSE;
GLboolean _GLEE_WGL_ARB_pbuffer = GL_FALSE;
GLboolean _GLEE_WGL_ARB_render_texture = GL_FALSE;
GLboolean _GLEE_WGL_ARB_pixel_format_float = GL_FALSE;
GLboolean _GLEE_WGL_ARB_create_context = GL_FALSE;
GLboolean _GLEE_WGL_EXT_make_current_read = GL_FALSE;
GLboolean _GLEE_WGL_EXT_pixel_format = GL_FALSE;
GLboolean _GLEE_WGL_EXT_pbuffer = GL_FALSE;
GLboolean _GLEE_WGL_EXT_depth_float = GL_FALSE;
GLboolean _GLEE_WGL_3DFX_multisample = GL_FALSE;
GLboolean _GLEE_WGL_EXT_multisample = GL_FALSE;
GLboolean _GLEE_WGL_I3D_digital_video_control = GL_FALSE;
GLboolean _GLEE_WGL_I3D_gamma = GL_FALSE;
GLboolean _GLEE_WGL_I3D_genlock = GL_FALSE;
GLboolean _GLEE_WGL_I3D_image_buffer = GL_FALSE;
GLboolean _GLEE_WGL_I3D_swap_frame_lock = GL_FALSE;
GLboolean _GLEE_WGL_NV_render_depth_texture = GL_FALSE;
GLboolean _GLEE_WGL_NV_render_texture_rectangle = GL_FALSE;
GLboolean _GLEE_WGL_ATI_pixel_format_float = GL_FALSE;
GLboolean _GLEE_WGL_NV_float_buffer = GL_FALSE;
GLboolean _GLEE_WGL_3DL_stereo_control = GL_FALSE;
GLboolean _GLEE_WGL_EXT_pixel_format_packed_float = GL_FALSE;
GLboolean _GLEE_WGL_EXT_framebuffer_sRGB = GL_FALSE;
GLboolean _GLEE_WGL_NV_present_video = GL_FALSE;
GLboolean _GLEE_WGL_NV_swap_group = GL_FALSE;
GLboolean _GLEE_WGL_NV_gpu_affinity = GL_FALSE;
GLboolean _GLEE_WGL_EXT_display_color_table = GL_FALSE;
GLboolean _GLEE_WGL_EXT_extensions_string = GL_FALSE;
GLboolean _GLEE_WGL_EXT_swap_control = GL_FALSE;
GLboolean _GLEE_WGL_NV_vertex_array_range = GL_FALSE;
GLboolean _GLEE_WGL_OML_sync_control = GL_FALSE;
GLboolean _GLEE_WGL_I3D_swap_frame_usage = GL_FALSE;
GLboolean _GLEE_WGL_NV_video_output = GL_FALSE;
/* WGL Extension names */
char __GLeeWGLExtensionNames[37][34]={
"WGL_ARB_buffer_region",
"WGL_ARB_multisample",
"WGL_ARB_extensions_string",
"WGL_ARB_pixel_format",
"WGL_ARB_make_current_read",
"WGL_ARB_pbuffer",
"WGL_ARB_render_texture",
"WGL_ARB_pixel_format_float",
"WGL_ARB_create_context",
"WGL_EXT_make_current_read",
"WGL_EXT_pixel_format",
"WGL_EXT_pbuffer",
"WGL_EXT_depth_float",
"WGL_3DFX_multisample",
"WGL_EXT_multisample",
"WGL_I3D_digital_video_control",
"WGL_I3D_gamma",
"WGL_I3D_genlock",
"WGL_I3D_image_buffer",
"WGL_I3D_swap_frame_lock",
"WGL_NV_render_depth_texture",
"WGL_NV_render_texture_rectangle",
"WGL_ATI_pixel_format_float",
"WGL_NV_float_buffer",
"WGL_3DL_stereo_control",
"WGL_EXT_pixel_format_packed_float",
"WGL_EXT_framebuffer_sRGB",
"WGL_NV_present_video",
"WGL_NV_swap_group",
"WGL_NV_gpu_affinity",
"WGL_EXT_display_color_table",
"WGL_EXT_extensions_string",
"WGL_EXT_swap_control",
"WGL_NV_vertex_array_range",
"WGL_OML_sync_control",
"WGL_I3D_swap_frame_usage",
"WGL_NV_video_output"
};
int __GLeeWGLNumExtensions=37;
/* WGL_ARB_buffer_region */
#ifdef __GLEE_WGL_ARB_buffer_region
#ifndef GLEE_C_DEFINED_wglCreateBufferRegionARB
#define GLEE_C_DEFINED_wglCreateBufferRegionARB
HANDLE __stdcall GLee_Lazy_wglCreateBufferRegionARB(HDC hDC, int iLayerPlane, UINT uType) {if (GLeeInit()) return wglCreateBufferRegionARB(hDC, iLayerPlane, uType); return (HANDLE)0;}
GLEEPFNWGLCREATEBUFFERREGIONARBPROC GLeeFuncPtr_wglCreateBufferRegionARB=GLee_Lazy_wglCreateBufferRegionARB;
#endif
#ifndef GLEE_C_DEFINED_wglDeleteBufferRegionARB
#define GLEE_C_DEFINED_wglDeleteBufferRegionARB
VOID __stdcall GLee_Lazy_wglDeleteBufferRegionARB(HANDLE hRegion) {if (GLeeInit()) wglDeleteBufferRegionARB(hRegion);}
GLEEPFNWGLDELETEBUFFERREGIONARBPROC GLeeFuncPtr_wglDeleteBufferRegionARB=GLee_Lazy_wglDeleteBufferRegionARB;
#endif
#ifndef GLEE_C_DEFINED_wglSaveBufferRegionARB
#define GLEE_C_DEFINED_wglSaveBufferRegionARB
BOOL __stdcall GLee_Lazy_wglSaveBufferRegionARB(HANDLE hRegion, int x, int y, int width, int height) {if (GLeeInit()) return wglSaveBufferRegionARB(hRegion, x, y, width, height); return (BOOL)0;}
GLEEPFNWGLSAVEBUFFERREGIONARBPROC GLeeFuncPtr_wglSaveBufferRegionARB=GLee_Lazy_wglSaveBufferRegionARB;
#endif
#ifndef GLEE_C_DEFINED_wglRestoreBufferRegionARB
#define GLEE_C_DEFINED_wglRestoreBufferRegionARB
BOOL __stdcall GLee_Lazy_wglRestoreBufferRegionARB(HANDLE hRegion, int x, int y, int width, int height, int xSrc, int ySrc) {if (GLeeInit()) return wglRestoreBufferRegionARB(hRegion, x, y, width, height, xSrc, ySrc); return (BOOL)0;}
GLEEPFNWGLRESTOREBUFFERREGIONARBPROC GLeeFuncPtr_wglRestoreBufferRegionARB=GLee_Lazy_wglRestoreBufferRegionARB;
#endif
#endif
/* WGL_ARB_multisample */
#ifdef __GLEE_WGL_ARB_multisample
#endif
/* WGL_ARB_extensions_string */
#ifdef __GLEE_WGL_ARB_extensions_string
#ifndef GLEE_C_DEFINED_wglGetExtensionsStringARB
#define GLEE_C_DEFINED_wglGetExtensionsStringARB
const char * __stdcall GLee_Lazy_wglGetExtensionsStringARB(HDC hdc) {if (GLeeInit()) return wglGetExtensionsStringARB(hdc); return (const char *)0;}
GLEEPFNWGLGETEXTENSIONSSTRINGARBPROC GLeeFuncPtr_wglGetExtensionsStringARB=GLee_Lazy_wglGetExtensionsStringARB;
#endif
#endif
/* WGL_ARB_pixel_format */
#ifdef __GLEE_WGL_ARB_pixel_format
#ifndef GLEE_C_DEFINED_wglGetPixelFormatAttribivARB
#define GLEE_C_DEFINED_wglGetPixelFormatAttribivARB
BOOL __stdcall GLee_Lazy_wglGetPixelFormatAttribivARB(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int * piAttributes, int * piValues) {if (GLeeInit()) return wglGetPixelFormatAttribivARB(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues); return (BOOL)0;}
GLEEPFNWGLGETPIXELFORMATATTRIBIVARBPROC GLeeFuncPtr_wglGetPixelFormatAttribivARB=GLee_Lazy_wglGetPixelFormatAttribivARB;
#endif
#ifndef GLEE_C_DEFINED_wglGetPixelFormatAttribfvARB
#define GLEE_C_DEFINED_wglGetPixelFormatAttribfvARB
BOOL __stdcall GLee_Lazy_wglGetPixelFormatAttribfvARB(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int * piAttributes, FLOAT * pfValues) {if (GLeeInit()) return wglGetPixelFormatAttribfvARB(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues); return (BOOL)0;}
GLEEPFNWGLGETPIXELFORMATATTRIBFVARBPROC GLeeFuncPtr_wglGetPixelFormatAttribfvARB=GLee_Lazy_wglGetPixelFormatAttribfvARB;
#endif
#ifndef GLEE_C_DEFINED_wglChoosePixelFormatARB
#define GLEE_C_DEFINED_wglChoosePixelFormatARB
BOOL __stdcall GLee_Lazy_wglChoosePixelFormatARB(HDC hdc, const int * piAttribIList, const FLOAT * pfAttribFList, UINT nMaxFormats, int * piFormats, UINT * nNumFormats) {if (GLeeInit()) return wglChoosePixelFormatARB(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats); return (BOOL)0;}
GLEEPFNWGLCHOOSEPIXELFORMATARBPROC GLeeFuncPtr_wglChoosePixelFormatARB=GLee_Lazy_wglChoosePixelFormatARB;
#endif
#endif
/* WGL_ARB_make_current_read */
#ifdef __GLEE_WGL_ARB_make_current_read
#ifndef GLEE_C_DEFINED_wglMakeContextCurrentARB
#define GLEE_C_DEFINED_wglMakeContextCurrentARB
BOOL __stdcall GLee_Lazy_wglMakeContextCurrentARB(HDC hDrawDC, HDC hReadDC, HGLRC hglrc) {if (GLeeInit()) return wglMakeContextCurrentARB(hDrawDC, hReadDC, hglrc); return (BOOL)0;}
GLEEPFNWGLMAKECONTEXTCURRENTARBPROC GLeeFuncPtr_wglMakeContextCurrentARB=GLee_Lazy_wglMakeContextCurrentARB;
#endif
#ifndef GLEE_C_DEFINED_wglGetCurrentReadDCARB
#define GLEE_C_DEFINED_wglGetCurrentReadDCARB
HDC __stdcall GLee_Lazy_wglGetCurrentReadDCARB(void) {if (GLeeInit()) return wglGetCurrentReadDCARB(); return (HDC)0;}
GLEEPFNWGLGETCURRENTREADDCARBPROC GLeeFuncPtr_wglGetCurrentReadDCARB=GLee_Lazy_wglGetCurrentReadDCARB;
#endif
#endif
/* WGL_ARB_pbuffer */
#ifdef __GLEE_WGL_ARB_pbuffer
#ifndef GLEE_C_DEFINED_wglCreatePbufferARB
#define GLEE_C_DEFINED_wglCreatePbufferARB
HPBUFFERARB __stdcall GLee_Lazy_wglCreatePbufferARB(HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int * piAttribList) {if (GLeeInit()) return wglCreatePbufferARB(hDC, iPixelFormat, iWidth, iHeight, piAttribList); return (HPBUFFERARB)0;}
GLEEPFNWGLCREATEPBUFFERARBPROC GLeeFuncPtr_wglCreatePbufferARB=GLee_Lazy_wglCreatePbufferARB;
#endif
#ifndef GLEE_C_DEFINED_wglGetPbufferDCARB
#define GLEE_C_DEFINED_wglGetPbufferDCARB
HDC __stdcall GLee_Lazy_wglGetPbufferDCARB(HPBUFFERARB hPbuffer) {if (GLeeInit()) return wglGetPbufferDCARB(hPbuffer); return (HDC)0;}
GLEEPFNWGLGETPBUFFERDCARBPROC GLeeFuncPtr_wglGetPbufferDCARB=GLee_Lazy_wglGetPbufferDCARB;
#endif
#ifndef GLEE_C_DEFINED_wglReleasePbufferDCARB
#define GLEE_C_DEFINED_wglReleasePbufferDCARB
int __stdcall GLee_Lazy_wglReleasePbufferDCARB(HPBUFFERARB hPbuffer, HDC hDC) {if (GLeeInit()) return wglReleasePbufferDCARB(hPbuffer, hDC); return (int)0;}
GLEEPFNWGLRELEASEPBUFFERDCARBPROC GLeeFuncPtr_wglReleasePbufferDCARB=GLee_Lazy_wglReleasePbufferDCARB;
#endif
#ifndef GLEE_C_DEFINED_wglDestroyPbufferARB
#define GLEE_C_DEFINED_wglDestroyPbufferARB
BOOL __stdcall GLee_Lazy_wglDestroyPbufferARB(HPBUFFERARB hPbuffer) {if (GLeeInit()) return wglDestroyPbufferARB(hPbuffer); return (BOOL)0;}
GLEEPFNWGLDESTROYPBUFFERARBPROC GLeeFuncPtr_wglDestroyPbufferARB=GLee_Lazy_wglDestroyPbufferARB;
#endif
#ifndef GLEE_C_DEFINED_wglQueryPbufferARB
#define GLEE_C_DEFINED_wglQueryPbufferARB
BOOL __stdcall GLee_Lazy_wglQueryPbufferARB(HPBUFFERARB hPbuffer, int iAttribute, int * piValue) {if (GLeeInit()) return wglQueryPbufferARB(hPbuffer, iAttribute, piValue); return (BOOL)0;}
GLEEPFNWGLQUERYPBUFFERARBPROC GLeeFuncPtr_wglQueryPbufferARB=GLee_Lazy_wglQueryPbufferARB;
#endif
#endif
/* WGL_ARB_render_texture */
#ifdef __GLEE_WGL_ARB_render_texture
#ifndef GLEE_C_DEFINED_wglBindTexImageARB
#define GLEE_C_DEFINED_wglBindTexImageARB
BOOL __stdcall GLee_Lazy_wglBindTexImageARB(HPBUFFERARB hPbuffer, int iBuffer) {if (GLeeInit()) return wglBindTexImageARB(hPbuffer, iBuffer); return (BOOL)0;}
GLEEPFNWGLBINDTEXIMAGEARBPROC GLeeFuncPtr_wglBindTexImageARB=GLee_Lazy_wglBindTexImageARB;
#endif
#ifndef GLEE_C_DEFINED_wglReleaseTexImageARB
#define GLEE_C_DEFINED_wglReleaseTexImageARB
BOOL __stdcall GLee_Lazy_wglReleaseTexImageARB(HPBUFFERARB hPbuffer, int iBuffer) {if (GLeeInit()) return wglReleaseTexImageARB(hPbuffer, iBuffer); return (BOOL)0;}
GLEEPFNWGLRELEASETEXIMAGEARBPROC GLeeFuncPtr_wglReleaseTexImageARB=GLee_Lazy_wglReleaseTexImageARB;
#endif
#ifndef GLEE_C_DEFINED_wglSetPbufferAttribARB
#define GLEE_C_DEFINED_wglSetPbufferAttribARB
BOOL __stdcall GLee_Lazy_wglSetPbufferAttribARB(HPBUFFERARB hPbuffer, const int * piAttribList) {if (GLeeInit()) return wglSetPbufferAttribARB(hPbuffer, piAttribList); return (BOOL)0;}
GLEEPFNWGLSETPBUFFERATTRIBARBPROC GLeeFuncPtr_wglSetPbufferAttribARB=GLee_Lazy_wglSetPbufferAttribARB;
#endif
#endif
/* WGL_ARB_pixel_format_float */
#ifdef __GLEE_WGL_ARB_pixel_format_float
#endif
/* WGL_ARB_create_context */
#ifdef __GLEE_WGL_ARB_create_context
#ifndef GLEE_C_DEFINED_wglCreateContextAttribsARB
#define GLEE_C_DEFINED_wglCreateContextAttribsARB
HGLRC __stdcall GLee_Lazy_wglCreateContextAttribsARB(HDC hDC, HGLRC hShareContext, const int * attribList) {if (GLeeInit()) return wglCreateContextAttribsARB(hDC, hShareContext, attribList); return (HGLRC)0;}
GLEEPFNWGLCREATECONTEXTATTRIBSARBPROC GLeeFuncPtr_wglCreateContextAttribsARB=GLee_Lazy_wglCreateContextAttribsARB;
#endif
#endif
/* WGL_EXT_make_current_read */
#ifdef __GLEE_WGL_EXT_make_current_read
#ifndef GLEE_C_DEFINED_wglMakeContextCurrentEXT
#define GLEE_C_DEFINED_wglMakeContextCurrentEXT
BOOL __stdcall GLee_Lazy_wglMakeContextCurrentEXT(HDC hDrawDC, HDC hReadDC, HGLRC hglrc) {if (GLeeInit()) return wglMakeContextCurrentEXT(hDrawDC, hReadDC, hglrc); return (BOOL)0;}
GLEEPFNWGLMAKECONTEXTCURRENTEXTPROC GLeeFuncPtr_wglMakeContextCurrentEXT=GLee_Lazy_wglMakeContextCurrentEXT;
#endif
#ifndef GLEE_C_DEFINED_wglGetCurrentReadDCEXT
#define GLEE_C_DEFINED_wglGetCurrentReadDCEXT
HDC __stdcall GLee_Lazy_wglGetCurrentReadDCEXT(void) {if (GLeeInit()) return wglGetCurrentReadDCEXT(); return (HDC)0;}
GLEEPFNWGLGETCURRENTREADDCEXTPROC GLeeFuncPtr_wglGetCurrentReadDCEXT=GLee_Lazy_wglGetCurrentReadDCEXT;
#endif
#endif
/* WGL_EXT_pixel_format */
#ifdef __GLEE_WGL_EXT_pixel_format
#ifndef GLEE_C_DEFINED_wglGetPixelFormatAttribivEXT
#define GLEE_C_DEFINED_wglGetPixelFormatAttribivEXT
BOOL __stdcall GLee_Lazy_wglGetPixelFormatAttribivEXT(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int * piAttributes, int * piValues) {if (GLeeInit()) return wglGetPixelFormatAttribivEXT(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues); return (BOOL)0;}
GLEEPFNWGLGETPIXELFORMATATTRIBIVEXTPROC GLeeFuncPtr_wglGetPixelFormatAttribivEXT=GLee_Lazy_wglGetPixelFormatAttribivEXT;
#endif
#ifndef GLEE_C_DEFINED_wglGetPixelFormatAttribfvEXT
#define GLEE_C_DEFINED_wglGetPixelFormatAttribfvEXT
BOOL __stdcall GLee_Lazy_wglGetPixelFormatAttribfvEXT(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int * piAttributes, FLOAT * pfValues) {if (GLeeInit()) return wglGetPixelFormatAttribfvEXT(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues); return (BOOL)0;}
GLEEPFNWGLGETPIXELFORMATATTRIBFVEXTPROC GLeeFuncPtr_wglGetPixelFormatAttribfvEXT=GLee_Lazy_wglGetPixelFormatAttribfvEXT;
#endif
#ifndef GLEE_C_DEFINED_wglChoosePixelFormatEXT
#define GLEE_C_DEFINED_wglChoosePixelFormatEXT
BOOL __stdcall GLee_Lazy_wglChoosePixelFormatEXT(HDC hdc, const int * piAttribIList, const FLOAT * pfAttribFList, UINT nMaxFormats, int * piFormats, UINT * nNumFormats) {if (GLeeInit()) return wglChoosePixelFormatEXT(hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats); return (BOOL)0;}
GLEEPFNWGLCHOOSEPIXELFORMATEXTPROC GLeeFuncPtr_wglChoosePixelFormatEXT=GLee_Lazy_wglChoosePixelFormatEXT;
#endif
#endif
/* WGL_EXT_pbuffer */
#ifdef __GLEE_WGL_EXT_pbuffer
#ifndef GLEE_C_DEFINED_wglCreatePbufferEXT
#define GLEE_C_DEFINED_wglCreatePbufferEXT
HPBUFFEREXT __stdcall GLee_Lazy_wglCreatePbufferEXT(HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int * piAttribList) {if (GLeeInit()) return wglCreatePbufferEXT(hDC, iPixelFormat, iWidth, iHeight, piAttribList); return (HPBUFFEREXT)0;}
GLEEPFNWGLCREATEPBUFFEREXTPROC GLeeFuncPtr_wglCreatePbufferEXT=GLee_Lazy_wglCreatePbufferEXT;
#endif
#ifndef GLEE_C_DEFINED_wglGetPbufferDCEXT
#define GLEE_C_DEFINED_wglGetPbufferDCEXT
HDC __stdcall GLee_Lazy_wglGetPbufferDCEXT(HPBUFFEREXT hPbuffer) {if (GLeeInit()) return wglGetPbufferDCEXT(hPbuffer); return (HDC)0;}
GLEEPFNWGLGETPBUFFERDCEXTPROC GLeeFuncPtr_wglGetPbufferDCEXT=GLee_Lazy_wglGetPbufferDCEXT;
#endif
#ifndef GLEE_C_DEFINED_wglReleasePbufferDCEXT
#define GLEE_C_DEFINED_wglReleasePbufferDCEXT
int __stdcall GLee_Lazy_wglReleasePbufferDCEXT(HPBUFFEREXT hPbuffer, HDC hDC) {if (GLeeInit()) return wglReleasePbufferDCEXT(hPbuffer, hDC); return (int)0;}
GLEEPFNWGLRELEASEPBUFFERDCEXTPROC GLeeFuncPtr_wglReleasePbufferDCEXT=GLee_Lazy_wglReleasePbufferDCEXT;
#endif
#ifndef GLEE_C_DEFINED_wglDestroyPbufferEXT
#define GLEE_C_DEFINED_wglDestroyPbufferEXT
BOOL __stdcall GLee_Lazy_wglDestroyPbufferEXT(HPBUFFEREXT hPbuffer) {if (GLeeInit()) return wglDestroyPbufferEXT(hPbuffer); return (BOOL)0;}
GLEEPFNWGLDESTROYPBUFFEREXTPROC GLeeFuncPtr_wglDestroyPbufferEXT=GLee_Lazy_wglDestroyPbufferEXT;
#endif
#ifndef GLEE_C_DEFINED_wglQueryPbufferEXT
#define GLEE_C_DEFINED_wglQueryPbufferEXT
BOOL __stdcall GLee_Lazy_wglQueryPbufferEXT(HPBUFFEREXT hPbuffer, int iAttribute, int * piValue) {if (GLeeInit()) return wglQueryPbufferEXT(hPbuffer, iAttribute, piValue); return (BOOL)0;}
GLEEPFNWGLQUERYPBUFFEREXTPROC GLeeFuncPtr_wglQueryPbufferEXT=GLee_Lazy_wglQueryPbufferEXT;
#endif
#endif
/* WGL_EXT_depth_float */
#ifdef __GLEE_WGL_EXT_depth_float
#endif
/* WGL_3DFX_multisample */
#ifdef __GLEE_WGL_3DFX_multisample
#endif
/* WGL_EXT_multisample */
#ifdef __GLEE_WGL_EXT_multisample
#endif
/* WGL_I3D_digital_video_control */
#ifdef __GLEE_WGL_I3D_digital_video_control
#ifndef GLEE_C_DEFINED_wglGetDigitalVideoParametersI3D
#define GLEE_C_DEFINED_wglGetDigitalVideoParametersI3D
BOOL __stdcall GLee_Lazy_wglGetDigitalVideoParametersI3D(HDC hDC, int iAttribute, int * piValue) {if (GLeeInit()) return wglGetDigitalVideoParametersI3D(hDC, iAttribute, piValue); return (BOOL)0;}
GLEEPFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC GLeeFuncPtr_wglGetDigitalVideoParametersI3D=GLee_Lazy_wglGetDigitalVideoParametersI3D;
#endif
#ifndef GLEE_C_DEFINED_wglSetDigitalVideoParametersI3D
#define GLEE_C_DEFINED_wglSetDigitalVideoParametersI3D
BOOL __stdcall GLee_Lazy_wglSetDigitalVideoParametersI3D(HDC hDC, int iAttribute, const int * piValue) {if (GLeeInit()) return wglSetDigitalVideoParametersI3D(hDC, iAttribute, piValue); return (BOOL)0;}
GLEEPFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC GLeeFuncPtr_wglSetDigitalVideoParametersI3D=GLee_Lazy_wglSetDigitalVideoParametersI3D;
#endif
#endif
/* WGL_I3D_gamma */
#ifdef __GLEE_WGL_I3D_gamma
#ifndef GLEE_C_DEFINED_wglGetGammaTableParametersI3D
#define GLEE_C_DEFINED_wglGetGammaTableParametersI3D
BOOL __stdcall GLee_Lazy_wglGetGammaTableParametersI3D(HDC hDC, int iAttribute, int * piValue) {if (GLeeInit()) return wglGetGammaTableParametersI3D(hDC, iAttribute, piValue); return (BOOL)0;}
GLEEPFNWGLGETGAMMATABLEPARAMETERSI3DPROC GLeeFuncPtr_wglGetGammaTableParametersI3D=GLee_Lazy_wglGetGammaTableParametersI3D;
#endif
#ifndef GLEE_C_DEFINED_wglSetGammaTableParametersI3D
#define GLEE_C_DEFINED_wglSetGammaTableParametersI3D
BOOL __stdcall GLee_Lazy_wglSetGammaTableParametersI3D(HDC hDC, int iAttribute, const int * piValue) {if (GLeeInit()) return wglSetGammaTableParametersI3D(hDC, iAttribute, piValue); return (BOOL)0;}
GLEEPFNWGLSETGAMMATABLEPARAMETERSI3DPROC GLeeFuncPtr_wglSetGammaTableParametersI3D=GLee_Lazy_wglSetGammaTableParametersI3D;
#endif
#ifndef GLEE_C_DEFINED_wglGetGammaTableI3D
#define GLEE_C_DEFINED_wglGetGammaTableI3D
BOOL __stdcall GLee_Lazy_wglGetGammaTableI3D(HDC hDC, int iEntries, USHORT * puRed, USHORT * puGreen, USHORT * puBlue) {if (GLeeInit()) return wglGetGammaTableI3D(hDC, iEntries, puRed, puGreen, puBlue); return (BOOL)0;}
GLEEPFNWGLGETGAMMATABLEI3DPROC GLeeFuncPtr_wglGetGammaTableI3D=GLee_Lazy_wglGetGammaTableI3D;
#endif
#ifndef GLEE_C_DEFINED_wglSetGammaTableI3D
#define GLEE_C_DEFINED_wglSetGammaTableI3D
BOOL __stdcall GLee_Lazy_wglSetGammaTableI3D(HDC hDC, int iEntries, const USHORT * puRed, const USHORT * puGreen, const USHORT * puBlue) {if (GLeeInit()) return wglSetGammaTableI3D(hDC, iEntries, puRed, puGreen, puBlue); return (BOOL)0;}
GLEEPFNWGLSETGAMMATABLEI3DPROC GLeeFuncPtr_wglSetGammaTableI3D=GLee_Lazy_wglSetGammaTableI3D;
#endif
#endif
/* WGL_I3D_genlock */
#ifdef __GLEE_WGL_I3D_genlock
#ifndef GLEE_C_DEFINED_wglEnableGenlockI3D
#define GLEE_C_DEFINED_wglEnableGenlockI3D
BOOL __stdcall GLee_Lazy_wglEnableGenlockI3D(HDC hDC) {if (GLeeInit()) return wglEnableGenlockI3D(hDC); return (BOOL)0;}
GLEEPFNWGLENABLEGENLOCKI3DPROC GLeeFuncPtr_wglEnableGenlockI3D=GLee_Lazy_wglEnableGenlockI3D;
#endif
#ifndef GLEE_C_DEFINED_wglDisableGenlockI3D
#define GLEE_C_DEFINED_wglDisableGenlockI3D
BOOL __stdcall GLee_Lazy_wglDisableGenlockI3D(HDC hDC) {if (GLeeInit()) return wglDisableGenlockI3D(hDC); return (BOOL)0;}
GLEEPFNWGLDISABLEGENLOCKI3DPROC GLeeFuncPtr_wglDisableGenlockI3D=GLee_Lazy_wglDisableGenlockI3D;
#endif
#ifndef GLEE_C_DEFINED_wglIsEnabledGenlockI3D
#define GLEE_C_DEFINED_wglIsEnabledGenlockI3D
BOOL __stdcall GLee_Lazy_wglIsEnabledGenlockI3D(HDC hDC, BOOL * pFlag) {if (GLeeInit()) return wglIsEnabledGenlockI3D(hDC, pFlag); return (BOOL)0;}
GLEEPFNWGLISENABLEDGENLOCKI3DPROC GLeeFuncPtr_wglIsEnabledGenlockI3D=GLee_Lazy_wglIsEnabledGenlockI3D;
#endif
#ifndef GLEE_C_DEFINED_wglGenlockSourceI3D
#define GLEE_C_DEFINED_wglGenlockSourceI3D
BOOL __stdcall GLee_Lazy_wglGenlockSourceI3D(HDC hDC, UINT uSource) {if (GLeeInit()) return wglGenlockSourceI3D(hDC, uSource); return (BOOL)0;}
GLEEPFNWGLGENLOCKSOURCEI3DPROC GLeeFuncPtr_wglGenlockSourceI3D=GLee_Lazy_wglGenlockSourceI3D;
#endif
#ifndef GLEE_C_DEFINED_wglGetGenlockSourceI3D
#define GLEE_C_DEFINED_wglGetGenlockSourceI3D
BOOL __stdcall GLee_Lazy_wglGetGenlockSourceI3D(HDC hDC, UINT * uSource) {if (GLeeInit()) return wglGetGenlockSourceI3D(hDC, uSource); return (BOOL)0;}
GLEEPFNWGLGETGENLOCKSOURCEI3DPROC GLeeFuncPtr_wglGetGenlockSourceI3D=GLee_Lazy_wglGetGenlockSourceI3D;
#endif
#ifndef GLEE_C_DEFINED_wglGenlockSourceEdgeI3D
#define GLEE_C_DEFINED_wglGenlockSourceEdgeI3D
BOOL __stdcall GLee_Lazy_wglGenlockSourceEdgeI3D(HDC hDC, UINT uEdge) {if (GLeeInit()) return wglGenlockSourceEdgeI3D(hDC, uEdge); return (BOOL)0;}
GLEEPFNWGLGENLOCKSOURCEEDGEI3DPROC GLeeFuncPtr_wglGenlockSourceEdgeI3D=GLee_Lazy_wglGenlockSourceEdgeI3D;
#endif
#ifndef GLEE_C_DEFINED_wglGetGenlockSourceEdgeI3D
#define GLEE_C_DEFINED_wglGetGenlockSourceEdgeI3D
BOOL __stdcall GLee_Lazy_wglGetGenlockSourceEdgeI3D(HDC hDC, UINT * uEdge) {if (GLeeInit()) return wglGetGenlockSourceEdgeI3D(hDC, uEdge); return (BOOL)0;}
GLEEPFNWGLGETGENLOCKSOURCEEDGEI3DPROC GLeeFuncPtr_wglGetGenlockSourceEdgeI3D=GLee_Lazy_wglGetGenlockSourceEdgeI3D;
#endif
#ifndef GLEE_C_DEFINED_wglGenlockSampleRateI3D
#define GLEE_C_DEFINED_wglGenlockSampleRateI3D
BOOL __stdcall GLee_Lazy_wglGenlockSampleRateI3D(HDC hDC, UINT uRate) {if (GLeeInit()) return wglGenlockSampleRateI3D(hDC, uRate); return (BOOL)0;}
GLEEPFNWGLGENLOCKSAMPLERATEI3DPROC GLeeFuncPtr_wglGenlockSampleRateI3D=GLee_Lazy_wglGenlockSampleRateI3D;
#endif
#ifndef GLEE_C_DEFINED_wglGetGenlockSampleRateI3D
#define GLEE_C_DEFINED_wglGetGenlockSampleRateI3D
BOOL __stdcall GLee_Lazy_wglGetGenlockSampleRateI3D(HDC hDC, UINT * uRate) {if (GLeeInit()) return wglGetGenlockSampleRateI3D(hDC, uRate); return (BOOL)0;}
GLEEPFNWGLGETGENLOCKSAMPLERATEI3DPROC GLeeFuncPtr_wglGetGenlockSampleRateI3D=GLee_Lazy_wglGetGenlockSampleRateI3D;
#endif
#ifndef GLEE_C_DEFINED_wglGenlockSourceDelayI3D
#define GLEE_C_DEFINED_wglGenlockSourceDelayI3D
BOOL __stdcall GLee_Lazy_wglGenlockSourceDelayI3D(HDC hDC, UINT uDelay) {if (GLeeInit()) return wglGenlockSourceDelayI3D(hDC, uDelay); return (BOOL)0;}
GLEEPFNWGLGENLOCKSOURCEDELAYI3DPROC GLeeFuncPtr_wglGenlockSourceDelayI3D=GLee_Lazy_wglGenlockSourceDelayI3D;
#endif
#ifndef GLEE_C_DEFINED_wglGetGenlockSourceDelayI3D
#define GLEE_C_DEFINED_wglGetGenlockSourceDelayI3D
BOOL __stdcall GLee_Lazy_wglGetGenlockSourceDelayI3D(HDC hDC, UINT * uDelay) {if (GLeeInit()) return wglGetGenlockSourceDelayI3D(hDC, uDelay); return (BOOL)0;}
GLEEPFNWGLGETGENLOCKSOURCEDELAYI3DPROC GLeeFuncPtr_wglGetGenlockSourceDelayI3D=GLee_Lazy_wglGetGenlockSourceDelayI3D;
#endif
#ifndef GLEE_C_DEFINED_wglQueryGenlockMaxSourceDelayI3D
#define GLEE_C_DEFINED_wglQueryGenlockMaxSourceDelayI3D
BOOL __stdcall GLee_Lazy_wglQueryGenlockMaxSourceDelayI3D(HDC hDC, UINT * uMaxLineDelay, UINT * uMaxPixelDelay) {if (GLeeInit()) return wglQueryGenlockMaxSourceDelayI3D(hDC, uMaxLineDelay, uMaxPixelDelay); return (BOOL)0;}
GLEEPFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC GLeeFuncPtr_wglQueryGenlockMaxSourceDelayI3D=GLee_Lazy_wglQueryGenlockMaxSourceDelayI3D;
#endif
#endif
/* WGL_I3D_image_buffer */
#ifdef __GLEE_WGL_I3D_image_buffer
#ifndef GLEE_C_DEFINED_wglCreateImageBufferI3D
#define GLEE_C_DEFINED_wglCreateImageBufferI3D
LPVOID __stdcall GLee_Lazy_wglCreateImageBufferI3D(HDC hDC, DWORD dwSize, UINT uFlags) {if (GLeeInit()) return wglCreateImageBufferI3D(hDC, dwSize, uFlags); return (LPVOID)0;}
GLEEPFNWGLCREATEIMAGEBUFFERI3DPROC GLeeFuncPtr_wglCreateImageBufferI3D=GLee_Lazy_wglCreateImageBufferI3D;
#endif
#ifndef GLEE_C_DEFINED_wglDestroyImageBufferI3D
#define GLEE_C_DEFINED_wglDestroyImageBufferI3D
BOOL __stdcall GLee_Lazy_wglDestroyImageBufferI3D(HDC hDC, LPVOID pAddress) {if (GLeeInit()) return wglDestroyImageBufferI3D(hDC, pAddress); return (BOOL)0;}
GLEEPFNWGLDESTROYIMAGEBUFFERI3DPROC GLeeFuncPtr_wglDestroyImageBufferI3D=GLee_Lazy_wglDestroyImageBufferI3D;
#endif
#ifndef GLEE_C_DEFINED_wglAssociateImageBufferEventsI3D
#define GLEE_C_DEFINED_wglAssociateImageBufferEventsI3D
BOOL __stdcall GLee_Lazy_wglAssociateImageBufferEventsI3D(HDC hDC, const HANDLE * pEvent, const LPVOID * pAddress, const DWORD * pSize, UINT count) {if (GLeeInit()) return wglAssociateImageBufferEventsI3D(hDC, pEvent, pAddress, pSize, count); return (BOOL)0;}
GLEEPFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC GLeeFuncPtr_wglAssociateImageBufferEventsI3D=GLee_Lazy_wglAssociateImageBufferEventsI3D;
#endif
#ifndef GLEE_C_DEFINED_wglReleaseImageBufferEventsI3D
#define GLEE_C_DEFINED_wglReleaseImageBufferEventsI3D
BOOL __stdcall GLee_Lazy_wglReleaseImageBufferEventsI3D(HDC hDC, const LPVOID * pAddress, UINT count) {if (GLeeInit()) return wglReleaseImageBufferEventsI3D(hDC, pAddress, count); return (BOOL)0;}
GLEEPFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC GLeeFuncPtr_wglReleaseImageBufferEventsI3D=GLee_Lazy_wglReleaseImageBufferEventsI3D;
#endif
#endif
/* WGL_I3D_swap_frame_lock */
#ifdef __GLEE_WGL_I3D_swap_frame_lock
#ifndef GLEE_C_DEFINED_wglEnableFrameLockI3D
#define GLEE_C_DEFINED_wglEnableFrameLockI3D
BOOL __stdcall GLee_Lazy_wglEnableFrameLockI3D(void) {if (GLeeInit()) return wglEnableFrameLockI3D(); return (BOOL)0;}
GLEEPFNWGLENABLEFRAMELOCKI3DPROC GLeeFuncPtr_wglEnableFrameLockI3D=GLee_Lazy_wglEnableFrameLockI3D;
#endif
#ifndef GLEE_C_DEFINED_wglDisableFrameLockI3D
#define GLEE_C_DEFINED_wglDisableFrameLockI3D
BOOL __stdcall GLee_Lazy_wglDisableFrameLockI3D(void) {if (GLeeInit()) return wglDisableFrameLockI3D(); return (BOOL)0;}
GLEEPFNWGLDISABLEFRAMELOCKI3DPROC GLeeFuncPtr_wglDisableFrameLockI3D=GLee_Lazy_wglDisableFrameLockI3D;
#endif
#ifndef GLEE_C_DEFINED_wglIsEnabledFrameLockI3D
#define GLEE_C_DEFINED_wglIsEnabledFrameLockI3D
BOOL __stdcall GLee_Lazy_wglIsEnabledFrameLockI3D(BOOL * pFlag) {if (GLeeInit()) return wglIsEnabledFrameLockI3D(pFlag); return (BOOL)0;}
GLEEPFNWGLISENABLEDFRAMELOCKI3DPROC GLeeFuncPtr_wglIsEnabledFrameLockI3D=GLee_Lazy_wglIsEnabledFrameLockI3D;
#endif
#ifndef GLEE_C_DEFINED_wglQueryFrameLockMasterI3D
#define GLEE_C_DEFINED_wglQueryFrameLockMasterI3D
BOOL __stdcall GLee_Lazy_wglQueryFrameLockMasterI3D(BOOL * pFlag) {if (GLeeInit()) return wglQueryFrameLockMasterI3D(pFlag); return (BOOL)0;}
GLEEPFNWGLQUERYFRAMELOCKMASTERI3DPROC GLeeFuncPtr_wglQueryFrameLockMasterI3D=GLee_Lazy_wglQueryFrameLockMasterI3D;
#endif
#endif
/* WGL_NV_render_depth_texture */
#ifdef __GLEE_WGL_NV_render_depth_texture
#endif
/* WGL_NV_render_texture_rectangle */
#ifdef __GLEE_WGL_NV_render_texture_rectangle
#endif
/* WGL_ATI_pixel_format_float */
#ifdef __GLEE_WGL_ATI_pixel_format_float
#endif
/* WGL_NV_float_buffer */
#ifdef __GLEE_WGL_NV_float_buffer
#endif
/* WGL_3DL_stereo_control */
#ifdef __GLEE_WGL_3DL_stereo_control
#endif
/* WGL_EXT_pixel_format_packed_float */
#ifdef __GLEE_WGL_EXT_pixel_format_packed_float
#endif
/* WGL_EXT_framebuffer_sRGB */
#ifdef __GLEE_WGL_EXT_framebuffer_sRGB
#endif
/* WGL_NV_present_video */
#ifdef __GLEE_WGL_NV_present_video
#ifndef GLEE_C_DEFINED_wglEnumerateVideoDevicesNV
#define GLEE_C_DEFINED_wglEnumerateVideoDevicesNV
int __stdcall GLee_Lazy_wglEnumerateVideoDevicesNV(HDC hDC, HVIDEOOUTPUTDEVICENV * phDeviceList) {if (GLeeInit()) return wglEnumerateVideoDevicesNV(hDC, phDeviceList); return (int)0;}
GLEEPFNWGLENUMERATEVIDEODEVICESNVPROC GLeeFuncPtr_wglEnumerateVideoDevicesNV=GLee_Lazy_wglEnumerateVideoDevicesNV;
#endif
#ifndef GLEE_C_DEFINED_wglBindVideoDeviceNV
#define GLEE_C_DEFINED_wglBindVideoDeviceNV
BOOL __stdcall GLee_Lazy_wglBindVideoDeviceNV(HDC hDC, unsigned int uVideoSlot, HVIDEOOUTPUTDEVICENV hVideoDevice, const int * piAttribList) {if (GLeeInit()) return wglBindVideoDeviceNV(hDC, uVideoSlot, hVideoDevice, piAttribList); return (BOOL)0;}
GLEEPFNWGLBINDVIDEODEVICENVPROC GLeeFuncPtr_wglBindVideoDeviceNV=GLee_Lazy_wglBindVideoDeviceNV;
#endif
#ifndef GLEE_C_DEFINED_wglQueryCurrentContextNV
#define GLEE_C_DEFINED_wglQueryCurrentContextNV
BOOL __stdcall GLee_Lazy_wglQueryCurrentContextNV(int iAttribute, int * piValue) {if (GLeeInit()) return wglQueryCurrentContextNV(iAttribute, piValue); return (BOOL)0;}
GLEEPFNWGLQUERYCURRENTCONTEXTNVPROC GLeeFuncPtr_wglQueryCurrentContextNV=GLee_Lazy_wglQueryCurrentContextNV;
#endif
#endif
/* WGL_NV_swap_group */
#ifdef __GLEE_WGL_NV_swap_group
#ifndef GLEE_C_DEFINED_wglJoinSwapGroupNV
#define GLEE_C_DEFINED_wglJoinSwapGroupNV
BOOL __stdcall GLee_Lazy_wglJoinSwapGroupNV(HDC hDC, GLuint group) {if (GLeeInit()) return wglJoinSwapGroupNV(hDC, group); return (BOOL)0;}
GLEEPFNWGLJOINSWAPGROUPNVPROC GLeeFuncPtr_wglJoinSwapGroupNV=GLee_Lazy_wglJoinSwapGroupNV;
#endif
#ifndef GLEE_C_DEFINED_wglBindSwapBarrierNV
#define GLEE_C_DEFINED_wglBindSwapBarrierNV
BOOL __stdcall GLee_Lazy_wglBindSwapBarrierNV(GLuint group, GLuint barrier) {if (GLeeInit()) return wglBindSwapBarrierNV(group, barrier); return (BOOL)0;}
GLEEPFNWGLBINDSWAPBARRIERNVPROC GLeeFuncPtr_wglBindSwapBarrierNV=GLee_Lazy_wglBindSwapBarrierNV;
#endif
#ifndef GLEE_C_DEFINED_wglQuerySwapGroupNV
#define GLEE_C_DEFINED_wglQuerySwapGroupNV
BOOL __stdcall GLee_Lazy_wglQuerySwapGroupNV(HDC hDC, GLuint * group, GLuint * barrier) {if (GLeeInit()) return wglQuerySwapGroupNV(hDC, group, barrier); return (BOOL)0;}
GLEEPFNWGLQUERYSWAPGROUPNVPROC GLeeFuncPtr_wglQuerySwapGroupNV=GLee_Lazy_wglQuerySwapGroupNV;
#endif
#ifndef GLEE_C_DEFINED_wglQueryMaxSwapGroupsNV
#define GLEE_C_DEFINED_wglQueryMaxSwapGroupsNV
BOOL __stdcall GLee_Lazy_wglQueryMaxSwapGroupsNV(HDC hDC, GLuint * maxGroups, GLuint * maxBarriers) {if (GLeeInit()) return wglQueryMaxSwapGroupsNV(hDC, maxGroups, maxBarriers); return (BOOL)0;}
GLEEPFNWGLQUERYMAXSWAPGROUPSNVPROC GLeeFuncPtr_wglQueryMaxSwapGroupsNV=GLee_Lazy_wglQueryMaxSwapGroupsNV;
#endif
#ifndef GLEE_C_DEFINED_wglQueryFrameCountNV
#define GLEE_C_DEFINED_wglQueryFrameCountNV
BOOL __stdcall GLee_Lazy_wglQueryFrameCountNV(HDC hDC, GLuint * count) {if (GLeeInit()) return wglQueryFrameCountNV(hDC, count); return (BOOL)0;}
GLEEPFNWGLQUERYFRAMECOUNTNVPROC GLeeFuncPtr_wglQueryFrameCountNV=GLee_Lazy_wglQueryFrameCountNV;
#endif
#ifndef GLEE_C_DEFINED_wglResetFrameCountNV
#define GLEE_C_DEFINED_wglResetFrameCountNV
BOOL __stdcall GLee_Lazy_wglResetFrameCountNV(HDC hDC) {if (GLeeInit()) return wglResetFrameCountNV(hDC); return (BOOL)0;}
GLEEPFNWGLRESETFRAMECOUNTNVPROC GLeeFuncPtr_wglResetFrameCountNV=GLee_Lazy_wglResetFrameCountNV;
#endif
#endif
/* WGL_NV_gpu_affinity */
#ifdef __GLEE_WGL_NV_gpu_affinity
#ifndef GLEE_C_DEFINED_wglEnumGpusNV
#define GLEE_C_DEFINED_wglEnumGpusNV
BOOL __stdcall GLee_Lazy_wglEnumGpusNV(UINT iGpuIndex, HGPUNV * phGpu) {if (GLeeInit()) return wglEnumGpusNV(iGpuIndex, phGpu); return (BOOL)0;}
GLEEPFNWGLENUMGPUSNVPROC GLeeFuncPtr_wglEnumGpusNV=GLee_Lazy_wglEnumGpusNV;
#endif
#ifndef GLEE_C_DEFINED_wglEnumGpuDevicesNV
#define GLEE_C_DEFINED_wglEnumGpuDevicesNV
BOOL __stdcall GLee_Lazy_wglEnumGpuDevicesNV(HGPUNV hGpu, UINT iDeviceIndex, PGPU_DEVICE lpGpuDevice) {if (GLeeInit()) return wglEnumGpuDevicesNV(hGpu, iDeviceIndex, lpGpuDevice); return (BOOL)0;}
GLEEPFNWGLENUMGPUDEVICESNVPROC GLeeFuncPtr_wglEnumGpuDevicesNV=GLee_Lazy_wglEnumGpuDevicesNV;
#endif
#ifndef GLEE_C_DEFINED_wglCreateAffinityDCNV
#define GLEE_C_DEFINED_wglCreateAffinityDCNV
HDC __stdcall GLee_Lazy_wglCreateAffinityDCNV(const HGPUNV * phGpuList) {if (GLeeInit()) return wglCreateAffinityDCNV(phGpuList); return (HDC)0;}
GLEEPFNWGLCREATEAFFINITYDCNVPROC GLeeFuncPtr_wglCreateAffinityDCNV=GLee_Lazy_wglCreateAffinityDCNV;
#endif
#ifndef GLEE_C_DEFINED_wglEnumGpusFromAffinityDCNV
#define GLEE_C_DEFINED_wglEnumGpusFromAffinityDCNV
BOOL __stdcall GLee_Lazy_wglEnumGpusFromAffinityDCNV(HDC hAffinityDC, UINT iGpuIndex, HGPUNV * hGpu) {if (GLeeInit()) return wglEnumGpusFromAffinityDCNV(hAffinityDC, iGpuIndex, hGpu); return (BOOL)0;}
GLEEPFNWGLENUMGPUSFROMAFFINITYDCNVPROC GLeeFuncPtr_wglEnumGpusFromAffinityDCNV=GLee_Lazy_wglEnumGpusFromAffinityDCNV;
#endif
#ifndef GLEE_C_DEFINED_wglDeleteDCNV
#define GLEE_C_DEFINED_wglDeleteDCNV
BOOL __stdcall GLee_Lazy_wglDeleteDCNV(HDC hdc) {if (GLeeInit()) return wglDeleteDCNV(hdc); return (BOOL)0;}
GLEEPFNWGLDELETEDCNVPROC GLeeFuncPtr_wglDeleteDCNV=GLee_Lazy_wglDeleteDCNV;
#endif
#endif
/* WGL_EXT_display_color_table */
#ifdef __GLEE_WGL_EXT_display_color_table
#ifndef GLEE_C_DEFINED_wglCreateDisplayColorTableEXT
#define GLEE_C_DEFINED_wglCreateDisplayColorTableEXT
GLboolean __stdcall GLee_Lazy_wglCreateDisplayColorTableEXT(GLushort id) {if (GLeeInit()) return wglCreateDisplayColorTableEXT(id); return (GLboolean)0;}
GLEEPFNWGLCREATEDISPLAYCOLORTABLEEXTPROC GLeeFuncPtr_wglCreateDisplayColorTableEXT=GLee_Lazy_wglCreateDisplayColorTableEXT;
#endif
#ifndef GLEE_C_DEFINED_wglLoadDisplayColorTableEXT
#define GLEE_C_DEFINED_wglLoadDisplayColorTableEXT
GLboolean __stdcall GLee_Lazy_wglLoadDisplayColorTableEXT(const GLushort * table, GLuint length) {if (GLeeInit()) return wglLoadDisplayColorTableEXT(table, length); return (GLboolean)0;}
GLEEPFNWGLLOADDISPLAYCOLORTABLEEXTPROC GLeeFuncPtr_wglLoadDisplayColorTableEXT=GLee_Lazy_wglLoadDisplayColorTableEXT;
#endif
#ifndef GLEE_C_DEFINED_wglBindDisplayColorTableEXT
#define GLEE_C_DEFINED_wglBindDisplayColorTableEXT
GLboolean __stdcall GLee_Lazy_wglBindDisplayColorTableEXT(GLushort id) {if (GLeeInit()) return wglBindDisplayColorTableEXT(id); return (GLboolean)0;}
GLEEPFNWGLBINDDISPLAYCOLORTABLEEXTPROC GLeeFuncPtr_wglBindDisplayColorTableEXT=GLee_Lazy_wglBindDisplayColorTableEXT;
#endif
#ifndef GLEE_C_DEFINED_wglDestroyDisplayColorTableEXT
#define GLEE_C_DEFINED_wglDestroyDisplayColorTableEXT
VOID __stdcall GLee_Lazy_wglDestroyDisplayColorTableEXT(GLushort id) {if (GLeeInit()) wglDestroyDisplayColorTableEXT(id);}
GLEEPFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC GLeeFuncPtr_wglDestroyDisplayColorTableEXT=GLee_Lazy_wglDestroyDisplayColorTableEXT;
#endif
#endif
/* WGL_EXT_extensions_string */
#ifdef __GLEE_WGL_EXT_extensions_string
#ifndef GLEE_C_DEFINED_wglGetExtensionsStringEXT
#define GLEE_C_DEFINED_wglGetExtensionsStringEXT
const char * __stdcall GLee_Lazy_wglGetExtensionsStringEXT(void) {if (GLeeInit()) return wglGetExtensionsStringEXT(); return (const char *)0;}
GLEEPFNWGLGETEXTENSIONSSTRINGEXTPROC GLeeFuncPtr_wglGetExtensionsStringEXT=GLee_Lazy_wglGetExtensionsStringEXT;
#endif
#endif
/* WGL_EXT_swap_control */
#ifdef __GLEE_WGL_EXT_swap_control
#ifndef GLEE_C_DEFINED_wglSwapIntervalEXT
#define GLEE_C_DEFINED_wglSwapIntervalEXT
BOOL __stdcall GLee_Lazy_wglSwapIntervalEXT(int interval) {if (GLeeInit()) return wglSwapIntervalEXT(interval); return (BOOL)0;}
GLEEPFNWGLSWAPINTERVALEXTPROC GLeeFuncPtr_wglSwapIntervalEXT=GLee_Lazy_wglSwapIntervalEXT;
#endif
#ifndef GLEE_C_DEFINED_wglGetSwapIntervalEXT
#define GLEE_C_DEFINED_wglGetSwapIntervalEXT
int __stdcall GLee_Lazy_wglGetSwapIntervalEXT(void) {if (GLeeInit()) return wglGetSwapIntervalEXT(); return (int)0;}
GLEEPFNWGLGETSWAPINTERVALEXTPROC GLeeFuncPtr_wglGetSwapIntervalEXT=GLee_Lazy_wglGetSwapIntervalEXT;
#endif
#endif
/* WGL_NV_vertex_array_range */
#ifdef __GLEE_WGL_NV_vertex_array_range
#ifndef GLEE_C_DEFINED_wglAllocateMemoryNV
#define GLEE_C_DEFINED_wglAllocateMemoryNV
void* __stdcall GLee_Lazy_wglAllocateMemoryNV(GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority) {if (GLeeInit()) return wglAllocateMemoryNV(size, readfreq, writefreq, priority); return (void*)0;}
GLEEPFNWGLALLOCATEMEMORYNVPROC GLeeFuncPtr_wglAllocateMemoryNV=GLee_Lazy_wglAllocateMemoryNV;
#endif
#ifndef GLEE_C_DEFINED_wglFreeMemoryNV
#define GLEE_C_DEFINED_wglFreeMemoryNV
void __stdcall GLee_Lazy_wglFreeMemoryNV(void * pointer) {if (GLeeInit()) wglFreeMemoryNV(pointer);}
GLEEPFNWGLFREEMEMORYNVPROC GLeeFuncPtr_wglFreeMemoryNV=GLee_Lazy_wglFreeMemoryNV;
#endif
#endif
/* WGL_OML_sync_control */
#ifdef __GLEE_WGL_OML_sync_control
#ifndef GLEE_C_DEFINED_wglGetSyncValuesOML
#define GLEE_C_DEFINED_wglGetSyncValuesOML
BOOL __stdcall GLee_Lazy_wglGetSyncValuesOML(HDC hdc, INT64 * ust, INT64 * msc, INT64 * sbc) {if (GLeeInit()) return wglGetSyncValuesOML(hdc, ust, msc, sbc); return (BOOL)0;}
GLEEPFNWGLGETSYNCVALUESOMLPROC GLeeFuncPtr_wglGetSyncValuesOML=GLee_Lazy_wglGetSyncValuesOML;
#endif
#ifndef GLEE_C_DEFINED_wglGetMscRateOML
#define GLEE_C_DEFINED_wglGetMscRateOML
BOOL __stdcall GLee_Lazy_wglGetMscRateOML(HDC hdc, INT32 * numerator, INT32 * denominator) {if (GLeeInit()) return wglGetMscRateOML(hdc, numerator, denominator); return (BOOL)0;}
GLEEPFNWGLGETMSCRATEOMLPROC GLeeFuncPtr_wglGetMscRateOML=GLee_Lazy_wglGetMscRateOML;
#endif
#ifndef GLEE_C_DEFINED_wglSwapBuffersMscOML
#define GLEE_C_DEFINED_wglSwapBuffersMscOML
INT64 __stdcall GLee_Lazy_wglSwapBuffersMscOML(HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder) {if (GLeeInit()) return wglSwapBuffersMscOML(hdc, target_msc, divisor, remainder); return (INT64)0;}
GLEEPFNWGLSWAPBUFFERSMSCOMLPROC GLeeFuncPtr_wglSwapBuffersMscOML=GLee_Lazy_wglSwapBuffersMscOML;
#endif
#ifndef GLEE_C_DEFINED_wglSwapLayerBuffersMscOML
#define GLEE_C_DEFINED_wglSwapLayerBuffersMscOML
INT64 __stdcall GLee_Lazy_wglSwapLayerBuffersMscOML(HDC hdc, int fuPlanes, INT64 target_msc, INT64 divisor, INT64 remainder) {if (GLeeInit()) return wglSwapLayerBuffersMscOML(hdc, fuPlanes, target_msc, divisor, remainder); return (INT64)0;}
GLEEPFNWGLSWAPLAYERBUFFERSMSCOMLPROC GLeeFuncPtr_wglSwapLayerBuffersMscOML=GLee_Lazy_wglSwapLayerBuffersMscOML;
#endif
#ifndef GLEE_C_DEFINED_wglWaitForMscOML
#define GLEE_C_DEFINED_wglWaitForMscOML
BOOL __stdcall GLee_Lazy_wglWaitForMscOML(HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder, INT64 * ust, INT64 * msc, INT64 * sbc) {if (GLeeInit()) return wglWaitForMscOML(hdc, target_msc, divisor, remainder, ust, msc, sbc); return (BOOL)0;}
GLEEPFNWGLWAITFORMSCOMLPROC GLeeFuncPtr_wglWaitForMscOML=GLee_Lazy_wglWaitForMscOML;
#endif
#ifndef GLEE_C_DEFINED_wglWaitForSbcOML
#define GLEE_C_DEFINED_wglWaitForSbcOML
BOOL __stdcall GLee_Lazy_wglWaitForSbcOML(HDC hdc, INT64 target_sbc, INT64 * ust, INT64 * msc, INT64 * sbc) {if (GLeeInit()) return wglWaitForSbcOML(hdc, target_sbc, ust, msc, sbc); return (BOOL)0;}
GLEEPFNWGLWAITFORSBCOMLPROC GLeeFuncPtr_wglWaitForSbcOML=GLee_Lazy_wglWaitForSbcOML;
#endif
#endif
/* WGL_I3D_swap_frame_usage */
#ifdef __GLEE_WGL_I3D_swap_frame_usage
#ifndef GLEE_C_DEFINED_wglGetFrameUsageI3D
#define GLEE_C_DEFINED_wglGetFrameUsageI3D
BOOL __stdcall GLee_Lazy_wglGetFrameUsageI3D(float * pUsage) {if (GLeeInit()) return wglGetFrameUsageI3D(pUsage); return (BOOL)0;}
GLEEPFNWGLGETFRAMEUSAGEI3DPROC GLeeFuncPtr_wglGetFrameUsageI3D=GLee_Lazy_wglGetFrameUsageI3D;
#endif
#ifndef GLEE_C_DEFINED_wglBeginFrameTrackingI3D
#define GLEE_C_DEFINED_wglBeginFrameTrackingI3D
BOOL __stdcall GLee_Lazy_wglBeginFrameTrackingI3D(void) {if (GLeeInit()) return wglBeginFrameTrackingI3D(); return (BOOL)0;}
GLEEPFNWGLBEGINFRAMETRACKINGI3DPROC GLeeFuncPtr_wglBeginFrameTrackingI3D=GLee_Lazy_wglBeginFrameTrackingI3D;
#endif
#ifndef GLEE_C_DEFINED_wglEndFrameTrackingI3D
#define GLEE_C_DEFINED_wglEndFrameTrackingI3D
BOOL __stdcall GLee_Lazy_wglEndFrameTrackingI3D(void) {if (GLeeInit()) return wglEndFrameTrackingI3D(); return (BOOL)0;}
GLEEPFNWGLENDFRAMETRACKINGI3DPROC GLeeFuncPtr_wglEndFrameTrackingI3D=GLee_Lazy_wglEndFrameTrackingI3D;
#endif
#ifndef GLEE_C_DEFINED_wglQueryFrameTrackingI3D
#define GLEE_C_DEFINED_wglQueryFrameTrackingI3D
BOOL __stdcall GLee_Lazy_wglQueryFrameTrackingI3D(DWORD * pFrameCount, DWORD * pMissedFrames, float * pLastMissedUsage) {if (GLeeInit()) return wglQueryFrameTrackingI3D(pFrameCount, pMissedFrames, pLastMissedUsage); return (BOOL)0;}
GLEEPFNWGLQUERYFRAMETRACKINGI3DPROC GLeeFuncPtr_wglQueryFrameTrackingI3D=GLee_Lazy_wglQueryFrameTrackingI3D;
#endif
#endif
/* WGL_NV_video_output */
#ifdef __GLEE_WGL_NV_video_output
#ifndef GLEE_C_DEFINED_wglGetVideoDeviceNV
#define GLEE_C_DEFINED_wglGetVideoDeviceNV
BOOL __stdcall GLee_Lazy_wglGetVideoDeviceNV(HDC hDC, int numDevices, HPVIDEODEV * hVideoDevice) {if (GLeeInit()) return wglGetVideoDeviceNV(hDC, numDevices, hVideoDevice); return (BOOL)0;}
GLEEPFNWGLGETVIDEODEVICENVPROC GLeeFuncPtr_wglGetVideoDeviceNV=GLee_Lazy_wglGetVideoDeviceNV;
#endif
#ifndef GLEE_C_DEFINED_wglReleaseVideoDeviceNV
#define GLEE_C_DEFINED_wglReleaseVideoDeviceNV
BOOL __stdcall GLee_Lazy_wglReleaseVideoDeviceNV(HPVIDEODEV hVideoDevice) {if (GLeeInit()) return wglReleaseVideoDeviceNV(hVideoDevice); return (BOOL)0;}
GLEEPFNWGLRELEASEVIDEODEVICENVPROC GLeeFuncPtr_wglReleaseVideoDeviceNV=GLee_Lazy_wglReleaseVideoDeviceNV;
#endif
#ifndef GLEE_C_DEFINED_wglBindVideoImageNV
#define GLEE_C_DEFINED_wglBindVideoImageNV
BOOL __stdcall GLee_Lazy_wglBindVideoImageNV(HPVIDEODEV hVideoDevice, HPBUFFERARB hPbuffer, int iVideoBuffer) {if (GLeeInit()) return wglBindVideoImageNV(hVideoDevice, hPbuffer, iVideoBuffer); return (BOOL)0;}
GLEEPFNWGLBINDVIDEOIMAGENVPROC GLeeFuncPtr_wglBindVideoImageNV=GLee_Lazy_wglBindVideoImageNV;
#endif
#ifndef GLEE_C_DEFINED_wglReleaseVideoImageNV
#define GLEE_C_DEFINED_wglReleaseVideoImageNV
BOOL __stdcall GLee_Lazy_wglReleaseVideoImageNV(HPBUFFERARB hPbuffer, int iVideoBuffer) {if (GLeeInit()) return wglReleaseVideoImageNV(hPbuffer, iVideoBuffer); return (BOOL)0;}
GLEEPFNWGLRELEASEVIDEOIMAGENVPROC GLeeFuncPtr_wglReleaseVideoImageNV=GLee_Lazy_wglReleaseVideoImageNV;
#endif
#ifndef GLEE_C_DEFINED_wglSendPbufferToVideoNV
#define GLEE_C_DEFINED_wglSendPbufferToVideoNV
BOOL __stdcall GLee_Lazy_wglSendPbufferToVideoNV(HPBUFFERARB hPbuffer, int iBufferType, unsigned long * pulCounterPbuffer, BOOL bBlock) {if (GLeeInit()) return wglSendPbufferToVideoNV(hPbuffer, iBufferType, pulCounterPbuffer, bBlock); return (BOOL)0;}
GLEEPFNWGLSENDPBUFFERTOVIDEONVPROC GLeeFuncPtr_wglSendPbufferToVideoNV=GLee_Lazy_wglSendPbufferToVideoNV;
#endif
#ifndef GLEE_C_DEFINED_wglGetVideoInfoNV
#define GLEE_C_DEFINED_wglGetVideoInfoNV
BOOL __stdcall GLee_Lazy_wglGetVideoInfoNV(HPVIDEODEV hpVideoDevice, unsigned long * pulCounterOutputPbuffer, unsigned long * pulCounterOutputVideo) {if (GLeeInit()) return wglGetVideoInfoNV(hpVideoDevice, pulCounterOutputPbuffer, pulCounterOutputVideo); return (BOOL)0;}
GLEEPFNWGLGETVIDEOINFONVPROC GLeeFuncPtr_wglGetVideoInfoNV=GLee_Lazy_wglGetVideoInfoNV;
#endif
#endif
#elif defined(__APPLE__) || defined(__APPLE_CC__)
#else /* GLX */
/* Extension querying variables */
GLboolean _GLEE_GLX_VERSION_1_3 = GL_FALSE;
GLboolean _GLEE_GLX_VERSION_1_4 = GL_FALSE;
GLboolean _GLEE_GLX_ARB_multisample = GL_FALSE;
GLboolean _GLEE_GLX_ARB_fbconfig_float = GL_FALSE;
GLboolean _GLEE_GLX_ARB_create_context = GL_FALSE;
GLboolean _GLEE_GLX_SGIS_multisample = GL_FALSE;
GLboolean _GLEE_GLX_EXT_visual_info = GL_FALSE;
GLboolean _GLEE_GLX_SGI_swap_control = GL_FALSE;
GLboolean _GLEE_GLX_SGI_video_sync = GL_FALSE;
GLboolean _GLEE_GLX_SGI_make_current_read = GL_FALSE;
GLboolean _GLEE_GLX_EXT_visual_rating = GL_FALSE;
GLboolean _GLEE_GLX_EXT_import_context = GL_FALSE;
GLboolean _GLEE_GLX_SGIX_fbconfig = GL_FALSE;
GLboolean _GLEE_GLX_SGIX_pbuffer = GL_FALSE;
GLboolean _GLEE_GLX_SGI_cushion = GL_FALSE;
GLboolean _GLEE_GLX_SGIX_video_resize = GL_FALSE;
GLboolean _GLEE_GLX_SGIX_swap_group = GL_FALSE;
GLboolean _GLEE_GLX_SGIX_swap_barrier = GL_FALSE;
GLboolean _GLEE_GLX_SGIS_blended_overlay = GL_FALSE;
GLboolean _GLEE_GLX_SGIS_shared_multisample = GL_FALSE;
GLboolean _GLEE_GLX_SUN_get_transparent_index = GL_FALSE;
GLboolean _GLEE_GLX_3DFX_multisample = GL_FALSE;
GLboolean _GLEE_GLX_MESA_copy_sub_buffer = GL_FALSE;
GLboolean _GLEE_GLX_MESA_pixmap_colormap = GL_FALSE;
GLboolean _GLEE_GLX_MESA_release_buffers = GL_FALSE;
GLboolean _GLEE_GLX_MESA_set_3dfx_mode = GL_FALSE;
GLboolean _GLEE_GLX_SGIX_visual_select_group = GL_FALSE;
GLboolean _GLEE_GLX_OML_swap_method = GL_FALSE;
GLboolean _GLEE_GLX_OML_sync_control = GL_FALSE;
GLboolean _GLEE_GLX_NV_float_buffer = GL_FALSE;
GLboolean _GLEE_GLX_SGIX_hyperpipe = GL_FALSE;
GLboolean _GLEE_GLX_MESA_agp_offset = GL_FALSE;
GLboolean _GLEE_GLX_EXT_fbconfig_packed_float = GL_FALSE;
GLboolean _GLEE_GLX_EXT_framebuffer_sRGB = GL_FALSE;
GLboolean _GLEE_GLX_EXT_texture_from_pixmap = GL_FALSE;
GLboolean _GLEE_GLX_NV_present_video = GL_FALSE;
GLboolean _GLEE_GLX_NV_video_out = GL_FALSE;
GLboolean _GLEE_GLX_NV_swap_group = GL_FALSE;
GLboolean _GLEE_GLX_EXT_scene_marker = GL_FALSE;
GLboolean _GLEE_GLX_NV_video_output = GL_FALSE;
/* GLX Extension names */
char __GLeeGLXExtensionNames[40][30]={
"GLX_VERSION_1_3",
"GLX_VERSION_1_4",
"GLX_ARB_multisample",
"GLX_ARB_fbconfig_float",
"GLX_ARB_create_context",
"GLX_SGIS_multisample",
"GLX_EXT_visual_info",
"GLX_SGI_swap_control",
"GLX_SGI_video_sync",
"GLX_SGI_make_current_read",
"GLX_EXT_visual_rating",
"GLX_EXT_import_context",
"GLX_SGIX_fbconfig",
"GLX_SGIX_pbuffer",
"GLX_SGI_cushion",
"GLX_SGIX_video_resize",
"GLX_SGIX_swap_group",
"GLX_SGIX_swap_barrier",
"GLX_SGIS_blended_overlay",
"GLX_SGIS_shared_multisample",
"GLX_SUN_get_transparent_index",
"GLX_3DFX_multisample",
"GLX_MESA_copy_sub_buffer",
"GLX_MESA_pixmap_colormap",
"GLX_MESA_release_buffers",
"GLX_MESA_set_3dfx_mode",
"GLX_SGIX_visual_select_group",
"GLX_OML_swap_method",
"GLX_OML_sync_control",
"GLX_NV_float_buffer",
"GLX_SGIX_hyperpipe",
"GLX_MESA_agp_offset",
"GLX_EXT_fbconfig_packed_float",
"GLX_EXT_framebuffer_sRGB",
"GLX_EXT_texture_from_pixmap",
"GLX_NV_present_video",
"GLX_NV_video_out",
"GLX_NV_swap_group",
"GLX_EXT_scene_marker",
"GLX_NV_video_output"
};
int __GLeeGLXNumExtensions=40;
/* GLX_VERSION_1_3 */
#ifdef __GLEE_GLX_VERSION_1_3
#ifndef GLEE_C_DEFINED_glXGetFBConfigs
#define GLEE_C_DEFINED_glXGetFBConfigs
GLXFBConfig * __stdcall GLee_Lazy_glXGetFBConfigs(Display * dpy, int screen, int * nelements) {if (GLeeInit()) return glXGetFBConfigs(dpy, screen, nelements); return (GLXFBConfig *)0;}
GLEEPFNGLXGETFBCONFIGSPROC GLeeFuncPtr_glXGetFBConfigs=GLee_Lazy_glXGetFBConfigs;
#endif
#ifndef GLEE_C_DEFINED_glXChooseFBConfig
#define GLEE_C_DEFINED_glXChooseFBConfig
GLXFBConfig * __stdcall GLee_Lazy_glXChooseFBConfig(Display * dpy, int screen, const int * attrib_list, int * nelements) {if (GLeeInit()) return glXChooseFBConfig(dpy, screen, attrib_list, nelements); return (GLXFBConfig *)0;}
GLEEPFNGLXCHOOSEFBCONFIGPROC GLeeFuncPtr_glXChooseFBConfig=GLee_Lazy_glXChooseFBConfig;
#endif
#ifndef GLEE_C_DEFINED_glXGetFBConfigAttrib
#define GLEE_C_DEFINED_glXGetFBConfigAttrib
int __stdcall GLee_Lazy_glXGetFBConfigAttrib(Display * dpy, GLXFBConfig config, int attribute, int * value) {if (GLeeInit()) return glXGetFBConfigAttrib(dpy, config, attribute, value); return (int)0;}
GLEEPFNGLXGETFBCONFIGATTRIBPROC GLeeFuncPtr_glXGetFBConfigAttrib=GLee_Lazy_glXGetFBConfigAttrib;
#endif
#ifndef GLEE_C_DEFINED_glXGetVisualFromFBConfig
#define GLEE_C_DEFINED_glXGetVisualFromFBConfig
XVisualInfo * __stdcall GLee_Lazy_glXGetVisualFromFBConfig(Display * dpy, GLXFBConfig config) {if (GLeeInit()) return glXGetVisualFromFBConfig(dpy, config); return (XVisualInfo *)0;}
GLEEPFNGLXGETVISUALFROMFBCONFIGPROC GLeeFuncPtr_glXGetVisualFromFBConfig=GLee_Lazy_glXGetVisualFromFBConfig;
#endif
#ifndef GLEE_C_DEFINED_glXCreateWindow
#define GLEE_C_DEFINED_glXCreateWindow
GLXWindow __stdcall GLee_Lazy_glXCreateWindow(Display * dpy, GLXFBConfig config, Window win, const int * attrib_list) {if (GLeeInit()) return glXCreateWindow(dpy, config, win, attrib_list); return (GLXWindow)0;}
GLEEPFNGLXCREATEWINDOWPROC GLeeFuncPtr_glXCreateWindow=GLee_Lazy_glXCreateWindow;
#endif
#ifndef GLEE_C_DEFINED_glXDestroyWindow
#define GLEE_C_DEFINED_glXDestroyWindow
void __stdcall GLee_Lazy_glXDestroyWindow(Display * dpy, GLXWindow win) {if (GLeeInit()) glXDestroyWindow(dpy, win);}
GLEEPFNGLXDESTROYWINDOWPROC GLeeFuncPtr_glXDestroyWindow=GLee_Lazy_glXDestroyWindow;
#endif
#ifndef GLEE_C_DEFINED_glXCreatePixmap
#define GLEE_C_DEFINED_glXCreatePixmap
GLXPixmap __stdcall GLee_Lazy_glXCreatePixmap(Display * dpy, GLXFBConfig config, Pixmap pixmap, const int * attrib_list) {if (GLeeInit()) return glXCreatePixmap(dpy, config, pixmap, attrib_list); return (GLXPixmap)0;}
GLEEPFNGLXCREATEPIXMAPPROC GLeeFuncPtr_glXCreatePixmap=GLee_Lazy_glXCreatePixmap;
#endif
#ifndef GLEE_C_DEFINED_glXDestroyPixmap
#define GLEE_C_DEFINED_glXDestroyPixmap
void __stdcall GLee_Lazy_glXDestroyPixmap(Display * dpy, GLXPixmap pixmap) {if (GLeeInit()) glXDestroyPixmap(dpy, pixmap);}
GLEEPFNGLXDESTROYPIXMAPPROC GLeeFuncPtr_glXDestroyPixmap=GLee_Lazy_glXDestroyPixmap;
#endif
#ifndef GLEE_C_DEFINED_glXCreatePbuffer
#define GLEE_C_DEFINED_glXCreatePbuffer
GLXPbuffer __stdcall GLee_Lazy_glXCreatePbuffer(Display * dpy, GLXFBConfig config, const int * attrib_list) {if (GLeeInit()) return glXCreatePbuffer(dpy, config, attrib_list); return (GLXPbuffer)0;}
GLEEPFNGLXCREATEPBUFFERPROC GLeeFuncPtr_glXCreatePbuffer=GLee_Lazy_glXCreatePbuffer;
#endif
#ifndef GLEE_C_DEFINED_glXDestroyPbuffer
#define GLEE_C_DEFINED_glXDestroyPbuffer
void __stdcall GLee_Lazy_glXDestroyPbuffer(Display * dpy, GLXPbuffer pbuf) {if (GLeeInit()) glXDestroyPbuffer(dpy, pbuf);}
GLEEPFNGLXDESTROYPBUFFERPROC GLeeFuncPtr_glXDestroyPbuffer=GLee_Lazy_glXDestroyPbuffer;
#endif
#ifndef GLEE_C_DEFINED_glXQueryDrawable
#define GLEE_C_DEFINED_glXQueryDrawable
void __stdcall GLee_Lazy_glXQueryDrawable(Display * dpy, GLXDrawable draw, int attribute, unsigned int * value) {if (GLeeInit()) glXQueryDrawable(dpy, draw, attribute, value);}
GLEEPFNGLXQUERYDRAWABLEPROC GLeeFuncPtr_glXQueryDrawable=GLee_Lazy_glXQueryDrawable;
#endif
#ifndef GLEE_C_DEFINED_glXCreateNewContext
#define GLEE_C_DEFINED_glXCreateNewContext
GLXContext __stdcall GLee_Lazy_glXCreateNewContext(Display * dpy, GLXFBConfig config, int render_type, GLXContext share_list, Bool direct) {if (GLeeInit()) return glXCreateNewContext(dpy, config, render_type, share_list, direct); return (GLXContext)0;}
GLEEPFNGLXCREATENEWCONTEXTPROC GLeeFuncPtr_glXCreateNewContext=GLee_Lazy_glXCreateNewContext;
#endif
#ifndef GLEE_C_DEFINED_glXMakeContextCurrent
#define GLEE_C_DEFINED_glXMakeContextCurrent
Bool __stdcall GLee_Lazy_glXMakeContextCurrent(Display * dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx) {if (GLeeInit()) return glXMakeContextCurrent(dpy, draw, read, ctx); return (Bool)0;}
GLEEPFNGLXMAKECONTEXTCURRENTPROC GLeeFuncPtr_glXMakeContextCurrent=GLee_Lazy_glXMakeContextCurrent;
#endif
#ifndef GLEE_C_DEFINED_glXGetCurrentReadDrawable
#define GLEE_C_DEFINED_glXGetCurrentReadDrawable
GLXDrawable __stdcall GLee_Lazy_glXGetCurrentReadDrawable(void) {if (GLeeInit()) return glXGetCurrentReadDrawable(); return (GLXDrawable)0;}
GLEEPFNGLXGETCURRENTREADDRAWABLEPROC GLeeFuncPtr_glXGetCurrentReadDrawable=GLee_Lazy_glXGetCurrentReadDrawable;
#endif
#ifndef GLEE_C_DEFINED_glXGetCurrentDisplay
#define GLEE_C_DEFINED_glXGetCurrentDisplay
Display * __stdcall GLee_Lazy_glXGetCurrentDisplay(void) {if (GLeeInit()) return glXGetCurrentDisplay(); return (Display *)0;}
GLEEPFNGLXGETCURRENTDISPLAYPROC GLeeFuncPtr_glXGetCurrentDisplay=GLee_Lazy_glXGetCurrentDisplay;
#endif
#ifndef GLEE_C_DEFINED_glXQueryContext
#define GLEE_C_DEFINED_glXQueryContext
int __stdcall GLee_Lazy_glXQueryContext(Display * dpy, GLXContext ctx, int attribute, int * value) {if (GLeeInit()) return glXQueryContext(dpy, ctx, attribute, value); return (int)0;}
GLEEPFNGLXQUERYCONTEXTPROC GLeeFuncPtr_glXQueryContext=GLee_Lazy_glXQueryContext;
#endif
#ifndef GLEE_C_DEFINED_glXSelectEvent
#define GLEE_C_DEFINED_glXSelectEvent
void __stdcall GLee_Lazy_glXSelectEvent(Display * dpy, GLXDrawable draw, unsigned long event_mask) {if (GLeeInit()) glXSelectEvent(dpy, draw, event_mask);}
GLEEPFNGLXSELECTEVENTPROC GLeeFuncPtr_glXSelectEvent=GLee_Lazy_glXSelectEvent;
#endif
#ifndef GLEE_C_DEFINED_glXGetSelectedEvent
#define GLEE_C_DEFINED_glXGetSelectedEvent
void __stdcall GLee_Lazy_glXGetSelectedEvent(Display * dpy, GLXDrawable draw, unsigned long * event_mask) {if (GLeeInit()) glXGetSelectedEvent(dpy, draw, event_mask);}
GLEEPFNGLXGETSELECTEDEVENTPROC GLeeFuncPtr_glXGetSelectedEvent=GLee_Lazy_glXGetSelectedEvent;
#endif
#endif
/* GLX_VERSION_1_4 */
#ifdef __GLEE_GLX_VERSION_1_4
#ifndef GLEE_C_DEFINED_glXGetProcAddress
#define GLEE_C_DEFINED_glXGetProcAddress
__GLXextFuncPtr __stdcall GLee_Lazy_glXGetProcAddress(const GLubyte * procName) {if (GLeeInit()) return glXGetProcAddress(procName); return (__GLXextFuncPtr)0;}
GLEEPFNGLXGETPROCADDRESSPROC GLeeFuncPtr_glXGetProcAddress=GLee_Lazy_glXGetProcAddress;
#endif
#endif
/* GLX_ARB_multisample */
#ifdef __GLEE_GLX_ARB_multisample
#endif
/* GLX_ARB_fbconfig_float */
#ifdef __GLEE_GLX_ARB_fbconfig_float
#endif
/* GLX_ARB_create_context */
#ifdef __GLEE_GLX_ARB_create_context
#ifndef GLEE_C_DEFINED_glXCreateContextAttribsARB
#define GLEE_C_DEFINED_glXCreateContextAttribsARB
GLXContext __stdcall GLee_Lazy_glXCreateContextAttribsARB(Display * dpy, GLXFBConfig config, GLXContext share_context, Bool direct, const int * attrib_list) {if (GLeeInit()) return glXCreateContextAttribsARB(dpy, config, share_context, direct, attrib_list); return (GLXContext)0;}
GLEEPFNGLXCREATECONTEXTATTRIBSARBPROC GLeeFuncPtr_glXCreateContextAttribsARB=GLee_Lazy_glXCreateContextAttribsARB;
#endif
#endif
/* GLX_SGIS_multisample */
#ifdef __GLEE_GLX_SGIS_multisample
#endif
/* GLX_EXT_visual_info */
#ifdef __GLEE_GLX_EXT_visual_info
#endif
/* GLX_SGI_swap_control */
#ifdef __GLEE_GLX_SGI_swap_control
#ifndef GLEE_C_DEFINED_glXSwapIntervalSGI
#define GLEE_C_DEFINED_glXSwapIntervalSGI
int __stdcall GLee_Lazy_glXSwapIntervalSGI(int interval) {if (GLeeInit()) return glXSwapIntervalSGI(interval); return (int)0;}
GLEEPFNGLXSWAPINTERVALSGIPROC GLeeFuncPtr_glXSwapIntervalSGI=GLee_Lazy_glXSwapIntervalSGI;
#endif
#endif
/* GLX_SGI_video_sync */
#ifdef __GLEE_GLX_SGI_video_sync
#ifndef GLEE_C_DEFINED_glXGetVideoSyncSGI
#define GLEE_C_DEFINED_glXGetVideoSyncSGI
int __stdcall GLee_Lazy_glXGetVideoSyncSGI(unsigned int * count) {if (GLeeInit()) return glXGetVideoSyncSGI(count); return (int)0;}
GLEEPFNGLXGETVIDEOSYNCSGIPROC GLeeFuncPtr_glXGetVideoSyncSGI=GLee_Lazy_glXGetVideoSyncSGI;
#endif
#ifndef GLEE_C_DEFINED_glXWaitVideoSyncSGI
#define GLEE_C_DEFINED_glXWaitVideoSyncSGI
int __stdcall GLee_Lazy_glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int * count) {if (GLeeInit()) return glXWaitVideoSyncSGI(divisor, remainder, count); return (int)0;}
GLEEPFNGLXWAITVIDEOSYNCSGIPROC GLeeFuncPtr_glXWaitVideoSyncSGI=GLee_Lazy_glXWaitVideoSyncSGI;
#endif
#endif
/* GLX_SGI_make_current_read */
#ifdef __GLEE_GLX_SGI_make_current_read
#ifndef GLEE_C_DEFINED_glXMakeCurrentReadSGI
#define GLEE_C_DEFINED_glXMakeCurrentReadSGI
Bool __stdcall GLee_Lazy_glXMakeCurrentReadSGI(Display * dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx) {if (GLeeInit()) return glXMakeCurrentReadSGI(dpy, draw, read, ctx); return (Bool)0;}
GLEEPFNGLXMAKECURRENTREADSGIPROC GLeeFuncPtr_glXMakeCurrentReadSGI=GLee_Lazy_glXMakeCurrentReadSGI;
#endif
#ifndef GLEE_C_DEFINED_glXGetCurrentReadDrawableSGI
#define GLEE_C_DEFINED_glXGetCurrentReadDrawableSGI
GLXDrawable __stdcall GLee_Lazy_glXGetCurrentReadDrawableSGI(void) {if (GLeeInit()) return glXGetCurrentReadDrawableSGI(); return (GLXDrawable)0;}
GLEEPFNGLXGETCURRENTREADDRAWABLESGIPROC GLeeFuncPtr_glXGetCurrentReadDrawableSGI=GLee_Lazy_glXGetCurrentReadDrawableSGI;
#endif
#endif
/* GLX_EXT_visual_rating */
#ifdef __GLEE_GLX_EXT_visual_rating
#endif
/* GLX_EXT_import_context */
#ifdef __GLEE_GLX_EXT_import_context
#ifndef GLEE_C_DEFINED_glXGetCurrentDisplayEXT
#define GLEE_C_DEFINED_glXGetCurrentDisplayEXT
Display * __stdcall GLee_Lazy_glXGetCurrentDisplayEXT(void) {if (GLeeInit()) return glXGetCurrentDisplayEXT(); return (Display *)0;}
GLEEPFNGLXGETCURRENTDISPLAYEXTPROC GLeeFuncPtr_glXGetCurrentDisplayEXT=GLee_Lazy_glXGetCurrentDisplayEXT;
#endif
#ifndef GLEE_C_DEFINED_glXQueryContextInfoEXT
#define GLEE_C_DEFINED_glXQueryContextInfoEXT
int __stdcall GLee_Lazy_glXQueryContextInfoEXT(Display * dpy, GLXContext context, int attribute, int * value) {if (GLeeInit()) return glXQueryContextInfoEXT(dpy, context, attribute, value); return (int)0;}
GLEEPFNGLXQUERYCONTEXTINFOEXTPROC GLeeFuncPtr_glXQueryContextInfoEXT=GLee_Lazy_glXQueryContextInfoEXT;
#endif
#ifndef GLEE_C_DEFINED_glXGetContextIDEXT
#define GLEE_C_DEFINED_glXGetContextIDEXT
GLXContextID __stdcall GLee_Lazy_glXGetContextIDEXT(const GLXContext context) {if (GLeeInit()) return glXGetContextIDEXT(context); return (GLXContextID)0;}
GLEEPFNGLXGETCONTEXTIDEXTPROC GLeeFuncPtr_glXGetContextIDEXT=GLee_Lazy_glXGetContextIDEXT;
#endif
#ifndef GLEE_C_DEFINED_glXImportContextEXT
#define GLEE_C_DEFINED_glXImportContextEXT
GLXContext __stdcall GLee_Lazy_glXImportContextEXT(Display * dpy, GLXContextID contextID) {if (GLeeInit()) return glXImportContextEXT(dpy, contextID); return (GLXContext)0;}
GLEEPFNGLXIMPORTCONTEXTEXTPROC GLeeFuncPtr_glXImportContextEXT=GLee_Lazy_glXImportContextEXT;
#endif
#ifndef GLEE_C_DEFINED_glXFreeContextEXT
#define GLEE_C_DEFINED_glXFreeContextEXT
void __stdcall GLee_Lazy_glXFreeContextEXT(Display * dpy, GLXContext context) {if (GLeeInit()) glXFreeContextEXT(dpy, context);}
GLEEPFNGLXFREECONTEXTEXTPROC GLeeFuncPtr_glXFreeContextEXT=GLee_Lazy_glXFreeContextEXT;
#endif
#endif
/* GLX_SGIX_fbconfig */
#ifdef __GLEE_GLX_SGIX_fbconfig
#ifndef GLEE_C_DEFINED_glXGetFBConfigAttribSGIX
#define GLEE_C_DEFINED_glXGetFBConfigAttribSGIX
int __stdcall GLee_Lazy_glXGetFBConfigAttribSGIX(Display * dpy, GLXFBConfigSGIX config, int attribute, int * value) {if (GLeeInit()) return glXGetFBConfigAttribSGIX(dpy, config, attribute, value); return (int)0;}
GLEEPFNGLXGETFBCONFIGATTRIBSGIXPROC GLeeFuncPtr_glXGetFBConfigAttribSGIX=GLee_Lazy_glXGetFBConfigAttribSGIX;
#endif
#ifndef GLEE_C_DEFINED_glXChooseFBConfigSGIX
#define GLEE_C_DEFINED_glXChooseFBConfigSGIX
GLXFBConfigSGIX * __stdcall GLee_Lazy_glXChooseFBConfigSGIX(Display * dpy, int screen, int * attrib_list, int * nelements) {if (GLeeInit()) return glXChooseFBConfigSGIX(dpy, screen, attrib_list, nelements); return (GLXFBConfigSGIX *)0;}
GLEEPFNGLXCHOOSEFBCONFIGSGIXPROC GLeeFuncPtr_glXChooseFBConfigSGIX=GLee_Lazy_glXChooseFBConfigSGIX;
#endif
#ifndef GLEE_C_DEFINED_glXCreateGLXPixmapWithConfigSGIX
#define GLEE_C_DEFINED_glXCreateGLXPixmapWithConfigSGIX
GLXPixmap __stdcall GLee_Lazy_glXCreateGLXPixmapWithConfigSGIX(Display * dpy, GLXFBConfigSGIX config, Pixmap pixmap) {if (GLeeInit()) return glXCreateGLXPixmapWithConfigSGIX(dpy, config, pixmap); return (GLXPixmap)0;}
GLEEPFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC GLeeFuncPtr_glXCreateGLXPixmapWithConfigSGIX=GLee_Lazy_glXCreateGLXPixmapWithConfigSGIX;
#endif
#ifndef GLEE_C_DEFINED_glXCreateContextWithConfigSGIX
#define GLEE_C_DEFINED_glXCreateContextWithConfigSGIX
GLXContext __stdcall GLee_Lazy_glXCreateContextWithConfigSGIX(Display * dpy, GLXFBConfigSGIX config, int render_type, GLXContext share_list, Bool direct) {if (GLeeInit()) return glXCreateContextWithConfigSGIX(dpy, config, render_type, share_list, direct); return (GLXContext)0;}
GLEEPFNGLXCREATECONTEXTWITHCONFIGSGIXPROC GLeeFuncPtr_glXCreateContextWithConfigSGIX=GLee_Lazy_glXCreateContextWithConfigSGIX;
#endif
#ifndef GLEE_C_DEFINED_glXGetVisualFromFBConfigSGIX
#define GLEE_C_DEFINED_glXGetVisualFromFBConfigSGIX
XVisualInfo * __stdcall GLee_Lazy_glXGetVisualFromFBConfigSGIX(Display * dpy, GLXFBConfigSGIX config) {if (GLeeInit()) return glXGetVisualFromFBConfigSGIX(dpy, config); return (XVisualInfo *)0;}
GLEEPFNGLXGETVISUALFROMFBCONFIGSGIXPROC GLeeFuncPtr_glXGetVisualFromFBConfigSGIX=GLee_Lazy_glXGetVisualFromFBConfigSGIX;
#endif
#ifndef GLEE_C_DEFINED_glXGetFBConfigFromVisualSGIX
#define GLEE_C_DEFINED_glXGetFBConfigFromVisualSGIX
GLXFBConfigSGIX __stdcall GLee_Lazy_glXGetFBConfigFromVisualSGIX(Display * dpy, XVisualInfo * vis) {if (GLeeInit()) return glXGetFBConfigFromVisualSGIX(dpy, vis); return (GLXFBConfigSGIX)0;}
GLEEPFNGLXGETFBCONFIGFROMVISUALSGIXPROC GLeeFuncPtr_glXGetFBConfigFromVisualSGIX=GLee_Lazy_glXGetFBConfigFromVisualSGIX;
#endif
#endif
/* GLX_SGIX_pbuffer */
#ifdef __GLEE_GLX_SGIX_pbuffer
#ifndef GLEE_C_DEFINED_glXCreateGLXPbufferSGIX
#define GLEE_C_DEFINED_glXCreateGLXPbufferSGIX
GLXPbufferSGIX __stdcall GLee_Lazy_glXCreateGLXPbufferSGIX(Display * dpy, GLXFBConfigSGIX config, unsigned int width, unsigned int height, int * attrib_list) {if (GLeeInit()) return glXCreateGLXPbufferSGIX(dpy, config, width, height, attrib_list); return (GLXPbufferSGIX)0;}
GLEEPFNGLXCREATEGLXPBUFFERSGIXPROC GLeeFuncPtr_glXCreateGLXPbufferSGIX=GLee_Lazy_glXCreateGLXPbufferSGIX;
#endif
#ifndef GLEE_C_DEFINED_glXDestroyGLXPbufferSGIX
#define GLEE_C_DEFINED_glXDestroyGLXPbufferSGIX
void __stdcall GLee_Lazy_glXDestroyGLXPbufferSGIX(Display * dpy, GLXPbufferSGIX pbuf) {if (GLeeInit()) glXDestroyGLXPbufferSGIX(dpy, pbuf);}
GLEEPFNGLXDESTROYGLXPBUFFERSGIXPROC GLeeFuncPtr_glXDestroyGLXPbufferSGIX=GLee_Lazy_glXDestroyGLXPbufferSGIX;
#endif
#ifndef GLEE_C_DEFINED_glXQueryGLXPbufferSGIX
#define GLEE_C_DEFINED_glXQueryGLXPbufferSGIX
int __stdcall GLee_Lazy_glXQueryGLXPbufferSGIX(Display * dpy, GLXPbufferSGIX pbuf, int attribute, unsigned int * value) {if (GLeeInit()) return glXQueryGLXPbufferSGIX(dpy, pbuf, attribute, value); return (int)0;}
GLEEPFNGLXQUERYGLXPBUFFERSGIXPROC GLeeFuncPtr_glXQueryGLXPbufferSGIX=GLee_Lazy_glXQueryGLXPbufferSGIX;
#endif
#ifndef GLEE_C_DEFINED_glXSelectEventSGIX
#define GLEE_C_DEFINED_glXSelectEventSGIX
void __stdcall GLee_Lazy_glXSelectEventSGIX(Display * dpy, GLXDrawable drawable, unsigned long mask) {if (GLeeInit()) glXSelectEventSGIX(dpy, drawable, mask);}
GLEEPFNGLXSELECTEVENTSGIXPROC GLeeFuncPtr_glXSelectEventSGIX=GLee_Lazy_glXSelectEventSGIX;
#endif
#ifndef GLEE_C_DEFINED_glXGetSelectedEventSGIX
#define GLEE_C_DEFINED_glXGetSelectedEventSGIX
void __stdcall GLee_Lazy_glXGetSelectedEventSGIX(Display * dpy, GLXDrawable drawable, unsigned long * mask) {if (GLeeInit()) glXGetSelectedEventSGIX(dpy, drawable, mask);}
GLEEPFNGLXGETSELECTEDEVENTSGIXPROC GLeeFuncPtr_glXGetSelectedEventSGIX=GLee_Lazy_glXGetSelectedEventSGIX;
#endif
#endif
/* GLX_SGI_cushion */
#ifdef __GLEE_GLX_SGI_cushion
#ifndef GLEE_C_DEFINED_glXCushionSGI
#define GLEE_C_DEFINED_glXCushionSGI
void __stdcall GLee_Lazy_glXCushionSGI(Display * dpy, Window window, float cushion) {if (GLeeInit()) glXCushionSGI(dpy, window, cushion);}
GLEEPFNGLXCUSHIONSGIPROC GLeeFuncPtr_glXCushionSGI=GLee_Lazy_glXCushionSGI;
#endif
#endif
/* GLX_SGIX_video_resize */
#ifdef __GLEE_GLX_SGIX_video_resize
#ifndef GLEE_C_DEFINED_glXBindChannelToWindowSGIX
#define GLEE_C_DEFINED_glXBindChannelToWindowSGIX
int __stdcall GLee_Lazy_glXBindChannelToWindowSGIX(Display * display, int screen, int channel, Window window) {if (GLeeInit()) return glXBindChannelToWindowSGIX(display, screen, channel, window); return (int)0;}
GLEEPFNGLXBINDCHANNELTOWINDOWSGIXPROC GLeeFuncPtr_glXBindChannelToWindowSGIX=GLee_Lazy_glXBindChannelToWindowSGIX;
#endif
#ifndef GLEE_C_DEFINED_glXChannelRectSGIX
#define GLEE_C_DEFINED_glXChannelRectSGIX
int __stdcall GLee_Lazy_glXChannelRectSGIX(Display * display, int screen, int channel, int x, int y, int w, int h) {if (GLeeInit()) return glXChannelRectSGIX(display, screen, channel, x, y, w, h); return (int)0;}
GLEEPFNGLXCHANNELRECTSGIXPROC GLeeFuncPtr_glXChannelRectSGIX=GLee_Lazy_glXChannelRectSGIX;
#endif
#ifndef GLEE_C_DEFINED_glXQueryChannelRectSGIX
#define GLEE_C_DEFINED_glXQueryChannelRectSGIX
int __stdcall GLee_Lazy_glXQueryChannelRectSGIX(Display * display, int screen, int channel, int * dx, int * dy, int * dw, int * dh) {if (GLeeInit()) return glXQueryChannelRectSGIX(display, screen, channel, dx, dy, dw, dh); return (int)0;}
GLEEPFNGLXQUERYCHANNELRECTSGIXPROC GLeeFuncPtr_glXQueryChannelRectSGIX=GLee_Lazy_glXQueryChannelRectSGIX;
#endif
#ifndef GLEE_C_DEFINED_glXQueryChannelDeltasSGIX
#define GLEE_C_DEFINED_glXQueryChannelDeltasSGIX
int __stdcall GLee_Lazy_glXQueryChannelDeltasSGIX(Display * display, int screen, int channel, int * x, int * y, int * w, int * h) {if (GLeeInit()) return glXQueryChannelDeltasSGIX(display, screen, channel, x, y, w, h); return (int)0;}
GLEEPFNGLXQUERYCHANNELDELTASSGIXPROC GLeeFuncPtr_glXQueryChannelDeltasSGIX=GLee_Lazy_glXQueryChannelDeltasSGIX;
#endif
#ifndef GLEE_C_DEFINED_glXChannelRectSyncSGIX
#define GLEE_C_DEFINED_glXChannelRectSyncSGIX
int __stdcall GLee_Lazy_glXChannelRectSyncSGIX(Display * display, int screen, int channel, GLenum synctype) {if (GLeeInit()) return glXChannelRectSyncSGIX(display, screen, channel, synctype); return (int)0;}
GLEEPFNGLXCHANNELRECTSYNCSGIXPROC GLeeFuncPtr_glXChannelRectSyncSGIX=GLee_Lazy_glXChannelRectSyncSGIX;
#endif
#endif
/* GLX_SGIX_swap_group */
#ifdef __GLEE_GLX_SGIX_swap_group
#ifndef GLEE_C_DEFINED_glXJoinSwapGroupSGIX
#define GLEE_C_DEFINED_glXJoinSwapGroupSGIX
void __stdcall GLee_Lazy_glXJoinSwapGroupSGIX(Display * dpy, GLXDrawable drawable, GLXDrawable member) {if (GLeeInit()) glXJoinSwapGroupSGIX(dpy, drawable, member);}
GLEEPFNGLXJOINSWAPGROUPSGIXPROC GLeeFuncPtr_glXJoinSwapGroupSGIX=GLee_Lazy_glXJoinSwapGroupSGIX;
#endif
#endif
/* GLX_SGIX_swap_barrier */
#ifdef __GLEE_GLX_SGIX_swap_barrier
#ifndef GLEE_C_DEFINED_glXBindSwapBarrierSGIX
#define GLEE_C_DEFINED_glXBindSwapBarrierSGIX
void __stdcall GLee_Lazy_glXBindSwapBarrierSGIX(Display * dpy, GLXDrawable drawable, int barrier) {if (GLeeInit()) glXBindSwapBarrierSGIX(dpy, drawable, barrier);}
GLEEPFNGLXBINDSWAPBARRIERSGIXPROC GLeeFuncPtr_glXBindSwapBarrierSGIX=GLee_Lazy_glXBindSwapBarrierSGIX;
#endif
#ifndef GLEE_C_DEFINED_glXQueryMaxSwapBarriersSGIX
#define GLEE_C_DEFINED_glXQueryMaxSwapBarriersSGIX
Bool __stdcall GLee_Lazy_glXQueryMaxSwapBarriersSGIX(Display * dpy, int screen, int * max) {if (GLeeInit()) return glXQueryMaxSwapBarriersSGIX(dpy, screen, max); return (Bool)0;}
GLEEPFNGLXQUERYMAXSWAPBARRIERSSGIXPROC GLeeFuncPtr_glXQueryMaxSwapBarriersSGIX=GLee_Lazy_glXQueryMaxSwapBarriersSGIX;
#endif
#endif
/* GLX_SGIS_blended_overlay */
#ifdef __GLEE_GLX_SGIS_blended_overlay
#endif
/* GLX_SGIS_shared_multisample */
#ifdef __GLEE_GLX_SGIS_shared_multisample
#endif
/* GLX_SUN_get_transparent_index */
#ifdef __GLEE_GLX_SUN_get_transparent_index
#ifndef GLEE_C_DEFINED_glXGetTransparentIndexSUN
#define GLEE_C_DEFINED_glXGetTransparentIndexSUN
Status __stdcall GLee_Lazy_glXGetTransparentIndexSUN(Display * dpy, Window overlay, Window underlay, long * pTransparentIndex) {if (GLeeInit()) return glXGetTransparentIndexSUN(dpy, overlay, underlay, pTransparentIndex); return (Status)0;}
GLEEPFNGLXGETTRANSPARENTINDEXSUNPROC GLeeFuncPtr_glXGetTransparentIndexSUN=GLee_Lazy_glXGetTransparentIndexSUN;
#endif
#endif
/* GLX_3DFX_multisample */
#ifdef __GLEE_GLX_3DFX_multisample
#endif
/* GLX_MESA_copy_sub_buffer */
#ifdef __GLEE_GLX_MESA_copy_sub_buffer
#ifndef GLEE_C_DEFINED_glXCopySubBufferMESA
#define GLEE_C_DEFINED_glXCopySubBufferMESA
void __stdcall GLee_Lazy_glXCopySubBufferMESA(Display * dpy, GLXDrawable drawable, int x, int y, int width, int height) {if (GLeeInit()) glXCopySubBufferMESA(dpy, drawable, x, y, width, height);}
GLEEPFNGLXCOPYSUBBUFFERMESAPROC GLeeFuncPtr_glXCopySubBufferMESA=GLee_Lazy_glXCopySubBufferMESA;
#endif
#endif
/* GLX_MESA_pixmap_colormap */
#ifdef __GLEE_GLX_MESA_pixmap_colormap
#ifndef GLEE_C_DEFINED_glXCreateGLXPixmapMESA
#define GLEE_C_DEFINED_glXCreateGLXPixmapMESA
GLXPixmap __stdcall GLee_Lazy_glXCreateGLXPixmapMESA(Display * dpy, XVisualInfo * visual, Pixmap pixmap, Colormap cmap) {if (GLeeInit()) return glXCreateGLXPixmapMESA(dpy, visual, pixmap, cmap); return (GLXPixmap)0;}
GLEEPFNGLXCREATEGLXPIXMAPMESAPROC GLeeFuncPtr_glXCreateGLXPixmapMESA=GLee_Lazy_glXCreateGLXPixmapMESA;
#endif
#endif
/* GLX_MESA_release_buffers */
#ifdef __GLEE_GLX_MESA_release_buffers
#ifndef GLEE_C_DEFINED_glXReleaseBuffersMESA
#define GLEE_C_DEFINED_glXReleaseBuffersMESA
Bool __stdcall GLee_Lazy_glXReleaseBuffersMESA(Display * dpy, GLXDrawable drawable) {if (GLeeInit()) return glXReleaseBuffersMESA(dpy, drawable); return (Bool)0;}
GLEEPFNGLXRELEASEBUFFERSMESAPROC GLeeFuncPtr_glXReleaseBuffersMESA=GLee_Lazy_glXReleaseBuffersMESA;
#endif
#endif
/* GLX_MESA_set_3dfx_mode */
#ifdef __GLEE_GLX_MESA_set_3dfx_mode
#ifndef GLEE_C_DEFINED_glXSet3DfxModeMESA
#define GLEE_C_DEFINED_glXSet3DfxModeMESA
Bool __stdcall GLee_Lazy_glXSet3DfxModeMESA(int mode) {if (GLeeInit()) return glXSet3DfxModeMESA(mode); return (Bool)0;}
GLEEPFNGLXSET3DFXMODEMESAPROC GLeeFuncPtr_glXSet3DfxModeMESA=GLee_Lazy_glXSet3DfxModeMESA;
#endif
#endif
/* GLX_SGIX_visual_select_group */
#ifdef __GLEE_GLX_SGIX_visual_select_group
#endif
/* GLX_OML_swap_method */
#ifdef __GLEE_GLX_OML_swap_method
#endif
/* GLX_OML_sync_control */
#ifdef __GLEE_GLX_OML_sync_control
#ifndef GLEE_C_DEFINED_glXGetSyncValuesOML
#define GLEE_C_DEFINED_glXGetSyncValuesOML
Bool __stdcall GLee_Lazy_glXGetSyncValuesOML(Display * dpy, GLXDrawable drawable, int64_t * ust, int64_t * msc, int64_t * sbc) {if (GLeeInit()) return glXGetSyncValuesOML(dpy, drawable, ust, msc, sbc); return (Bool)0;}
GLEEPFNGLXGETSYNCVALUESOMLPROC GLeeFuncPtr_glXGetSyncValuesOML=GLee_Lazy_glXGetSyncValuesOML;
#endif
#ifndef GLEE_C_DEFINED_glXGetMscRateOML
#define GLEE_C_DEFINED_glXGetMscRateOML
Bool __stdcall GLee_Lazy_glXGetMscRateOML(Display * dpy, GLXDrawable drawable, int32_t * numerator, int32_t * denominator) {if (GLeeInit()) return glXGetMscRateOML(dpy, drawable, numerator, denominator); return (Bool)0;}
GLEEPFNGLXGETMSCRATEOMLPROC GLeeFuncPtr_glXGetMscRateOML=GLee_Lazy_glXGetMscRateOML;
#endif
#ifndef GLEE_C_DEFINED_glXSwapBuffersMscOML
#define GLEE_C_DEFINED_glXSwapBuffersMscOML
int64_t __stdcall GLee_Lazy_glXSwapBuffersMscOML(Display * dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder) {if (GLeeInit()) return glXSwapBuffersMscOML(dpy, drawable, target_msc, divisor, remainder); return (int64_t)0;}
GLEEPFNGLXSWAPBUFFERSMSCOMLPROC GLeeFuncPtr_glXSwapBuffersMscOML=GLee_Lazy_glXSwapBuffersMscOML;
#endif
#ifndef GLEE_C_DEFINED_glXWaitForMscOML
#define GLEE_C_DEFINED_glXWaitForMscOML
Bool __stdcall GLee_Lazy_glXWaitForMscOML(Display * dpy, GLXDrawable drawable, int64_t target_msc, int64_t divisor, int64_t remainder, int64_t * ust, int64_t * msc, int64_t * sbc) {if (GLeeInit()) return glXWaitForMscOML(dpy, drawable, target_msc, divisor, remainder, ust, msc, sbc); return (Bool)0;}
GLEEPFNGLXWAITFORMSCOMLPROC GLeeFuncPtr_glXWaitForMscOML=GLee_Lazy_glXWaitForMscOML;
#endif
#ifndef GLEE_C_DEFINED_glXWaitForSbcOML
#define GLEE_C_DEFINED_glXWaitForSbcOML
Bool __stdcall GLee_Lazy_glXWaitForSbcOML(Display * dpy, GLXDrawable drawable, int64_t target_sbc, int64_t * ust, int64_t * msc, int64_t * sbc) {if (GLeeInit()) return glXWaitForSbcOML(dpy, drawable, target_sbc, ust, msc, sbc); return (Bool)0;}
GLEEPFNGLXWAITFORSBCOMLPROC GLeeFuncPtr_glXWaitForSbcOML=GLee_Lazy_glXWaitForSbcOML;
#endif
#endif
/* GLX_NV_float_buffer */
#ifdef __GLEE_GLX_NV_float_buffer
#endif
/* GLX_SGIX_hyperpipe */
#ifdef __GLEE_GLX_SGIX_hyperpipe
#ifndef GLEE_C_DEFINED_glXQueryHyperpipeNetworkSGIX
#define GLEE_C_DEFINED_glXQueryHyperpipeNetworkSGIX
GLXHyperpipeNetworkSGIX * __stdcall GLee_Lazy_glXQueryHyperpipeNetworkSGIX(Display * dpy, int * npipes) {if (GLeeInit()) return glXQueryHyperpipeNetworkSGIX(dpy, npipes); return (GLXHyperpipeNetworkSGIX *)0;}
GLEEPFNGLXQUERYHYPERPIPENETWORKSGIXPROC GLeeFuncPtr_glXQueryHyperpipeNetworkSGIX=GLee_Lazy_glXQueryHyperpipeNetworkSGIX;
#endif
#ifndef GLEE_C_DEFINED_glXHyperpipeConfigSGIX
#define GLEE_C_DEFINED_glXHyperpipeConfigSGIX
int __stdcall GLee_Lazy_glXHyperpipeConfigSGIX(Display * dpy, int networkId, int npipes, GLXHyperpipeConfigSGIX * cfg, int * hpId) {if (GLeeInit()) return glXHyperpipeConfigSGIX(dpy, networkId, npipes, cfg, hpId); return (int)0;}
GLEEPFNGLXHYPERPIPECONFIGSGIXPROC GLeeFuncPtr_glXHyperpipeConfigSGIX=GLee_Lazy_glXHyperpipeConfigSGIX;
#endif
#ifndef GLEE_C_DEFINED_glXQueryHyperpipeConfigSGIX
#define GLEE_C_DEFINED_glXQueryHyperpipeConfigSGIX
GLXHyperpipeConfigSGIX * __stdcall GLee_Lazy_glXQueryHyperpipeConfigSGIX(Display * dpy, int hpId, int * npipes) {if (GLeeInit()) return glXQueryHyperpipeConfigSGIX(dpy, hpId, npipes); return (GLXHyperpipeConfigSGIX *)0;}
GLEEPFNGLXQUERYHYPERPIPECONFIGSGIXPROC GLeeFuncPtr_glXQueryHyperpipeConfigSGIX=GLee_Lazy_glXQueryHyperpipeConfigSGIX;
#endif
#ifndef GLEE_C_DEFINED_glXDestroyHyperpipeConfigSGIX
#define GLEE_C_DEFINED_glXDestroyHyperpipeConfigSGIX
int __stdcall GLee_Lazy_glXDestroyHyperpipeConfigSGIX(Display * dpy, int hpId) {if (GLeeInit()) return glXDestroyHyperpipeConfigSGIX(dpy, hpId); return (int)0;}
GLEEPFNGLXDESTROYHYPERPIPECONFIGSGIXPROC GLeeFuncPtr_glXDestroyHyperpipeConfigSGIX=GLee_Lazy_glXDestroyHyperpipeConfigSGIX;
#endif
#ifndef GLEE_C_DEFINED_glXBindHyperpipeSGIX
#define GLEE_C_DEFINED_glXBindHyperpipeSGIX
int __stdcall GLee_Lazy_glXBindHyperpipeSGIX(Display * dpy, int hpId) {if (GLeeInit()) return glXBindHyperpipeSGIX(dpy, hpId); return (int)0;}
GLEEPFNGLXBINDHYPERPIPESGIXPROC GLeeFuncPtr_glXBindHyperpipeSGIX=GLee_Lazy_glXBindHyperpipeSGIX;
#endif
#ifndef GLEE_C_DEFINED_glXQueryHyperpipeBestAttribSGIX
#define GLEE_C_DEFINED_glXQueryHyperpipeBestAttribSGIX
int __stdcall GLee_Lazy_glXQueryHyperpipeBestAttribSGIX(Display * dpy, int timeSlice, int attrib, int size, void * attribList, void * returnAttribList) {if (GLeeInit()) return glXQueryHyperpipeBestAttribSGIX(dpy, timeSlice, attrib, size, attribList, returnAttribList); return (int)0;}
GLEEPFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC GLeeFuncPtr_glXQueryHyperpipeBestAttribSGIX=GLee_Lazy_glXQueryHyperpipeBestAttribSGIX;
#endif
#ifndef GLEE_C_DEFINED_glXHyperpipeAttribSGIX
#define GLEE_C_DEFINED_glXHyperpipeAttribSGIX
int __stdcall GLee_Lazy_glXHyperpipeAttribSGIX(Display * dpy, int timeSlice, int attrib, int size, void * attribList) {if (GLeeInit()) return glXHyperpipeAttribSGIX(dpy, timeSlice, attrib, size, attribList); return (int)0;}
GLEEPFNGLXHYPERPIPEATTRIBSGIXPROC GLeeFuncPtr_glXHyperpipeAttribSGIX=GLee_Lazy_glXHyperpipeAttribSGIX;
#endif
#ifndef GLEE_C_DEFINED_glXQueryHyperpipeAttribSGIX
#define GLEE_C_DEFINED_glXQueryHyperpipeAttribSGIX
int __stdcall GLee_Lazy_glXQueryHyperpipeAttribSGIX(Display * dpy, int timeSlice, int attrib, int size, void * returnAttribList) {if (GLeeInit()) return glXQueryHyperpipeAttribSGIX(dpy, timeSlice, attrib, size, returnAttribList); return (int)0;}
GLEEPFNGLXQUERYHYPERPIPEATTRIBSGIXPROC GLeeFuncPtr_glXQueryHyperpipeAttribSGIX=GLee_Lazy_glXQueryHyperpipeAttribSGIX;
#endif
#endif
/* GLX_MESA_agp_offset */
#ifdef __GLEE_GLX_MESA_agp_offset
#ifndef GLEE_C_DEFINED_glXGetAGPOffsetMESA
#define GLEE_C_DEFINED_glXGetAGPOffsetMESA
unsigned int __stdcall GLee_Lazy_glXGetAGPOffsetMESA(const void * pointer) {if (GLeeInit()) return glXGetAGPOffsetMESA(pointer); return (unsigned int)0;}
GLEEPFNGLXGETAGPOFFSETMESAPROC GLeeFuncPtr_glXGetAGPOffsetMESA=GLee_Lazy_glXGetAGPOffsetMESA;
#endif
#endif
/* GLX_EXT_fbconfig_packed_float */
#ifdef __GLEE_GLX_EXT_fbconfig_packed_float
#endif
/* GLX_EXT_framebuffer_sRGB */
#ifdef __GLEE_GLX_EXT_framebuffer_sRGB
#endif
/* GLX_EXT_texture_from_pixmap */
#ifdef __GLEE_GLX_EXT_texture_from_pixmap
#ifndef GLEE_C_DEFINED_glXBindTexImageEXT
#define GLEE_C_DEFINED_glXBindTexImageEXT
void __stdcall GLee_Lazy_glXBindTexImageEXT(Display * dpy, GLXDrawable drawable, int buffer, const int * attrib_list) {if (GLeeInit()) glXBindTexImageEXT(dpy, drawable, buffer, attrib_list);}
GLEEPFNGLXBINDTEXIMAGEEXTPROC GLeeFuncPtr_glXBindTexImageEXT=GLee_Lazy_glXBindTexImageEXT;
#endif
#ifndef GLEE_C_DEFINED_glXReleaseTexImageEXT
#define GLEE_C_DEFINED_glXReleaseTexImageEXT
void __stdcall GLee_Lazy_glXReleaseTexImageEXT(Display * dpy, GLXDrawable drawable, int buffer) {if (GLeeInit()) glXReleaseTexImageEXT(dpy, drawable, buffer);}
GLEEPFNGLXRELEASETEXIMAGEEXTPROC GLeeFuncPtr_glXReleaseTexImageEXT=GLee_Lazy_glXReleaseTexImageEXT;
#endif
#endif
/* GLX_NV_present_video */
#ifdef __GLEE_GLX_NV_present_video
#endif
/* GLX_NV_video_out */
#ifdef __GLEE_GLX_NV_video_out
#endif
/* GLX_NV_swap_group */
#ifdef __GLEE_GLX_NV_swap_group
#endif
/* GLX_EXT_scene_marker */
#ifdef __GLEE_GLX_EXT_scene_marker
#endif
/* GLX_NV_video_output */
#ifdef __GLEE_GLX_NV_video_output
#ifndef GLEE_C_DEFINED_glXGetVideoDeviceNV
#define GLEE_C_DEFINED_glXGetVideoDeviceNV
int __stdcall GLee_Lazy_glXGetVideoDeviceNV(Display * dpy, int screen, int numVideoDevices, GLXVideoDeviceNV * pVideoDevice) {if (GLeeInit()) return glXGetVideoDeviceNV(dpy, screen, numVideoDevices, pVideoDevice); return (int)0;}
GLEEPFNGLXGETVIDEODEVICENVPROC GLeeFuncPtr_glXGetVideoDeviceNV=GLee_Lazy_glXGetVideoDeviceNV;
#endif
#ifndef GLEE_C_DEFINED_glXReleaseVideoDeviceNV
#define GLEE_C_DEFINED_glXReleaseVideoDeviceNV
int __stdcall GLee_Lazy_glXReleaseVideoDeviceNV(Display * dpy, int screen, GLXVideoDeviceNV VideoDevice) {if (GLeeInit()) return glXReleaseVideoDeviceNV(dpy, screen, VideoDevice); return (int)0;}
GLEEPFNGLXRELEASEVIDEODEVICENVPROC GLeeFuncPtr_glXReleaseVideoDeviceNV=GLee_Lazy_glXReleaseVideoDeviceNV;
#endif
#ifndef GLEE_C_DEFINED_glXBindVideoImageNV
#define GLEE_C_DEFINED_glXBindVideoImageNV
int __stdcall GLee_Lazy_glXBindVideoImageNV(Display * dpy, GLXVideoDeviceNV VideoDevice, GLXPbuffer pbuf, int iVideoBuffer) {if (GLeeInit()) return glXBindVideoImageNV(dpy, VideoDevice, pbuf, iVideoBuffer); return (int)0;}
GLEEPFNGLXBINDVIDEOIMAGENVPROC GLeeFuncPtr_glXBindVideoImageNV=GLee_Lazy_glXBindVideoImageNV;
#endif
#ifndef GLEE_C_DEFINED_glXReleaseVideoImageNV
#define GLEE_C_DEFINED_glXReleaseVideoImageNV
int __stdcall GLee_Lazy_glXReleaseVideoImageNV(Display * dpy, GLXPbuffer pbuf) {if (GLeeInit()) return glXReleaseVideoImageNV(dpy, pbuf); return (int)0;}
GLEEPFNGLXRELEASEVIDEOIMAGENVPROC GLeeFuncPtr_glXReleaseVideoImageNV=GLee_Lazy_glXReleaseVideoImageNV;
#endif
#ifndef GLEE_C_DEFINED_glXSendPbufferToVideoNV
#define GLEE_C_DEFINED_glXSendPbufferToVideoNV
int __stdcall GLee_Lazy_glXSendPbufferToVideoNV(Display * dpy, GLXPbuffer pbuf, int iBufferType, unsigned long * pulCounterPbuffer, GLboolean bBlock) {if (GLeeInit()) return glXSendPbufferToVideoNV(dpy, pbuf, iBufferType, pulCounterPbuffer, bBlock); return (int)0;}
GLEEPFNGLXSENDPBUFFERTOVIDEONVPROC GLeeFuncPtr_glXSendPbufferToVideoNV=GLee_Lazy_glXSendPbufferToVideoNV;
#endif
#ifndef GLEE_C_DEFINED_glXGetVideoInfoNV
#define GLEE_C_DEFINED_glXGetVideoInfoNV
int __stdcall GLee_Lazy_glXGetVideoInfoNV(Display * dpy, int screen, GLXVideoDeviceNV VideoDevice, unsigned long * pulCounterOutputPbuffer, unsigned long * pulCounterOutputVideo) {if (GLeeInit()) return glXGetVideoInfoNV(dpy, screen, VideoDevice, pulCounterOutputPbuffer, pulCounterOutputVideo); return (int)0;}
GLEEPFNGLXGETVIDEOINFONVPROC GLeeFuncPtr_glXGetVideoInfoNV=GLee_Lazy_glXGetVideoInfoNV;
#endif
#endif
#endif /* end GLX */
/*****************************************************************
* Extension link functions
*****************************************************************/
GLuint __GLeeLink_GL_VERSION_1_2(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_VERSION_1_2
if ((GLeeFuncPtr_glBlendColor = (GLEEPFNGLBLENDCOLORPROC) __GLeeGetProcAddress("glBlendColor"))!=0) nLinked++;
if ((GLeeFuncPtr_glBlendEquation = (GLEEPFNGLBLENDEQUATIONPROC) __GLeeGetProcAddress("glBlendEquation"))!=0) nLinked++;
if ((GLeeFuncPtr_glDrawRangeElements = (GLEEPFNGLDRAWRANGEELEMENTSPROC) __GLeeGetProcAddress("glDrawRangeElements"))!=0) nLinked++;
if ((GLeeFuncPtr_glColorTable = (GLEEPFNGLCOLORTABLEPROC) __GLeeGetProcAddress("glColorTable"))!=0) nLinked++;
if ((GLeeFuncPtr_glColorTableParameterfv = (GLEEPFNGLCOLORTABLEPARAMETERFVPROC) __GLeeGetProcAddress("glColorTableParameterfv"))!=0) nLinked++;
if ((GLeeFuncPtr_glColorTableParameteriv = (GLEEPFNGLCOLORTABLEPARAMETERIVPROC) __GLeeGetProcAddress("glColorTableParameteriv"))!=0) nLinked++;
if ((GLeeFuncPtr_glCopyColorTable = (GLEEPFNGLCOPYCOLORTABLEPROC) __GLeeGetProcAddress("glCopyColorTable"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetColorTable = (GLEEPFNGLGETCOLORTABLEPROC) __GLeeGetProcAddress("glGetColorTable"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetColorTableParameterfv = (GLEEPFNGLGETCOLORTABLEPARAMETERFVPROC) __GLeeGetProcAddress("glGetColorTableParameterfv"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetColorTableParameteriv = (GLEEPFNGLGETCOLORTABLEPARAMETERIVPROC) __GLeeGetProcAddress("glGetColorTableParameteriv"))!=0) nLinked++;
if ((GLeeFuncPtr_glColorSubTable = (GLEEPFNGLCOLORSUBTABLEPROC) __GLeeGetProcAddress("glColorSubTable"))!=0) nLinked++;
if ((GLeeFuncPtr_glCopyColorSubTable = (GLEEPFNGLCOPYCOLORSUBTABLEPROC) __GLeeGetProcAddress("glCopyColorSubTable"))!=0) nLinked++;
if ((GLeeFuncPtr_glConvolutionFilter1D = (GLEEPFNGLCONVOLUTIONFILTER1DPROC) __GLeeGetProcAddress("glConvolutionFilter1D"))!=0) nLinked++;
if ((GLeeFuncPtr_glConvolutionFilter2D = (GLEEPFNGLCONVOLUTIONFILTER2DPROC) __GLeeGetProcAddress("glConvolutionFilter2D"))!=0) nLinked++;
if ((GLeeFuncPtr_glConvolutionParameterf = (GLEEPFNGLCONVOLUTIONPARAMETERFPROC) __GLeeGetProcAddress("glConvolutionParameterf"))!=0) nLinked++;
if ((GLeeFuncPtr_glConvolutionParameterfv = (GLEEPFNGLCONVOLUTIONPARAMETERFVPROC) __GLeeGetProcAddress("glConvolutionParameterfv"))!=0) nLinked++;
if ((GLeeFuncPtr_glConvolutionParameteri = (GLEEPFNGLCONVOLUTIONPARAMETERIPROC) __GLeeGetProcAddress("glConvolutionParameteri"))!=0) nLinked++;
if ((GLeeFuncPtr_glConvolutionParameteriv = (GLEEPFNGLCONVOLUTIONPARAMETERIVPROC) __GLeeGetProcAddress("glConvolutionParameteriv"))!=0) nLinked++;
if ((GLeeFuncPtr_glCopyConvolutionFilter1D = (GLEEPFNGLCOPYCONVOLUTIONFILTER1DPROC) __GLeeGetProcAddress("glCopyConvolutionFilter1D"))!=0) nLinked++;
if ((GLeeFuncPtr_glCopyConvolutionFilter2D = (GLEEPFNGLCOPYCONVOLUTIONFILTER2DPROC) __GLeeGetProcAddress("glCopyConvolutionFilter2D"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetConvolutionFilter = (GLEEPFNGLGETCONVOLUTIONFILTERPROC) __GLeeGetProcAddress("glGetConvolutionFilter"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetConvolutionParameterfv = (GLEEPFNGLGETCONVOLUTIONPARAMETERFVPROC) __GLeeGetProcAddress("glGetConvolutionParameterfv"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetConvolutionParameteriv = (GLEEPFNGLGETCONVOLUTIONPARAMETERIVPROC) __GLeeGetProcAddress("glGetConvolutionParameteriv"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetSeparableFilter = (GLEEPFNGLGETSEPARABLEFILTERPROC) __GLeeGetProcAddress("glGetSeparableFilter"))!=0) nLinked++;
if ((GLeeFuncPtr_glSeparableFilter2D = (GLEEPFNGLSEPARABLEFILTER2DPROC) __GLeeGetProcAddress("glSeparableFilter2D"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetHistogram = (GLEEPFNGLGETHISTOGRAMPROC) __GLeeGetProcAddress("glGetHistogram"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetHistogramParameterfv = (GLEEPFNGLGETHISTOGRAMPARAMETERFVPROC) __GLeeGetProcAddress("glGetHistogramParameterfv"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetHistogramParameteriv = (GLEEPFNGLGETHISTOGRAMPARAMETERIVPROC) __GLeeGetProcAddress("glGetHistogramParameteriv"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetMinmax = (GLEEPFNGLGETMINMAXPROC) __GLeeGetProcAddress("glGetMinmax"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetMinmaxParameterfv = (GLEEPFNGLGETMINMAXPARAMETERFVPROC) __GLeeGetProcAddress("glGetMinmaxParameterfv"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetMinmaxParameteriv = (GLEEPFNGLGETMINMAXPARAMETERIVPROC) __GLeeGetProcAddress("glGetMinmaxParameteriv"))!=0) nLinked++;
if ((GLeeFuncPtr_glHistogram = (GLEEPFNGLHISTOGRAMPROC) __GLeeGetProcAddress("glHistogram"))!=0) nLinked++;
if ((GLeeFuncPtr_glMinmax = (GLEEPFNGLMINMAXPROC) __GLeeGetProcAddress("glMinmax"))!=0) nLinked++;
if ((GLeeFuncPtr_glResetHistogram = (GLEEPFNGLRESETHISTOGRAMPROC) __GLeeGetProcAddress("glResetHistogram"))!=0) nLinked++;
if ((GLeeFuncPtr_glResetMinmax = (GLEEPFNGLRESETMINMAXPROC) __GLeeGetProcAddress("glResetMinmax"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexImage3D = (GLEEPFNGLTEXIMAGE3DPROC) __GLeeGetProcAddress("glTexImage3D"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexSubImage3D = (GLEEPFNGLTEXSUBIMAGE3DPROC) __GLeeGetProcAddress("glTexSubImage3D"))!=0) nLinked++;
if ((GLeeFuncPtr_glCopyTexSubImage3D = (GLEEPFNGLCOPYTEXSUBIMAGE3DPROC) __GLeeGetProcAddress("glCopyTexSubImage3D"))!=0) nLinked++;
#endif
if (nLinked==38) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ARB_imaging(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_VERSION_1_3(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_VERSION_1_3
if ((GLeeFuncPtr_glActiveTexture = (GLEEPFNGLACTIVETEXTUREPROC) __GLeeGetProcAddress("glActiveTexture"))!=0) nLinked++;
if ((GLeeFuncPtr_glClientActiveTexture = (GLEEPFNGLCLIENTACTIVETEXTUREPROC) __GLeeGetProcAddress("glClientActiveTexture"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord1d = (GLEEPFNGLMULTITEXCOORD1DPROC) __GLeeGetProcAddress("glMultiTexCoord1d"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord1dv = (GLEEPFNGLMULTITEXCOORD1DVPROC) __GLeeGetProcAddress("glMultiTexCoord1dv"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord1f = (GLEEPFNGLMULTITEXCOORD1FPROC) __GLeeGetProcAddress("glMultiTexCoord1f"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord1fv = (GLEEPFNGLMULTITEXCOORD1FVPROC) __GLeeGetProcAddress("glMultiTexCoord1fv"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord1i = (GLEEPFNGLMULTITEXCOORD1IPROC) __GLeeGetProcAddress("glMultiTexCoord1i"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord1iv = (GLEEPFNGLMULTITEXCOORD1IVPROC) __GLeeGetProcAddress("glMultiTexCoord1iv"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord1s = (GLEEPFNGLMULTITEXCOORD1SPROC) __GLeeGetProcAddress("glMultiTexCoord1s"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord1sv = (GLEEPFNGLMULTITEXCOORD1SVPROC) __GLeeGetProcAddress("glMultiTexCoord1sv"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord2d = (GLEEPFNGLMULTITEXCOORD2DPROC) __GLeeGetProcAddress("glMultiTexCoord2d"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord2dv = (GLEEPFNGLMULTITEXCOORD2DVPROC) __GLeeGetProcAddress("glMultiTexCoord2dv"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord2f = (GLEEPFNGLMULTITEXCOORD2FPROC) __GLeeGetProcAddress("glMultiTexCoord2f"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord2fv = (GLEEPFNGLMULTITEXCOORD2FVPROC) __GLeeGetProcAddress("glMultiTexCoord2fv"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord2i = (GLEEPFNGLMULTITEXCOORD2IPROC) __GLeeGetProcAddress("glMultiTexCoord2i"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord2iv = (GLEEPFNGLMULTITEXCOORD2IVPROC) __GLeeGetProcAddress("glMultiTexCoord2iv"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord2s = (GLEEPFNGLMULTITEXCOORD2SPROC) __GLeeGetProcAddress("glMultiTexCoord2s"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord2sv = (GLEEPFNGLMULTITEXCOORD2SVPROC) __GLeeGetProcAddress("glMultiTexCoord2sv"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord3d = (GLEEPFNGLMULTITEXCOORD3DPROC) __GLeeGetProcAddress("glMultiTexCoord3d"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord3dv = (GLEEPFNGLMULTITEXCOORD3DVPROC) __GLeeGetProcAddress("glMultiTexCoord3dv"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord3f = (GLEEPFNGLMULTITEXCOORD3FPROC) __GLeeGetProcAddress("glMultiTexCoord3f"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord3fv = (GLEEPFNGLMULTITEXCOORD3FVPROC) __GLeeGetProcAddress("glMultiTexCoord3fv"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord3i = (GLEEPFNGLMULTITEXCOORD3IPROC) __GLeeGetProcAddress("glMultiTexCoord3i"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord3iv = (GLEEPFNGLMULTITEXCOORD3IVPROC) __GLeeGetProcAddress("glMultiTexCoord3iv"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord3s = (GLEEPFNGLMULTITEXCOORD3SPROC) __GLeeGetProcAddress("glMultiTexCoord3s"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord3sv = (GLEEPFNGLMULTITEXCOORD3SVPROC) __GLeeGetProcAddress("glMultiTexCoord3sv"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord4d = (GLEEPFNGLMULTITEXCOORD4DPROC) __GLeeGetProcAddress("glMultiTexCoord4d"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord4dv = (GLEEPFNGLMULTITEXCOORD4DVPROC) __GLeeGetProcAddress("glMultiTexCoord4dv"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord4f = (GLEEPFNGLMULTITEXCOORD4FPROC) __GLeeGetProcAddress("glMultiTexCoord4f"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord4fv = (GLEEPFNGLMULTITEXCOORD4FVPROC) __GLeeGetProcAddress("glMultiTexCoord4fv"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord4i = (GLEEPFNGLMULTITEXCOORD4IPROC) __GLeeGetProcAddress("glMultiTexCoord4i"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord4iv = (GLEEPFNGLMULTITEXCOORD4IVPROC) __GLeeGetProcAddress("glMultiTexCoord4iv"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord4s = (GLEEPFNGLMULTITEXCOORD4SPROC) __GLeeGetProcAddress("glMultiTexCoord4s"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord4sv = (GLEEPFNGLMULTITEXCOORD4SVPROC) __GLeeGetProcAddress("glMultiTexCoord4sv"))!=0) nLinked++;
if ((GLeeFuncPtr_glLoadTransposeMatrixf = (GLEEPFNGLLOADTRANSPOSEMATRIXFPROC) __GLeeGetProcAddress("glLoadTransposeMatrixf"))!=0) nLinked++;
if ((GLeeFuncPtr_glLoadTransposeMatrixd = (GLEEPFNGLLOADTRANSPOSEMATRIXDPROC) __GLeeGetProcAddress("glLoadTransposeMatrixd"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultTransposeMatrixf = (GLEEPFNGLMULTTRANSPOSEMATRIXFPROC) __GLeeGetProcAddress("glMultTransposeMatrixf"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultTransposeMatrixd = (GLEEPFNGLMULTTRANSPOSEMATRIXDPROC) __GLeeGetProcAddress("glMultTransposeMatrixd"))!=0) nLinked++;
if ((GLeeFuncPtr_glSampleCoverage = (GLEEPFNGLSAMPLECOVERAGEPROC) __GLeeGetProcAddress("glSampleCoverage"))!=0) nLinked++;
if ((GLeeFuncPtr_glCompressedTexImage3D = (GLEEPFNGLCOMPRESSEDTEXIMAGE3DPROC) __GLeeGetProcAddress("glCompressedTexImage3D"))!=0) nLinked++;
if ((GLeeFuncPtr_glCompressedTexImage2D = (GLEEPFNGLCOMPRESSEDTEXIMAGE2DPROC) __GLeeGetProcAddress("glCompressedTexImage2D"))!=0) nLinked++;
if ((GLeeFuncPtr_glCompressedTexImage1D = (GLEEPFNGLCOMPRESSEDTEXIMAGE1DPROC) __GLeeGetProcAddress("glCompressedTexImage1D"))!=0) nLinked++;
if ((GLeeFuncPtr_glCompressedTexSubImage3D = (GLEEPFNGLCOMPRESSEDTEXSUBIMAGE3DPROC) __GLeeGetProcAddress("glCompressedTexSubImage3D"))!=0) nLinked++;
if ((GLeeFuncPtr_glCompressedTexSubImage2D = (GLEEPFNGLCOMPRESSEDTEXSUBIMAGE2DPROC) __GLeeGetProcAddress("glCompressedTexSubImage2D"))!=0) nLinked++;
if ((GLeeFuncPtr_glCompressedTexSubImage1D = (GLEEPFNGLCOMPRESSEDTEXSUBIMAGE1DPROC) __GLeeGetProcAddress("glCompressedTexSubImage1D"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetCompressedTexImage = (GLEEPFNGLGETCOMPRESSEDTEXIMAGEPROC) __GLeeGetProcAddress("glGetCompressedTexImage"))!=0) nLinked++;
#endif
if (nLinked==46) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_VERSION_1_4(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_VERSION_1_4
if ((GLeeFuncPtr_glBlendFuncSeparate = (GLEEPFNGLBLENDFUNCSEPARATEPROC) __GLeeGetProcAddress("glBlendFuncSeparate"))!=0) nLinked++;
if ((GLeeFuncPtr_glFogCoordf = (GLEEPFNGLFOGCOORDFPROC) __GLeeGetProcAddress("glFogCoordf"))!=0) nLinked++;
if ((GLeeFuncPtr_glFogCoordfv = (GLEEPFNGLFOGCOORDFVPROC) __GLeeGetProcAddress("glFogCoordfv"))!=0) nLinked++;
if ((GLeeFuncPtr_glFogCoordd = (GLEEPFNGLFOGCOORDDPROC) __GLeeGetProcAddress("glFogCoordd"))!=0) nLinked++;
if ((GLeeFuncPtr_glFogCoorddv = (GLEEPFNGLFOGCOORDDVPROC) __GLeeGetProcAddress("glFogCoorddv"))!=0) nLinked++;
if ((GLeeFuncPtr_glFogCoordPointer = (GLEEPFNGLFOGCOORDPOINTERPROC) __GLeeGetProcAddress("glFogCoordPointer"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiDrawArrays = (GLEEPFNGLMULTIDRAWARRAYSPROC) __GLeeGetProcAddress("glMultiDrawArrays"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiDrawElements = (GLEEPFNGLMULTIDRAWELEMENTSPROC) __GLeeGetProcAddress("glMultiDrawElements"))!=0) nLinked++;
if ((GLeeFuncPtr_glPointParameterf = (GLEEPFNGLPOINTPARAMETERFPROC) __GLeeGetProcAddress("glPointParameterf"))!=0) nLinked++;
if ((GLeeFuncPtr_glPointParameterfv = (GLEEPFNGLPOINTPARAMETERFVPROC) __GLeeGetProcAddress("glPointParameterfv"))!=0) nLinked++;
if ((GLeeFuncPtr_glPointParameteri = (GLEEPFNGLPOINTPARAMETERIPROC) __GLeeGetProcAddress("glPointParameteri"))!=0) nLinked++;
if ((GLeeFuncPtr_glPointParameteriv = (GLEEPFNGLPOINTPARAMETERIVPROC) __GLeeGetProcAddress("glPointParameteriv"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3b = (GLEEPFNGLSECONDARYCOLOR3BPROC) __GLeeGetProcAddress("glSecondaryColor3b"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3bv = (GLEEPFNGLSECONDARYCOLOR3BVPROC) __GLeeGetProcAddress("glSecondaryColor3bv"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3d = (GLEEPFNGLSECONDARYCOLOR3DPROC) __GLeeGetProcAddress("glSecondaryColor3d"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3dv = (GLEEPFNGLSECONDARYCOLOR3DVPROC) __GLeeGetProcAddress("glSecondaryColor3dv"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3f = (GLEEPFNGLSECONDARYCOLOR3FPROC) __GLeeGetProcAddress("glSecondaryColor3f"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3fv = (GLEEPFNGLSECONDARYCOLOR3FVPROC) __GLeeGetProcAddress("glSecondaryColor3fv"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3i = (GLEEPFNGLSECONDARYCOLOR3IPROC) __GLeeGetProcAddress("glSecondaryColor3i"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3iv = (GLEEPFNGLSECONDARYCOLOR3IVPROC) __GLeeGetProcAddress("glSecondaryColor3iv"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3s = (GLEEPFNGLSECONDARYCOLOR3SPROC) __GLeeGetProcAddress("glSecondaryColor3s"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3sv = (GLEEPFNGLSECONDARYCOLOR3SVPROC) __GLeeGetProcAddress("glSecondaryColor3sv"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3ub = (GLEEPFNGLSECONDARYCOLOR3UBPROC) __GLeeGetProcAddress("glSecondaryColor3ub"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3ubv = (GLEEPFNGLSECONDARYCOLOR3UBVPROC) __GLeeGetProcAddress("glSecondaryColor3ubv"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3ui = (GLEEPFNGLSECONDARYCOLOR3UIPROC) __GLeeGetProcAddress("glSecondaryColor3ui"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3uiv = (GLEEPFNGLSECONDARYCOLOR3UIVPROC) __GLeeGetProcAddress("glSecondaryColor3uiv"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3us = (GLEEPFNGLSECONDARYCOLOR3USPROC) __GLeeGetProcAddress("glSecondaryColor3us"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3usv = (GLEEPFNGLSECONDARYCOLOR3USVPROC) __GLeeGetProcAddress("glSecondaryColor3usv"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColorPointer = (GLEEPFNGLSECONDARYCOLORPOINTERPROC) __GLeeGetProcAddress("glSecondaryColorPointer"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos2d = (GLEEPFNGLWINDOWPOS2DPROC) __GLeeGetProcAddress("glWindowPos2d"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos2dv = (GLEEPFNGLWINDOWPOS2DVPROC) __GLeeGetProcAddress("glWindowPos2dv"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos2f = (GLEEPFNGLWINDOWPOS2FPROC) __GLeeGetProcAddress("glWindowPos2f"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos2fv = (GLEEPFNGLWINDOWPOS2FVPROC) __GLeeGetProcAddress("glWindowPos2fv"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos2i = (GLEEPFNGLWINDOWPOS2IPROC) __GLeeGetProcAddress("glWindowPos2i"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos2iv = (GLEEPFNGLWINDOWPOS2IVPROC) __GLeeGetProcAddress("glWindowPos2iv"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos2s = (GLEEPFNGLWINDOWPOS2SPROC) __GLeeGetProcAddress("glWindowPos2s"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos2sv = (GLEEPFNGLWINDOWPOS2SVPROC) __GLeeGetProcAddress("glWindowPos2sv"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos3d = (GLEEPFNGLWINDOWPOS3DPROC) __GLeeGetProcAddress("glWindowPos3d"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos3dv = (GLEEPFNGLWINDOWPOS3DVPROC) __GLeeGetProcAddress("glWindowPos3dv"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos3f = (GLEEPFNGLWINDOWPOS3FPROC) __GLeeGetProcAddress("glWindowPos3f"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos3fv = (GLEEPFNGLWINDOWPOS3FVPROC) __GLeeGetProcAddress("glWindowPos3fv"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos3i = (GLEEPFNGLWINDOWPOS3IPROC) __GLeeGetProcAddress("glWindowPos3i"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos3iv = (GLEEPFNGLWINDOWPOS3IVPROC) __GLeeGetProcAddress("glWindowPos3iv"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos3s = (GLEEPFNGLWINDOWPOS3SPROC) __GLeeGetProcAddress("glWindowPos3s"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos3sv = (GLEEPFNGLWINDOWPOS3SVPROC) __GLeeGetProcAddress("glWindowPos3sv"))!=0) nLinked++;
#endif
if (nLinked==45) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_VERSION_1_5(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_VERSION_1_5
if ((GLeeFuncPtr_glGenQueries = (GLEEPFNGLGENQUERIESPROC) __GLeeGetProcAddress("glGenQueries"))!=0) nLinked++;
if ((GLeeFuncPtr_glDeleteQueries = (GLEEPFNGLDELETEQUERIESPROC) __GLeeGetProcAddress("glDeleteQueries"))!=0) nLinked++;
if ((GLeeFuncPtr_glIsQuery = (GLEEPFNGLISQUERYPROC) __GLeeGetProcAddress("glIsQuery"))!=0) nLinked++;
if ((GLeeFuncPtr_glBeginQuery = (GLEEPFNGLBEGINQUERYPROC) __GLeeGetProcAddress("glBeginQuery"))!=0) nLinked++;
if ((GLeeFuncPtr_glEndQuery = (GLEEPFNGLENDQUERYPROC) __GLeeGetProcAddress("glEndQuery"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetQueryiv = (GLEEPFNGLGETQUERYIVPROC) __GLeeGetProcAddress("glGetQueryiv"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetQueryObjectiv = (GLEEPFNGLGETQUERYOBJECTIVPROC) __GLeeGetProcAddress("glGetQueryObjectiv"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetQueryObjectuiv = (GLEEPFNGLGETQUERYOBJECTUIVPROC) __GLeeGetProcAddress("glGetQueryObjectuiv"))!=0) nLinked++;
if ((GLeeFuncPtr_glBindBuffer = (GLEEPFNGLBINDBUFFERPROC) __GLeeGetProcAddress("glBindBuffer"))!=0) nLinked++;
if ((GLeeFuncPtr_glDeleteBuffers = (GLEEPFNGLDELETEBUFFERSPROC) __GLeeGetProcAddress("glDeleteBuffers"))!=0) nLinked++;
if ((GLeeFuncPtr_glGenBuffers = (GLEEPFNGLGENBUFFERSPROC) __GLeeGetProcAddress("glGenBuffers"))!=0) nLinked++;
if ((GLeeFuncPtr_glIsBuffer = (GLEEPFNGLISBUFFERPROC) __GLeeGetProcAddress("glIsBuffer"))!=0) nLinked++;
if ((GLeeFuncPtr_glBufferData = (GLEEPFNGLBUFFERDATAPROC) __GLeeGetProcAddress("glBufferData"))!=0) nLinked++;
if ((GLeeFuncPtr_glBufferSubData = (GLEEPFNGLBUFFERSUBDATAPROC) __GLeeGetProcAddress("glBufferSubData"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetBufferSubData = (GLEEPFNGLGETBUFFERSUBDATAPROC) __GLeeGetProcAddress("glGetBufferSubData"))!=0) nLinked++;
if ((GLeeFuncPtr_glMapBuffer = (GLEEPFNGLMAPBUFFERPROC) __GLeeGetProcAddress("glMapBuffer"))!=0) nLinked++;
if ((GLeeFuncPtr_glUnmapBuffer = (GLEEPFNGLUNMAPBUFFERPROC) __GLeeGetProcAddress("glUnmapBuffer"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetBufferParameteriv = (GLEEPFNGLGETBUFFERPARAMETERIVPROC) __GLeeGetProcAddress("glGetBufferParameteriv"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetBufferPointerv = (GLEEPFNGLGETBUFFERPOINTERVPROC) __GLeeGetProcAddress("glGetBufferPointerv"))!=0) nLinked++;
#endif
if (nLinked==19) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_VERSION_2_0(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_VERSION_2_0
if ((GLeeFuncPtr_glBlendEquationSeparate = (GLEEPFNGLBLENDEQUATIONSEPARATEPROC) __GLeeGetProcAddress("glBlendEquationSeparate"))!=0) nLinked++;
if ((GLeeFuncPtr_glDrawBuffers = (GLEEPFNGLDRAWBUFFERSPROC) __GLeeGetProcAddress("glDrawBuffers"))!=0) nLinked++;
if ((GLeeFuncPtr_glStencilOpSeparate = (GLEEPFNGLSTENCILOPSEPARATEPROC) __GLeeGetProcAddress("glStencilOpSeparate"))!=0) nLinked++;
if ((GLeeFuncPtr_glStencilFuncSeparate = (GLEEPFNGLSTENCILFUNCSEPARATEPROC) __GLeeGetProcAddress("glStencilFuncSeparate"))!=0) nLinked++;
if ((GLeeFuncPtr_glStencilMaskSeparate = (GLEEPFNGLSTENCILMASKSEPARATEPROC) __GLeeGetProcAddress("glStencilMaskSeparate"))!=0) nLinked++;
if ((GLeeFuncPtr_glAttachShader = (GLEEPFNGLATTACHSHADERPROC) __GLeeGetProcAddress("glAttachShader"))!=0) nLinked++;
if ((GLeeFuncPtr_glBindAttribLocation = (GLEEPFNGLBINDATTRIBLOCATIONPROC) __GLeeGetProcAddress("glBindAttribLocation"))!=0) nLinked++;
if ((GLeeFuncPtr_glCompileShader = (GLEEPFNGLCOMPILESHADERPROC) __GLeeGetProcAddress("glCompileShader"))!=0) nLinked++;
if ((GLeeFuncPtr_glCreateProgram = (GLEEPFNGLCREATEPROGRAMPROC) __GLeeGetProcAddress("glCreateProgram"))!=0) nLinked++;
if ((GLeeFuncPtr_glCreateShader = (GLEEPFNGLCREATESHADERPROC) __GLeeGetProcAddress("glCreateShader"))!=0) nLinked++;
if ((GLeeFuncPtr_glDeleteProgram = (GLEEPFNGLDELETEPROGRAMPROC) __GLeeGetProcAddress("glDeleteProgram"))!=0) nLinked++;
if ((GLeeFuncPtr_glDeleteShader = (GLEEPFNGLDELETESHADERPROC) __GLeeGetProcAddress("glDeleteShader"))!=0) nLinked++;
if ((GLeeFuncPtr_glDetachShader = (GLEEPFNGLDETACHSHADERPROC) __GLeeGetProcAddress("glDetachShader"))!=0) nLinked++;
if ((GLeeFuncPtr_glDisableVertexAttribArray = (GLEEPFNGLDISABLEVERTEXATTRIBARRAYPROC) __GLeeGetProcAddress("glDisableVertexAttribArray"))!=0) nLinked++;
if ((GLeeFuncPtr_glEnableVertexAttribArray = (GLEEPFNGLENABLEVERTEXATTRIBARRAYPROC) __GLeeGetProcAddress("glEnableVertexAttribArray"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetActiveAttrib = (GLEEPFNGLGETACTIVEATTRIBPROC) __GLeeGetProcAddress("glGetActiveAttrib"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetActiveUniform = (GLEEPFNGLGETACTIVEUNIFORMPROC) __GLeeGetProcAddress("glGetActiveUniform"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetAttachedShaders = (GLEEPFNGLGETATTACHEDSHADERSPROC) __GLeeGetProcAddress("glGetAttachedShaders"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetAttribLocation = (GLEEPFNGLGETATTRIBLOCATIONPROC) __GLeeGetProcAddress("glGetAttribLocation"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetProgramiv = (GLEEPFNGLGETPROGRAMIVPROC) __GLeeGetProcAddress("glGetProgramiv"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetProgramInfoLog = (GLEEPFNGLGETPROGRAMINFOLOGPROC) __GLeeGetProcAddress("glGetProgramInfoLog"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetShaderiv = (GLEEPFNGLGETSHADERIVPROC) __GLeeGetProcAddress("glGetShaderiv"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetShaderInfoLog = (GLEEPFNGLGETSHADERINFOLOGPROC) __GLeeGetProcAddress("glGetShaderInfoLog"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetShaderSource = (GLEEPFNGLGETSHADERSOURCEPROC) __GLeeGetProcAddress("glGetShaderSource"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetUniformLocation = (GLEEPFNGLGETUNIFORMLOCATIONPROC) __GLeeGetProcAddress("glGetUniformLocation"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetUniformfv = (GLEEPFNGLGETUNIFORMFVPROC) __GLeeGetProcAddress("glGetUniformfv"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetUniformiv = (GLEEPFNGLGETUNIFORMIVPROC) __GLeeGetProcAddress("glGetUniformiv"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetVertexAttribdv = (GLEEPFNGLGETVERTEXATTRIBDVPROC) __GLeeGetProcAddress("glGetVertexAttribdv"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetVertexAttribfv = (GLEEPFNGLGETVERTEXATTRIBFVPROC) __GLeeGetProcAddress("glGetVertexAttribfv"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetVertexAttribiv = (GLEEPFNGLGETVERTEXATTRIBIVPROC) __GLeeGetProcAddress("glGetVertexAttribiv"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetVertexAttribPointerv = (GLEEPFNGLGETVERTEXATTRIBPOINTERVPROC) __GLeeGetProcAddress("glGetVertexAttribPointerv"))!=0) nLinked++;
if ((GLeeFuncPtr_glIsProgram = (GLEEPFNGLISPROGRAMPROC) __GLeeGetProcAddress("glIsProgram"))!=0) nLinked++;
if ((GLeeFuncPtr_glIsShader = (GLEEPFNGLISSHADERPROC) __GLeeGetProcAddress("glIsShader"))!=0) nLinked++;
if ((GLeeFuncPtr_glLinkProgram = (GLEEPFNGLLINKPROGRAMPROC) __GLeeGetProcAddress("glLinkProgram"))!=0) nLinked++;
if ((GLeeFuncPtr_glShaderSource = (GLEEPFNGLSHADERSOURCEPROC) __GLeeGetProcAddress("glShaderSource"))!=0) nLinked++;
if ((GLeeFuncPtr_glUseProgram = (GLEEPFNGLUSEPROGRAMPROC) __GLeeGetProcAddress("glUseProgram"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform1f = (GLEEPFNGLUNIFORM1FPROC) __GLeeGetProcAddress("glUniform1f"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform2f = (GLEEPFNGLUNIFORM2FPROC) __GLeeGetProcAddress("glUniform2f"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform3f = (GLEEPFNGLUNIFORM3FPROC) __GLeeGetProcAddress("glUniform3f"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform4f = (GLEEPFNGLUNIFORM4FPROC) __GLeeGetProcAddress("glUniform4f"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform1i = (GLEEPFNGLUNIFORM1IPROC) __GLeeGetProcAddress("glUniform1i"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform2i = (GLEEPFNGLUNIFORM2IPROC) __GLeeGetProcAddress("glUniform2i"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform3i = (GLEEPFNGLUNIFORM3IPROC) __GLeeGetProcAddress("glUniform3i"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform4i = (GLEEPFNGLUNIFORM4IPROC) __GLeeGetProcAddress("glUniform4i"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform1fv = (GLEEPFNGLUNIFORM1FVPROC) __GLeeGetProcAddress("glUniform1fv"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform2fv = (GLEEPFNGLUNIFORM2FVPROC) __GLeeGetProcAddress("glUniform2fv"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform3fv = (GLEEPFNGLUNIFORM3FVPROC) __GLeeGetProcAddress("glUniform3fv"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform4fv = (GLEEPFNGLUNIFORM4FVPROC) __GLeeGetProcAddress("glUniform4fv"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform1iv = (GLEEPFNGLUNIFORM1IVPROC) __GLeeGetProcAddress("glUniform1iv"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform2iv = (GLEEPFNGLUNIFORM2IVPROC) __GLeeGetProcAddress("glUniform2iv"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform3iv = (GLEEPFNGLUNIFORM3IVPROC) __GLeeGetProcAddress("glUniform3iv"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform4iv = (GLEEPFNGLUNIFORM4IVPROC) __GLeeGetProcAddress("glUniform4iv"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniformMatrix2fv = (GLEEPFNGLUNIFORMMATRIX2FVPROC) __GLeeGetProcAddress("glUniformMatrix2fv"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniformMatrix3fv = (GLEEPFNGLUNIFORMMATRIX3FVPROC) __GLeeGetProcAddress("glUniformMatrix3fv"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniformMatrix4fv = (GLEEPFNGLUNIFORMMATRIX4FVPROC) __GLeeGetProcAddress("glUniformMatrix4fv"))!=0) nLinked++;
if ((GLeeFuncPtr_glValidateProgram = (GLEEPFNGLVALIDATEPROGRAMPROC) __GLeeGetProcAddress("glValidateProgram"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib1d = (GLEEPFNGLVERTEXATTRIB1DPROC) __GLeeGetProcAddress("glVertexAttrib1d"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib1dv = (GLEEPFNGLVERTEXATTRIB1DVPROC) __GLeeGetProcAddress("glVertexAttrib1dv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib1f = (GLEEPFNGLVERTEXATTRIB1FPROC) __GLeeGetProcAddress("glVertexAttrib1f"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib1fv = (GLEEPFNGLVERTEXATTRIB1FVPROC) __GLeeGetProcAddress("glVertexAttrib1fv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib1s = (GLEEPFNGLVERTEXATTRIB1SPROC) __GLeeGetProcAddress("glVertexAttrib1s"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib1sv = (GLEEPFNGLVERTEXATTRIB1SVPROC) __GLeeGetProcAddress("glVertexAttrib1sv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib2d = (GLEEPFNGLVERTEXATTRIB2DPROC) __GLeeGetProcAddress("glVertexAttrib2d"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib2dv = (GLEEPFNGLVERTEXATTRIB2DVPROC) __GLeeGetProcAddress("glVertexAttrib2dv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib2f = (GLEEPFNGLVERTEXATTRIB2FPROC) __GLeeGetProcAddress("glVertexAttrib2f"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib2fv = (GLEEPFNGLVERTEXATTRIB2FVPROC) __GLeeGetProcAddress("glVertexAttrib2fv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib2s = (GLEEPFNGLVERTEXATTRIB2SPROC) __GLeeGetProcAddress("glVertexAttrib2s"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib2sv = (GLEEPFNGLVERTEXATTRIB2SVPROC) __GLeeGetProcAddress("glVertexAttrib2sv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib3d = (GLEEPFNGLVERTEXATTRIB3DPROC) __GLeeGetProcAddress("glVertexAttrib3d"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib3dv = (GLEEPFNGLVERTEXATTRIB3DVPROC) __GLeeGetProcAddress("glVertexAttrib3dv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib3f = (GLEEPFNGLVERTEXATTRIB3FPROC) __GLeeGetProcAddress("glVertexAttrib3f"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib3fv = (GLEEPFNGLVERTEXATTRIB3FVPROC) __GLeeGetProcAddress("glVertexAttrib3fv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib3s = (GLEEPFNGLVERTEXATTRIB3SPROC) __GLeeGetProcAddress("glVertexAttrib3s"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib3sv = (GLEEPFNGLVERTEXATTRIB3SVPROC) __GLeeGetProcAddress("glVertexAttrib3sv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4Nbv = (GLEEPFNGLVERTEXATTRIB4NBVPROC) __GLeeGetProcAddress("glVertexAttrib4Nbv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4Niv = (GLEEPFNGLVERTEXATTRIB4NIVPROC) __GLeeGetProcAddress("glVertexAttrib4Niv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4Nsv = (GLEEPFNGLVERTEXATTRIB4NSVPROC) __GLeeGetProcAddress("glVertexAttrib4Nsv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4Nub = (GLEEPFNGLVERTEXATTRIB4NUBPROC) __GLeeGetProcAddress("glVertexAttrib4Nub"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4Nubv = (GLEEPFNGLVERTEXATTRIB4NUBVPROC) __GLeeGetProcAddress("glVertexAttrib4Nubv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4Nuiv = (GLEEPFNGLVERTEXATTRIB4NUIVPROC) __GLeeGetProcAddress("glVertexAttrib4Nuiv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4Nusv = (GLEEPFNGLVERTEXATTRIB4NUSVPROC) __GLeeGetProcAddress("glVertexAttrib4Nusv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4bv = (GLEEPFNGLVERTEXATTRIB4BVPROC) __GLeeGetProcAddress("glVertexAttrib4bv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4d = (GLEEPFNGLVERTEXATTRIB4DPROC) __GLeeGetProcAddress("glVertexAttrib4d"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4dv = (GLEEPFNGLVERTEXATTRIB4DVPROC) __GLeeGetProcAddress("glVertexAttrib4dv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4f = (GLEEPFNGLVERTEXATTRIB4FPROC) __GLeeGetProcAddress("glVertexAttrib4f"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4fv = (GLEEPFNGLVERTEXATTRIB4FVPROC) __GLeeGetProcAddress("glVertexAttrib4fv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4iv = (GLEEPFNGLVERTEXATTRIB4IVPROC) __GLeeGetProcAddress("glVertexAttrib4iv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4s = (GLEEPFNGLVERTEXATTRIB4SPROC) __GLeeGetProcAddress("glVertexAttrib4s"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4sv = (GLEEPFNGLVERTEXATTRIB4SVPROC) __GLeeGetProcAddress("glVertexAttrib4sv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4ubv = (GLEEPFNGLVERTEXATTRIB4UBVPROC) __GLeeGetProcAddress("glVertexAttrib4ubv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4uiv = (GLEEPFNGLVERTEXATTRIB4UIVPROC) __GLeeGetProcAddress("glVertexAttrib4uiv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4usv = (GLEEPFNGLVERTEXATTRIB4USVPROC) __GLeeGetProcAddress("glVertexAttrib4usv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribPointer = (GLEEPFNGLVERTEXATTRIBPOINTERPROC) __GLeeGetProcAddress("glVertexAttribPointer"))!=0) nLinked++;
#endif
if (nLinked==93) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_VERSION_2_1(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_VERSION_2_1
if ((GLeeFuncPtr_glUniformMatrix2x3fv = (GLEEPFNGLUNIFORMMATRIX2X3FVPROC) __GLeeGetProcAddress("glUniformMatrix2x3fv"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniformMatrix3x2fv = (GLEEPFNGLUNIFORMMATRIX3X2FVPROC) __GLeeGetProcAddress("glUniformMatrix3x2fv"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniformMatrix2x4fv = (GLEEPFNGLUNIFORMMATRIX2X4FVPROC) __GLeeGetProcAddress("glUniformMatrix2x4fv"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniformMatrix4x2fv = (GLEEPFNGLUNIFORMMATRIX4X2FVPROC) __GLeeGetProcAddress("glUniformMatrix4x2fv"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniformMatrix3x4fv = (GLEEPFNGLUNIFORMMATRIX3X4FVPROC) __GLeeGetProcAddress("glUniformMatrix3x4fv"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniformMatrix4x3fv = (GLEEPFNGLUNIFORMMATRIX4X3FVPROC) __GLeeGetProcAddress("glUniformMatrix4x3fv"))!=0) nLinked++;
#endif
if (nLinked==6) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_VERSION_3_0(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_VERSION_3_0
if ((GLeeFuncPtr_glColorMaski = (GLEEPFNGLCOLORMASKIPROC) __GLeeGetProcAddress("glColorMaski"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetBooleani_v = (GLEEPFNGLGETBOOLEANI_VPROC) __GLeeGetProcAddress("glGetBooleani_v"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetIntegeri_v = (GLEEPFNGLGETINTEGERI_VPROC) __GLeeGetProcAddress("glGetIntegeri_v"))!=0) nLinked++;
if ((GLeeFuncPtr_glEnablei = (GLEEPFNGLENABLEIPROC) __GLeeGetProcAddress("glEnablei"))!=0) nLinked++;
if ((GLeeFuncPtr_glDisablei = (GLEEPFNGLDISABLEIPROC) __GLeeGetProcAddress("glDisablei"))!=0) nLinked++;
if ((GLeeFuncPtr_glIsEnabledi = (GLEEPFNGLISENABLEDIPROC) __GLeeGetProcAddress("glIsEnabledi"))!=0) nLinked++;
if ((GLeeFuncPtr_glBeginTransformFeedback = (GLEEPFNGLBEGINTRANSFORMFEEDBACKPROC) __GLeeGetProcAddress("glBeginTransformFeedback"))!=0) nLinked++;
if ((GLeeFuncPtr_glEndTransformFeedback = (GLEEPFNGLENDTRANSFORMFEEDBACKPROC) __GLeeGetProcAddress("glEndTransformFeedback"))!=0) nLinked++;
if ((GLeeFuncPtr_glBindBufferRange = (GLEEPFNGLBINDBUFFERRANGEPROC) __GLeeGetProcAddress("glBindBufferRange"))!=0) nLinked++;
if ((GLeeFuncPtr_glBindBufferBase = (GLEEPFNGLBINDBUFFERBASEPROC) __GLeeGetProcAddress("glBindBufferBase"))!=0) nLinked++;
if ((GLeeFuncPtr_glTransformFeedbackVaryings = (GLEEPFNGLTRANSFORMFEEDBACKVARYINGSPROC) __GLeeGetProcAddress("glTransformFeedbackVaryings"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetTransformFeedbackVarying = (GLEEPFNGLGETTRANSFORMFEEDBACKVARYINGPROC) __GLeeGetProcAddress("glGetTransformFeedbackVarying"))!=0) nLinked++;
if ((GLeeFuncPtr_glClampColor = (GLEEPFNGLCLAMPCOLORPROC) __GLeeGetProcAddress("glClampColor"))!=0) nLinked++;
if ((GLeeFuncPtr_glBeginConditionalRender = (GLEEPFNGLBEGINCONDITIONALRENDERPROC) __GLeeGetProcAddress("glBeginConditionalRender"))!=0) nLinked++;
if ((GLeeFuncPtr_glEndConditionalRender = (GLEEPFNGLENDCONDITIONALRENDERPROC) __GLeeGetProcAddress("glEndConditionalRender"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI1i = (GLEEPFNGLVERTEXATTRIBI1IPROC) __GLeeGetProcAddress("glVertexAttribI1i"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI2i = (GLEEPFNGLVERTEXATTRIBI2IPROC) __GLeeGetProcAddress("glVertexAttribI2i"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI3i = (GLEEPFNGLVERTEXATTRIBI3IPROC) __GLeeGetProcAddress("glVertexAttribI3i"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI4i = (GLEEPFNGLVERTEXATTRIBI4IPROC) __GLeeGetProcAddress("glVertexAttribI4i"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI1ui = (GLEEPFNGLVERTEXATTRIBI1UIPROC) __GLeeGetProcAddress("glVertexAttribI1ui"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI2ui = (GLEEPFNGLVERTEXATTRIBI2UIPROC) __GLeeGetProcAddress("glVertexAttribI2ui"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI3ui = (GLEEPFNGLVERTEXATTRIBI3UIPROC) __GLeeGetProcAddress("glVertexAttribI3ui"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI4ui = (GLEEPFNGLVERTEXATTRIBI4UIPROC) __GLeeGetProcAddress("glVertexAttribI4ui"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI1iv = (GLEEPFNGLVERTEXATTRIBI1IVPROC) __GLeeGetProcAddress("glVertexAttribI1iv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI2iv = (GLEEPFNGLVERTEXATTRIBI2IVPROC) __GLeeGetProcAddress("glVertexAttribI2iv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI3iv = (GLEEPFNGLVERTEXATTRIBI3IVPROC) __GLeeGetProcAddress("glVertexAttribI3iv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI4iv = (GLEEPFNGLVERTEXATTRIBI4IVPROC) __GLeeGetProcAddress("glVertexAttribI4iv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI1uiv = (GLEEPFNGLVERTEXATTRIBI1UIVPROC) __GLeeGetProcAddress("glVertexAttribI1uiv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI2uiv = (GLEEPFNGLVERTEXATTRIBI2UIVPROC) __GLeeGetProcAddress("glVertexAttribI2uiv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI3uiv = (GLEEPFNGLVERTEXATTRIBI3UIVPROC) __GLeeGetProcAddress("glVertexAttribI3uiv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI4uiv = (GLEEPFNGLVERTEXATTRIBI4UIVPROC) __GLeeGetProcAddress("glVertexAttribI4uiv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI4bv = (GLEEPFNGLVERTEXATTRIBI4BVPROC) __GLeeGetProcAddress("glVertexAttribI4bv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI4sv = (GLEEPFNGLVERTEXATTRIBI4SVPROC) __GLeeGetProcAddress("glVertexAttribI4sv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI4ubv = (GLEEPFNGLVERTEXATTRIBI4UBVPROC) __GLeeGetProcAddress("glVertexAttribI4ubv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI4usv = (GLEEPFNGLVERTEXATTRIBI4USVPROC) __GLeeGetProcAddress("glVertexAttribI4usv"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribIPointer = (GLEEPFNGLVERTEXATTRIBIPOINTERPROC) __GLeeGetProcAddress("glVertexAttribIPointer"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetVertexAttribIiv = (GLEEPFNGLGETVERTEXATTRIBIIVPROC) __GLeeGetProcAddress("glGetVertexAttribIiv"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetVertexAttribIuiv = (GLEEPFNGLGETVERTEXATTRIBIUIVPROC) __GLeeGetProcAddress("glGetVertexAttribIuiv"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetUniformuiv = (GLEEPFNGLGETUNIFORMUIVPROC) __GLeeGetProcAddress("glGetUniformuiv"))!=0) nLinked++;
if ((GLeeFuncPtr_glBindFragDataLocation = (GLEEPFNGLBINDFRAGDATALOCATIONPROC) __GLeeGetProcAddress("glBindFragDataLocation"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetFragDataLocation = (GLEEPFNGLGETFRAGDATALOCATIONPROC) __GLeeGetProcAddress("glGetFragDataLocation"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform1ui = (GLEEPFNGLUNIFORM1UIPROC) __GLeeGetProcAddress("glUniform1ui"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform2ui = (GLEEPFNGLUNIFORM2UIPROC) __GLeeGetProcAddress("glUniform2ui"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform3ui = (GLEEPFNGLUNIFORM3UIPROC) __GLeeGetProcAddress("glUniform3ui"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform4ui = (GLEEPFNGLUNIFORM4UIPROC) __GLeeGetProcAddress("glUniform4ui"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform1uiv = (GLEEPFNGLUNIFORM1UIVPROC) __GLeeGetProcAddress("glUniform1uiv"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform2uiv = (GLEEPFNGLUNIFORM2UIVPROC) __GLeeGetProcAddress("glUniform2uiv"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform3uiv = (GLEEPFNGLUNIFORM3UIVPROC) __GLeeGetProcAddress("glUniform3uiv"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform4uiv = (GLEEPFNGLUNIFORM4UIVPROC) __GLeeGetProcAddress("glUniform4uiv"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexParameterIiv = (GLEEPFNGLTEXPARAMETERIIVPROC) __GLeeGetProcAddress("glTexParameterIiv"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexParameterIuiv = (GLEEPFNGLTEXPARAMETERIUIVPROC) __GLeeGetProcAddress("glTexParameterIuiv"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetTexParameterIiv = (GLEEPFNGLGETTEXPARAMETERIIVPROC) __GLeeGetProcAddress("glGetTexParameterIiv"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetTexParameterIuiv = (GLEEPFNGLGETTEXPARAMETERIUIVPROC) __GLeeGetProcAddress("glGetTexParameterIuiv"))!=0) nLinked++;
if ((GLeeFuncPtr_glClearBufferiv = (GLEEPFNGLCLEARBUFFERIVPROC) __GLeeGetProcAddress("glClearBufferiv"))!=0) nLinked++;
if ((GLeeFuncPtr_glClearBufferuiv = (GLEEPFNGLCLEARBUFFERUIVPROC) __GLeeGetProcAddress("glClearBufferuiv"))!=0) nLinked++;
if ((GLeeFuncPtr_glClearBufferfv = (GLEEPFNGLCLEARBUFFERFVPROC) __GLeeGetProcAddress("glClearBufferfv"))!=0) nLinked++;
if ((GLeeFuncPtr_glClearBufferfi = (GLEEPFNGLCLEARBUFFERFIPROC) __GLeeGetProcAddress("glClearBufferfi"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetStringi = (GLEEPFNGLGETSTRINGIPROC) __GLeeGetProcAddress("glGetStringi"))!=0) nLinked++;
#endif
if (nLinked==58) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ARB_multitexture(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ARB_multitexture
if ((GLeeFuncPtr_glActiveTextureARB = (GLEEPFNGLACTIVETEXTUREARBPROC) __GLeeGetProcAddress("glActiveTextureARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glClientActiveTextureARB = (GLEEPFNGLCLIENTACTIVETEXTUREARBPROC) __GLeeGetProcAddress("glClientActiveTextureARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord1dARB = (GLEEPFNGLMULTITEXCOORD1DARBPROC) __GLeeGetProcAddress("glMultiTexCoord1dARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord1dvARB = (GLEEPFNGLMULTITEXCOORD1DVARBPROC) __GLeeGetProcAddress("glMultiTexCoord1dvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord1fARB = (GLEEPFNGLMULTITEXCOORD1FARBPROC) __GLeeGetProcAddress("glMultiTexCoord1fARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord1fvARB = (GLEEPFNGLMULTITEXCOORD1FVARBPROC) __GLeeGetProcAddress("glMultiTexCoord1fvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord1iARB = (GLEEPFNGLMULTITEXCOORD1IARBPROC) __GLeeGetProcAddress("glMultiTexCoord1iARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord1ivARB = (GLEEPFNGLMULTITEXCOORD1IVARBPROC) __GLeeGetProcAddress("glMultiTexCoord1ivARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord1sARB = (GLEEPFNGLMULTITEXCOORD1SARBPROC) __GLeeGetProcAddress("glMultiTexCoord1sARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord1svARB = (GLEEPFNGLMULTITEXCOORD1SVARBPROC) __GLeeGetProcAddress("glMultiTexCoord1svARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord2dARB = (GLEEPFNGLMULTITEXCOORD2DARBPROC) __GLeeGetProcAddress("glMultiTexCoord2dARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord2dvARB = (GLEEPFNGLMULTITEXCOORD2DVARBPROC) __GLeeGetProcAddress("glMultiTexCoord2dvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord2fARB = (GLEEPFNGLMULTITEXCOORD2FARBPROC) __GLeeGetProcAddress("glMultiTexCoord2fARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord2fvARB = (GLEEPFNGLMULTITEXCOORD2FVARBPROC) __GLeeGetProcAddress("glMultiTexCoord2fvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord2iARB = (GLEEPFNGLMULTITEXCOORD2IARBPROC) __GLeeGetProcAddress("glMultiTexCoord2iARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord2ivARB = (GLEEPFNGLMULTITEXCOORD2IVARBPROC) __GLeeGetProcAddress("glMultiTexCoord2ivARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord2sARB = (GLEEPFNGLMULTITEXCOORD2SARBPROC) __GLeeGetProcAddress("glMultiTexCoord2sARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord2svARB = (GLEEPFNGLMULTITEXCOORD2SVARBPROC) __GLeeGetProcAddress("glMultiTexCoord2svARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord3dARB = (GLEEPFNGLMULTITEXCOORD3DARBPROC) __GLeeGetProcAddress("glMultiTexCoord3dARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord3dvARB = (GLEEPFNGLMULTITEXCOORD3DVARBPROC) __GLeeGetProcAddress("glMultiTexCoord3dvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord3fARB = (GLEEPFNGLMULTITEXCOORD3FARBPROC) __GLeeGetProcAddress("glMultiTexCoord3fARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord3fvARB = (GLEEPFNGLMULTITEXCOORD3FVARBPROC) __GLeeGetProcAddress("glMultiTexCoord3fvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord3iARB = (GLEEPFNGLMULTITEXCOORD3IARBPROC) __GLeeGetProcAddress("glMultiTexCoord3iARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord3ivARB = (GLEEPFNGLMULTITEXCOORD3IVARBPROC) __GLeeGetProcAddress("glMultiTexCoord3ivARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord3sARB = (GLEEPFNGLMULTITEXCOORD3SARBPROC) __GLeeGetProcAddress("glMultiTexCoord3sARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord3svARB = (GLEEPFNGLMULTITEXCOORD3SVARBPROC) __GLeeGetProcAddress("glMultiTexCoord3svARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord4dARB = (GLEEPFNGLMULTITEXCOORD4DARBPROC) __GLeeGetProcAddress("glMultiTexCoord4dARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord4dvARB = (GLEEPFNGLMULTITEXCOORD4DVARBPROC) __GLeeGetProcAddress("glMultiTexCoord4dvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord4fARB = (GLEEPFNGLMULTITEXCOORD4FARBPROC) __GLeeGetProcAddress("glMultiTexCoord4fARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord4fvARB = (GLEEPFNGLMULTITEXCOORD4FVARBPROC) __GLeeGetProcAddress("glMultiTexCoord4fvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord4iARB = (GLEEPFNGLMULTITEXCOORD4IARBPROC) __GLeeGetProcAddress("glMultiTexCoord4iARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord4ivARB = (GLEEPFNGLMULTITEXCOORD4IVARBPROC) __GLeeGetProcAddress("glMultiTexCoord4ivARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord4sARB = (GLEEPFNGLMULTITEXCOORD4SARBPROC) __GLeeGetProcAddress("glMultiTexCoord4sARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord4svARB = (GLEEPFNGLMULTITEXCOORD4SVARBPROC) __GLeeGetProcAddress("glMultiTexCoord4svARB"))!=0) nLinked++;
#endif
if (nLinked==34) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ARB_transpose_matrix(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ARB_transpose_matrix
if ((GLeeFuncPtr_glLoadTransposeMatrixfARB = (GLEEPFNGLLOADTRANSPOSEMATRIXFARBPROC) __GLeeGetProcAddress("glLoadTransposeMatrixfARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glLoadTransposeMatrixdARB = (GLEEPFNGLLOADTRANSPOSEMATRIXDARBPROC) __GLeeGetProcAddress("glLoadTransposeMatrixdARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultTransposeMatrixfARB = (GLEEPFNGLMULTTRANSPOSEMATRIXFARBPROC) __GLeeGetProcAddress("glMultTransposeMatrixfARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultTransposeMatrixdARB = (GLEEPFNGLMULTTRANSPOSEMATRIXDARBPROC) __GLeeGetProcAddress("glMultTransposeMatrixdARB"))!=0) nLinked++;
#endif
if (nLinked==4) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ARB_multisample(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ARB_multisample
if ((GLeeFuncPtr_glSampleCoverageARB = (GLEEPFNGLSAMPLECOVERAGEARBPROC) __GLeeGetProcAddress("glSampleCoverageARB"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ARB_texture_env_add(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ARB_texture_cube_map(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ARB_texture_compression(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ARB_texture_compression
if ((GLeeFuncPtr_glCompressedTexImage3DARB = (GLEEPFNGLCOMPRESSEDTEXIMAGE3DARBPROC) __GLeeGetProcAddress("glCompressedTexImage3DARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glCompressedTexImage2DARB = (GLEEPFNGLCOMPRESSEDTEXIMAGE2DARBPROC) __GLeeGetProcAddress("glCompressedTexImage2DARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glCompressedTexImage1DARB = (GLEEPFNGLCOMPRESSEDTEXIMAGE1DARBPROC) __GLeeGetProcAddress("glCompressedTexImage1DARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glCompressedTexSubImage3DARB = (GLEEPFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC) __GLeeGetProcAddress("glCompressedTexSubImage3DARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glCompressedTexSubImage2DARB = (GLEEPFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC) __GLeeGetProcAddress("glCompressedTexSubImage2DARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glCompressedTexSubImage1DARB = (GLEEPFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC) __GLeeGetProcAddress("glCompressedTexSubImage1DARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetCompressedTexImageARB = (GLEEPFNGLGETCOMPRESSEDTEXIMAGEARBPROC) __GLeeGetProcAddress("glGetCompressedTexImageARB"))!=0) nLinked++;
#endif
if (nLinked==7) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ARB_texture_border_clamp(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ARB_point_parameters(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ARB_point_parameters
if ((GLeeFuncPtr_glPointParameterfARB = (GLEEPFNGLPOINTPARAMETERFARBPROC) __GLeeGetProcAddress("glPointParameterfARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glPointParameterfvARB = (GLEEPFNGLPOINTPARAMETERFVARBPROC) __GLeeGetProcAddress("glPointParameterfvARB"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ARB_vertex_blend(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ARB_vertex_blend
if ((GLeeFuncPtr_glWeightbvARB = (GLEEPFNGLWEIGHTBVARBPROC) __GLeeGetProcAddress("glWeightbvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glWeightsvARB = (GLEEPFNGLWEIGHTSVARBPROC) __GLeeGetProcAddress("glWeightsvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glWeightivARB = (GLEEPFNGLWEIGHTIVARBPROC) __GLeeGetProcAddress("glWeightivARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glWeightfvARB = (GLEEPFNGLWEIGHTFVARBPROC) __GLeeGetProcAddress("glWeightfvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glWeightdvARB = (GLEEPFNGLWEIGHTDVARBPROC) __GLeeGetProcAddress("glWeightdvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glWeightubvARB = (GLEEPFNGLWEIGHTUBVARBPROC) __GLeeGetProcAddress("glWeightubvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glWeightusvARB = (GLEEPFNGLWEIGHTUSVARBPROC) __GLeeGetProcAddress("glWeightusvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glWeightuivARB = (GLEEPFNGLWEIGHTUIVARBPROC) __GLeeGetProcAddress("glWeightuivARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glWeightPointerARB = (GLEEPFNGLWEIGHTPOINTERARBPROC) __GLeeGetProcAddress("glWeightPointerARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexBlendARB = (GLEEPFNGLVERTEXBLENDARBPROC) __GLeeGetProcAddress("glVertexBlendARB"))!=0) nLinked++;
#endif
if (nLinked==10) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ARB_matrix_palette(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ARB_matrix_palette
if ((GLeeFuncPtr_glCurrentPaletteMatrixARB = (GLEEPFNGLCURRENTPALETTEMATRIXARBPROC) __GLeeGetProcAddress("glCurrentPaletteMatrixARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMatrixIndexubvARB = (GLEEPFNGLMATRIXINDEXUBVARBPROC) __GLeeGetProcAddress("glMatrixIndexubvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMatrixIndexusvARB = (GLEEPFNGLMATRIXINDEXUSVARBPROC) __GLeeGetProcAddress("glMatrixIndexusvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMatrixIndexuivARB = (GLEEPFNGLMATRIXINDEXUIVARBPROC) __GLeeGetProcAddress("glMatrixIndexuivARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMatrixIndexPointerARB = (GLEEPFNGLMATRIXINDEXPOINTERARBPROC) __GLeeGetProcAddress("glMatrixIndexPointerARB"))!=0) nLinked++;
#endif
if (nLinked==5) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ARB_texture_env_combine(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ARB_texture_env_crossbar(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ARB_texture_env_dot3(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ARB_texture_mirrored_repeat(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ARB_depth_texture(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ARB_shadow(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ARB_shadow_ambient(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ARB_window_pos(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ARB_window_pos
if ((GLeeFuncPtr_glWindowPos2dARB = (GLEEPFNGLWINDOWPOS2DARBPROC) __GLeeGetProcAddress("glWindowPos2dARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos2dvARB = (GLEEPFNGLWINDOWPOS2DVARBPROC) __GLeeGetProcAddress("glWindowPos2dvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos2fARB = (GLEEPFNGLWINDOWPOS2FARBPROC) __GLeeGetProcAddress("glWindowPos2fARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos2fvARB = (GLEEPFNGLWINDOWPOS2FVARBPROC) __GLeeGetProcAddress("glWindowPos2fvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos2iARB = (GLEEPFNGLWINDOWPOS2IARBPROC) __GLeeGetProcAddress("glWindowPos2iARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos2ivARB = (GLEEPFNGLWINDOWPOS2IVARBPROC) __GLeeGetProcAddress("glWindowPos2ivARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos2sARB = (GLEEPFNGLWINDOWPOS2SARBPROC) __GLeeGetProcAddress("glWindowPos2sARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos2svARB = (GLEEPFNGLWINDOWPOS2SVARBPROC) __GLeeGetProcAddress("glWindowPos2svARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos3dARB = (GLEEPFNGLWINDOWPOS3DARBPROC) __GLeeGetProcAddress("glWindowPos3dARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos3dvARB = (GLEEPFNGLWINDOWPOS3DVARBPROC) __GLeeGetProcAddress("glWindowPos3dvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos3fARB = (GLEEPFNGLWINDOWPOS3FARBPROC) __GLeeGetProcAddress("glWindowPos3fARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos3fvARB = (GLEEPFNGLWINDOWPOS3FVARBPROC) __GLeeGetProcAddress("glWindowPos3fvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos3iARB = (GLEEPFNGLWINDOWPOS3IARBPROC) __GLeeGetProcAddress("glWindowPos3iARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos3ivARB = (GLEEPFNGLWINDOWPOS3IVARBPROC) __GLeeGetProcAddress("glWindowPos3ivARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos3sARB = (GLEEPFNGLWINDOWPOS3SARBPROC) __GLeeGetProcAddress("glWindowPos3sARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos3svARB = (GLEEPFNGLWINDOWPOS3SVARBPROC) __GLeeGetProcAddress("glWindowPos3svARB"))!=0) nLinked++;
#endif
if (nLinked==16) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ARB_vertex_program(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ARB_vertex_program
if ((GLeeFuncPtr_glVertexAttrib1dARB = (GLEEPFNGLVERTEXATTRIB1DARBPROC) __GLeeGetProcAddress("glVertexAttrib1dARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib1dvARB = (GLEEPFNGLVERTEXATTRIB1DVARBPROC) __GLeeGetProcAddress("glVertexAttrib1dvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib1fARB = (GLEEPFNGLVERTEXATTRIB1FARBPROC) __GLeeGetProcAddress("glVertexAttrib1fARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib1fvARB = (GLEEPFNGLVERTEXATTRIB1FVARBPROC) __GLeeGetProcAddress("glVertexAttrib1fvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib1sARB = (GLEEPFNGLVERTEXATTRIB1SARBPROC) __GLeeGetProcAddress("glVertexAttrib1sARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib1svARB = (GLEEPFNGLVERTEXATTRIB1SVARBPROC) __GLeeGetProcAddress("glVertexAttrib1svARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib2dARB = (GLEEPFNGLVERTEXATTRIB2DARBPROC) __GLeeGetProcAddress("glVertexAttrib2dARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib2dvARB = (GLEEPFNGLVERTEXATTRIB2DVARBPROC) __GLeeGetProcAddress("glVertexAttrib2dvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib2fARB = (GLEEPFNGLVERTEXATTRIB2FARBPROC) __GLeeGetProcAddress("glVertexAttrib2fARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib2fvARB = (GLEEPFNGLVERTEXATTRIB2FVARBPROC) __GLeeGetProcAddress("glVertexAttrib2fvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib2sARB = (GLEEPFNGLVERTEXATTRIB2SARBPROC) __GLeeGetProcAddress("glVertexAttrib2sARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib2svARB = (GLEEPFNGLVERTEXATTRIB2SVARBPROC) __GLeeGetProcAddress("glVertexAttrib2svARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib3dARB = (GLEEPFNGLVERTEXATTRIB3DARBPROC) __GLeeGetProcAddress("glVertexAttrib3dARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib3dvARB = (GLEEPFNGLVERTEXATTRIB3DVARBPROC) __GLeeGetProcAddress("glVertexAttrib3dvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib3fARB = (GLEEPFNGLVERTEXATTRIB3FARBPROC) __GLeeGetProcAddress("glVertexAttrib3fARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib3fvARB = (GLEEPFNGLVERTEXATTRIB3FVARBPROC) __GLeeGetProcAddress("glVertexAttrib3fvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib3sARB = (GLEEPFNGLVERTEXATTRIB3SARBPROC) __GLeeGetProcAddress("glVertexAttrib3sARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib3svARB = (GLEEPFNGLVERTEXATTRIB3SVARBPROC) __GLeeGetProcAddress("glVertexAttrib3svARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4NbvARB = (GLEEPFNGLVERTEXATTRIB4NBVARBPROC) __GLeeGetProcAddress("glVertexAttrib4NbvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4NivARB = (GLEEPFNGLVERTEXATTRIB4NIVARBPROC) __GLeeGetProcAddress("glVertexAttrib4NivARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4NsvARB = (GLEEPFNGLVERTEXATTRIB4NSVARBPROC) __GLeeGetProcAddress("glVertexAttrib4NsvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4NubARB = (GLEEPFNGLVERTEXATTRIB4NUBARBPROC) __GLeeGetProcAddress("glVertexAttrib4NubARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4NubvARB = (GLEEPFNGLVERTEXATTRIB4NUBVARBPROC) __GLeeGetProcAddress("glVertexAttrib4NubvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4NuivARB = (GLEEPFNGLVERTEXATTRIB4NUIVARBPROC) __GLeeGetProcAddress("glVertexAttrib4NuivARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4NusvARB = (GLEEPFNGLVERTEXATTRIB4NUSVARBPROC) __GLeeGetProcAddress("glVertexAttrib4NusvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4bvARB = (GLEEPFNGLVERTEXATTRIB4BVARBPROC) __GLeeGetProcAddress("glVertexAttrib4bvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4dARB = (GLEEPFNGLVERTEXATTRIB4DARBPROC) __GLeeGetProcAddress("glVertexAttrib4dARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4dvARB = (GLEEPFNGLVERTEXATTRIB4DVARBPROC) __GLeeGetProcAddress("glVertexAttrib4dvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4fARB = (GLEEPFNGLVERTEXATTRIB4FARBPROC) __GLeeGetProcAddress("glVertexAttrib4fARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4fvARB = (GLEEPFNGLVERTEXATTRIB4FVARBPROC) __GLeeGetProcAddress("glVertexAttrib4fvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4ivARB = (GLEEPFNGLVERTEXATTRIB4IVARBPROC) __GLeeGetProcAddress("glVertexAttrib4ivARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4sARB = (GLEEPFNGLVERTEXATTRIB4SARBPROC) __GLeeGetProcAddress("glVertexAttrib4sARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4svARB = (GLEEPFNGLVERTEXATTRIB4SVARBPROC) __GLeeGetProcAddress("glVertexAttrib4svARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4ubvARB = (GLEEPFNGLVERTEXATTRIB4UBVARBPROC) __GLeeGetProcAddress("glVertexAttrib4ubvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4uivARB = (GLEEPFNGLVERTEXATTRIB4UIVARBPROC) __GLeeGetProcAddress("glVertexAttrib4uivARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4usvARB = (GLEEPFNGLVERTEXATTRIB4USVARBPROC) __GLeeGetProcAddress("glVertexAttrib4usvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribPointerARB = (GLEEPFNGLVERTEXATTRIBPOINTERARBPROC) __GLeeGetProcAddress("glVertexAttribPointerARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glEnableVertexAttribArrayARB = (GLEEPFNGLENABLEVERTEXATTRIBARRAYARBPROC) __GLeeGetProcAddress("glEnableVertexAttribArrayARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glDisableVertexAttribArrayARB = (GLEEPFNGLDISABLEVERTEXATTRIBARRAYARBPROC) __GLeeGetProcAddress("glDisableVertexAttribArrayARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramStringARB = (GLEEPFNGLPROGRAMSTRINGARBPROC) __GLeeGetProcAddress("glProgramStringARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glBindProgramARB = (GLEEPFNGLBINDPROGRAMARBPROC) __GLeeGetProcAddress("glBindProgramARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glDeleteProgramsARB = (GLEEPFNGLDELETEPROGRAMSARBPROC) __GLeeGetProcAddress("glDeleteProgramsARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGenProgramsARB = (GLEEPFNGLGENPROGRAMSARBPROC) __GLeeGetProcAddress("glGenProgramsARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramEnvParameter4dARB = (GLEEPFNGLPROGRAMENVPARAMETER4DARBPROC) __GLeeGetProcAddress("glProgramEnvParameter4dARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramEnvParameter4dvARB = (GLEEPFNGLPROGRAMENVPARAMETER4DVARBPROC) __GLeeGetProcAddress("glProgramEnvParameter4dvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramEnvParameter4fARB = (GLEEPFNGLPROGRAMENVPARAMETER4FARBPROC) __GLeeGetProcAddress("glProgramEnvParameter4fARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramEnvParameter4fvARB = (GLEEPFNGLPROGRAMENVPARAMETER4FVARBPROC) __GLeeGetProcAddress("glProgramEnvParameter4fvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramLocalParameter4dARB = (GLEEPFNGLPROGRAMLOCALPARAMETER4DARBPROC) __GLeeGetProcAddress("glProgramLocalParameter4dARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramLocalParameter4dvARB = (GLEEPFNGLPROGRAMLOCALPARAMETER4DVARBPROC) __GLeeGetProcAddress("glProgramLocalParameter4dvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramLocalParameter4fARB = (GLEEPFNGLPROGRAMLOCALPARAMETER4FARBPROC) __GLeeGetProcAddress("glProgramLocalParameter4fARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramLocalParameter4fvARB = (GLEEPFNGLPROGRAMLOCALPARAMETER4FVARBPROC) __GLeeGetProcAddress("glProgramLocalParameter4fvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetProgramEnvParameterdvARB = (GLEEPFNGLGETPROGRAMENVPARAMETERDVARBPROC) __GLeeGetProcAddress("glGetProgramEnvParameterdvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetProgramEnvParameterfvARB = (GLEEPFNGLGETPROGRAMENVPARAMETERFVARBPROC) __GLeeGetProcAddress("glGetProgramEnvParameterfvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetProgramLocalParameterdvARB = (GLEEPFNGLGETPROGRAMLOCALPARAMETERDVARBPROC) __GLeeGetProcAddress("glGetProgramLocalParameterdvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetProgramLocalParameterfvARB = (GLEEPFNGLGETPROGRAMLOCALPARAMETERFVARBPROC) __GLeeGetProcAddress("glGetProgramLocalParameterfvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetProgramivARB = (GLEEPFNGLGETPROGRAMIVARBPROC) __GLeeGetProcAddress("glGetProgramivARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetProgramStringARB = (GLEEPFNGLGETPROGRAMSTRINGARBPROC) __GLeeGetProcAddress("glGetProgramStringARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetVertexAttribdvARB = (GLEEPFNGLGETVERTEXATTRIBDVARBPROC) __GLeeGetProcAddress("glGetVertexAttribdvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetVertexAttribfvARB = (GLEEPFNGLGETVERTEXATTRIBFVARBPROC) __GLeeGetProcAddress("glGetVertexAttribfvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetVertexAttribivARB = (GLEEPFNGLGETVERTEXATTRIBIVARBPROC) __GLeeGetProcAddress("glGetVertexAttribivARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetVertexAttribPointervARB = (GLEEPFNGLGETVERTEXATTRIBPOINTERVARBPROC) __GLeeGetProcAddress("glGetVertexAttribPointervARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glIsProgramARB = (GLEEPFNGLISPROGRAMARBPROC) __GLeeGetProcAddress("glIsProgramARB"))!=0) nLinked++;
#endif
if (nLinked==62) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ARB_fragment_program(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ARB_vertex_buffer_object(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ARB_vertex_buffer_object
if ((GLeeFuncPtr_glBindBufferARB = (GLEEPFNGLBINDBUFFERARBPROC) __GLeeGetProcAddress("glBindBufferARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glDeleteBuffersARB = (GLEEPFNGLDELETEBUFFERSARBPROC) __GLeeGetProcAddress("glDeleteBuffersARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGenBuffersARB = (GLEEPFNGLGENBUFFERSARBPROC) __GLeeGetProcAddress("glGenBuffersARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glIsBufferARB = (GLEEPFNGLISBUFFERARBPROC) __GLeeGetProcAddress("glIsBufferARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glBufferDataARB = (GLEEPFNGLBUFFERDATAARBPROC) __GLeeGetProcAddress("glBufferDataARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glBufferSubDataARB = (GLEEPFNGLBUFFERSUBDATAARBPROC) __GLeeGetProcAddress("glBufferSubDataARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetBufferSubDataARB = (GLEEPFNGLGETBUFFERSUBDATAARBPROC) __GLeeGetProcAddress("glGetBufferSubDataARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glMapBufferARB = (GLEEPFNGLMAPBUFFERARBPROC) __GLeeGetProcAddress("glMapBufferARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glUnmapBufferARB = (GLEEPFNGLUNMAPBUFFERARBPROC) __GLeeGetProcAddress("glUnmapBufferARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetBufferParameterivARB = (GLEEPFNGLGETBUFFERPARAMETERIVARBPROC) __GLeeGetProcAddress("glGetBufferParameterivARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetBufferPointervARB = (GLEEPFNGLGETBUFFERPOINTERVARBPROC) __GLeeGetProcAddress("glGetBufferPointervARB"))!=0) nLinked++;
#endif
if (nLinked==11) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ARB_occlusion_query(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ARB_occlusion_query
if ((GLeeFuncPtr_glGenQueriesARB = (GLEEPFNGLGENQUERIESARBPROC) __GLeeGetProcAddress("glGenQueriesARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glDeleteQueriesARB = (GLEEPFNGLDELETEQUERIESARBPROC) __GLeeGetProcAddress("glDeleteQueriesARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glIsQueryARB = (GLEEPFNGLISQUERYARBPROC) __GLeeGetProcAddress("glIsQueryARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glBeginQueryARB = (GLEEPFNGLBEGINQUERYARBPROC) __GLeeGetProcAddress("glBeginQueryARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glEndQueryARB = (GLEEPFNGLENDQUERYARBPROC) __GLeeGetProcAddress("glEndQueryARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetQueryivARB = (GLEEPFNGLGETQUERYIVARBPROC) __GLeeGetProcAddress("glGetQueryivARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetQueryObjectivARB = (GLEEPFNGLGETQUERYOBJECTIVARBPROC) __GLeeGetProcAddress("glGetQueryObjectivARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetQueryObjectuivARB = (GLEEPFNGLGETQUERYOBJECTUIVARBPROC) __GLeeGetProcAddress("glGetQueryObjectuivARB"))!=0) nLinked++;
#endif
if (nLinked==8) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ARB_shader_objects(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ARB_shader_objects
if ((GLeeFuncPtr_glDeleteObjectARB = (GLEEPFNGLDELETEOBJECTARBPROC) __GLeeGetProcAddress("glDeleteObjectARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetHandleARB = (GLEEPFNGLGETHANDLEARBPROC) __GLeeGetProcAddress("glGetHandleARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glDetachObjectARB = (GLEEPFNGLDETACHOBJECTARBPROC) __GLeeGetProcAddress("glDetachObjectARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glCreateShaderObjectARB = (GLEEPFNGLCREATESHADEROBJECTARBPROC) __GLeeGetProcAddress("glCreateShaderObjectARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glShaderSourceARB = (GLEEPFNGLSHADERSOURCEARBPROC) __GLeeGetProcAddress("glShaderSourceARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glCompileShaderARB = (GLEEPFNGLCOMPILESHADERARBPROC) __GLeeGetProcAddress("glCompileShaderARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glCreateProgramObjectARB = (GLEEPFNGLCREATEPROGRAMOBJECTARBPROC) __GLeeGetProcAddress("glCreateProgramObjectARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glAttachObjectARB = (GLEEPFNGLATTACHOBJECTARBPROC) __GLeeGetProcAddress("glAttachObjectARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glLinkProgramARB = (GLEEPFNGLLINKPROGRAMARBPROC) __GLeeGetProcAddress("glLinkProgramARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glUseProgramObjectARB = (GLEEPFNGLUSEPROGRAMOBJECTARBPROC) __GLeeGetProcAddress("glUseProgramObjectARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glValidateProgramARB = (GLEEPFNGLVALIDATEPROGRAMARBPROC) __GLeeGetProcAddress("glValidateProgramARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform1fARB = (GLEEPFNGLUNIFORM1FARBPROC) __GLeeGetProcAddress("glUniform1fARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform2fARB = (GLEEPFNGLUNIFORM2FARBPROC) __GLeeGetProcAddress("glUniform2fARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform3fARB = (GLEEPFNGLUNIFORM3FARBPROC) __GLeeGetProcAddress("glUniform3fARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform4fARB = (GLEEPFNGLUNIFORM4FARBPROC) __GLeeGetProcAddress("glUniform4fARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform1iARB = (GLEEPFNGLUNIFORM1IARBPROC) __GLeeGetProcAddress("glUniform1iARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform2iARB = (GLEEPFNGLUNIFORM2IARBPROC) __GLeeGetProcAddress("glUniform2iARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform3iARB = (GLEEPFNGLUNIFORM3IARBPROC) __GLeeGetProcAddress("glUniform3iARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform4iARB = (GLEEPFNGLUNIFORM4IARBPROC) __GLeeGetProcAddress("glUniform4iARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform1fvARB = (GLEEPFNGLUNIFORM1FVARBPROC) __GLeeGetProcAddress("glUniform1fvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform2fvARB = (GLEEPFNGLUNIFORM2FVARBPROC) __GLeeGetProcAddress("glUniform2fvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform3fvARB = (GLEEPFNGLUNIFORM3FVARBPROC) __GLeeGetProcAddress("glUniform3fvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform4fvARB = (GLEEPFNGLUNIFORM4FVARBPROC) __GLeeGetProcAddress("glUniform4fvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform1ivARB = (GLEEPFNGLUNIFORM1IVARBPROC) __GLeeGetProcAddress("glUniform1ivARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform2ivARB = (GLEEPFNGLUNIFORM2IVARBPROC) __GLeeGetProcAddress("glUniform2ivARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform3ivARB = (GLEEPFNGLUNIFORM3IVARBPROC) __GLeeGetProcAddress("glUniform3ivARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform4ivARB = (GLEEPFNGLUNIFORM4IVARBPROC) __GLeeGetProcAddress("glUniform4ivARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniformMatrix2fvARB = (GLEEPFNGLUNIFORMMATRIX2FVARBPROC) __GLeeGetProcAddress("glUniformMatrix2fvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniformMatrix3fvARB = (GLEEPFNGLUNIFORMMATRIX3FVARBPROC) __GLeeGetProcAddress("glUniformMatrix3fvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniformMatrix4fvARB = (GLEEPFNGLUNIFORMMATRIX4FVARBPROC) __GLeeGetProcAddress("glUniformMatrix4fvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetObjectParameterfvARB = (GLEEPFNGLGETOBJECTPARAMETERFVARBPROC) __GLeeGetProcAddress("glGetObjectParameterfvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetObjectParameterivARB = (GLEEPFNGLGETOBJECTPARAMETERIVARBPROC) __GLeeGetProcAddress("glGetObjectParameterivARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetInfoLogARB = (GLEEPFNGLGETINFOLOGARBPROC) __GLeeGetProcAddress("glGetInfoLogARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetAttachedObjectsARB = (GLEEPFNGLGETATTACHEDOBJECTSARBPROC) __GLeeGetProcAddress("glGetAttachedObjectsARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetUniformLocationARB = (GLEEPFNGLGETUNIFORMLOCATIONARBPROC) __GLeeGetProcAddress("glGetUniformLocationARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetActiveUniformARB = (GLEEPFNGLGETACTIVEUNIFORMARBPROC) __GLeeGetProcAddress("glGetActiveUniformARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetUniformfvARB = (GLEEPFNGLGETUNIFORMFVARBPROC) __GLeeGetProcAddress("glGetUniformfvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetUniformivARB = (GLEEPFNGLGETUNIFORMIVARBPROC) __GLeeGetProcAddress("glGetUniformivARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetShaderSourceARB = (GLEEPFNGLGETSHADERSOURCEARBPROC) __GLeeGetProcAddress("glGetShaderSourceARB"))!=0) nLinked++;
#endif
if (nLinked==39) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ARB_vertex_shader(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ARB_vertex_shader
if ((GLeeFuncPtr_glBindAttribLocationARB = (GLEEPFNGLBINDATTRIBLOCATIONARBPROC) __GLeeGetProcAddress("glBindAttribLocationARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetActiveAttribARB = (GLEEPFNGLGETACTIVEATTRIBARBPROC) __GLeeGetProcAddress("glGetActiveAttribARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetAttribLocationARB = (GLEEPFNGLGETATTRIBLOCATIONARBPROC) __GLeeGetProcAddress("glGetAttribLocationARB"))!=0) nLinked++;
#endif
if (nLinked==3) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ARB_fragment_shader(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ARB_shading_language_100(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ARB_texture_non_power_of_two(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ARB_point_sprite(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ARB_fragment_program_shadow(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ARB_draw_buffers(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ARB_draw_buffers
if ((GLeeFuncPtr_glDrawBuffersARB = (GLEEPFNGLDRAWBUFFERSARBPROC) __GLeeGetProcAddress("glDrawBuffersARB"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ARB_texture_rectangle(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ARB_color_buffer_float(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ARB_color_buffer_float
if ((GLeeFuncPtr_glClampColorARB = (GLEEPFNGLCLAMPCOLORARBPROC) __GLeeGetProcAddress("glClampColorARB"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ARB_half_float_pixel(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ARB_texture_float(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ARB_pixel_buffer_object(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ARB_depth_buffer_float(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ARB_draw_instanced(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ARB_draw_instanced
if ((GLeeFuncPtr_glDrawArraysInstancedARB = (GLEEPFNGLDRAWARRAYSINSTANCEDARBPROC) __GLeeGetProcAddress("glDrawArraysInstancedARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glDrawElementsInstancedARB = (GLEEPFNGLDRAWELEMENTSINSTANCEDARBPROC) __GLeeGetProcAddress("glDrawElementsInstancedARB"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ARB_framebuffer_object(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ARB_framebuffer_object
if ((GLeeFuncPtr_glIsRenderbuffer = (GLEEPFNGLISRENDERBUFFERPROC) __GLeeGetProcAddress("glIsRenderbuffer"))!=0) nLinked++;
if ((GLeeFuncPtr_glBindRenderbuffer = (GLEEPFNGLBINDRENDERBUFFERPROC) __GLeeGetProcAddress("glBindRenderbuffer"))!=0) nLinked++;
if ((GLeeFuncPtr_glDeleteRenderbuffers = (GLEEPFNGLDELETERENDERBUFFERSPROC) __GLeeGetProcAddress("glDeleteRenderbuffers"))!=0) nLinked++;
if ((GLeeFuncPtr_glGenRenderbuffers = (GLEEPFNGLGENRENDERBUFFERSPROC) __GLeeGetProcAddress("glGenRenderbuffers"))!=0) nLinked++;
if ((GLeeFuncPtr_glRenderbufferStorage = (GLEEPFNGLRENDERBUFFERSTORAGEPROC) __GLeeGetProcAddress("glRenderbufferStorage"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetRenderbufferParameteriv = (GLEEPFNGLGETRENDERBUFFERPARAMETERIVPROC) __GLeeGetProcAddress("glGetRenderbufferParameteriv"))!=0) nLinked++;
if ((GLeeFuncPtr_glIsFramebuffer = (GLEEPFNGLISFRAMEBUFFERPROC) __GLeeGetProcAddress("glIsFramebuffer"))!=0) nLinked++;
if ((GLeeFuncPtr_glBindFramebuffer = (GLEEPFNGLBINDFRAMEBUFFERPROC) __GLeeGetProcAddress("glBindFramebuffer"))!=0) nLinked++;
if ((GLeeFuncPtr_glDeleteFramebuffers = (GLEEPFNGLDELETEFRAMEBUFFERSPROC) __GLeeGetProcAddress("glDeleteFramebuffers"))!=0) nLinked++;
if ((GLeeFuncPtr_glGenFramebuffers = (GLEEPFNGLGENFRAMEBUFFERSPROC) __GLeeGetProcAddress("glGenFramebuffers"))!=0) nLinked++;
if ((GLeeFuncPtr_glCheckFramebufferStatus = (GLEEPFNGLCHECKFRAMEBUFFERSTATUSPROC) __GLeeGetProcAddress("glCheckFramebufferStatus"))!=0) nLinked++;
if ((GLeeFuncPtr_glFramebufferTexture1D = (GLEEPFNGLFRAMEBUFFERTEXTURE1DPROC) __GLeeGetProcAddress("glFramebufferTexture1D"))!=0) nLinked++;
if ((GLeeFuncPtr_glFramebufferTexture2D = (GLEEPFNGLFRAMEBUFFERTEXTURE2DPROC) __GLeeGetProcAddress("glFramebufferTexture2D"))!=0) nLinked++;
if ((GLeeFuncPtr_glFramebufferTexture3D = (GLEEPFNGLFRAMEBUFFERTEXTURE3DPROC) __GLeeGetProcAddress("glFramebufferTexture3D"))!=0) nLinked++;
if ((GLeeFuncPtr_glFramebufferRenderbuffer = (GLEEPFNGLFRAMEBUFFERRENDERBUFFERPROC) __GLeeGetProcAddress("glFramebufferRenderbuffer"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetFramebufferAttachmentParameteriv = (GLEEPFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC) __GLeeGetProcAddress("glGetFramebufferAttachmentParameteriv"))!=0) nLinked++;
if ((GLeeFuncPtr_glGenerateMipmap = (GLEEPFNGLGENERATEMIPMAPPROC) __GLeeGetProcAddress("glGenerateMipmap"))!=0) nLinked++;
if ((GLeeFuncPtr_glBlitFramebuffer = (GLEEPFNGLBLITFRAMEBUFFERPROC) __GLeeGetProcAddress("glBlitFramebuffer"))!=0) nLinked++;
if ((GLeeFuncPtr_glRenderbufferStorageMultisample = (GLEEPFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC) __GLeeGetProcAddress("glRenderbufferStorageMultisample"))!=0) nLinked++;
if ((GLeeFuncPtr_glFramebufferTextureLayer = (GLEEPFNGLFRAMEBUFFERTEXTURELAYERPROC) __GLeeGetProcAddress("glFramebufferTextureLayer"))!=0) nLinked++;
#endif
if (nLinked==20) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ARB_framebuffer_sRGB(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ARB_geometry_shader4(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ARB_geometry_shader4
if ((GLeeFuncPtr_glProgramParameteriARB = (GLEEPFNGLPROGRAMPARAMETERIARBPROC) __GLeeGetProcAddress("glProgramParameteriARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glFramebufferTextureARB = (GLEEPFNGLFRAMEBUFFERTEXTUREARBPROC) __GLeeGetProcAddress("glFramebufferTextureARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glFramebufferTextureLayerARB = (GLEEPFNGLFRAMEBUFFERTEXTURELAYERARBPROC) __GLeeGetProcAddress("glFramebufferTextureLayerARB"))!=0) nLinked++;
if ((GLeeFuncPtr_glFramebufferTextureFaceARB = (GLEEPFNGLFRAMEBUFFERTEXTUREFACEARBPROC) __GLeeGetProcAddress("glFramebufferTextureFaceARB"))!=0) nLinked++;
#endif
if (nLinked==4) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ARB_half_float_vertex(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ARB_instanced_arrays(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ARB_instanced_arrays
if ((GLeeFuncPtr_glVertexAttribDivisor = (GLEEPFNGLVERTEXATTRIBDIVISORPROC) __GLeeGetProcAddress("glVertexAttribDivisor"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ARB_map_buffer_range(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ARB_map_buffer_range
if ((GLeeFuncPtr_glMapBufferRange = (GLEEPFNGLMAPBUFFERRANGEPROC) __GLeeGetProcAddress("glMapBufferRange"))!=0) nLinked++;
if ((GLeeFuncPtr_glFlushMappedBufferRange = (GLEEPFNGLFLUSHMAPPEDBUFFERRANGEPROC) __GLeeGetProcAddress("glFlushMappedBufferRange"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ARB_texture_buffer_object(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ARB_texture_buffer_object
if ((GLeeFuncPtr_glTexBufferARB = (GLEEPFNGLTEXBUFFERARBPROC) __GLeeGetProcAddress("glTexBufferARB"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ARB_texture_compression_rgtc(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ARB_texture_rg(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ARB_vertex_array_object(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ARB_vertex_array_object
if ((GLeeFuncPtr_glBindVertexArray = (GLEEPFNGLBINDVERTEXARRAYPROC) __GLeeGetProcAddress("glBindVertexArray"))!=0) nLinked++;
if ((GLeeFuncPtr_glDeleteVertexArrays = (GLEEPFNGLDELETEVERTEXARRAYSPROC) __GLeeGetProcAddress("glDeleteVertexArrays"))!=0) nLinked++;
if ((GLeeFuncPtr_glGenVertexArrays = (GLEEPFNGLGENVERTEXARRAYSPROC) __GLeeGetProcAddress("glGenVertexArrays"))!=0) nLinked++;
if ((GLeeFuncPtr_glIsVertexArray = (GLEEPFNGLISVERTEXARRAYPROC) __GLeeGetProcAddress("glIsVertexArray"))!=0) nLinked++;
#endif
if (nLinked==4) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_abgr(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_blend_color(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_blend_color
if ((GLeeFuncPtr_glBlendColorEXT = (GLEEPFNGLBLENDCOLOREXTPROC) __GLeeGetProcAddress("glBlendColorEXT"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_polygon_offset(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_polygon_offset
if ((GLeeFuncPtr_glPolygonOffsetEXT = (GLEEPFNGLPOLYGONOFFSETEXTPROC) __GLeeGetProcAddress("glPolygonOffsetEXT"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_texture(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_texture3D(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_texture3D
if ((GLeeFuncPtr_glTexImage3DEXT = (GLEEPFNGLTEXIMAGE3DEXTPROC) __GLeeGetProcAddress("glTexImage3DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexSubImage3DEXT = (GLEEPFNGLTEXSUBIMAGE3DEXTPROC) __GLeeGetProcAddress("glTexSubImage3DEXT"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SGIS_texture_filter4(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_SGIS_texture_filter4
if ((GLeeFuncPtr_glGetTexFilterFuncSGIS = (GLEEPFNGLGETTEXFILTERFUNCSGISPROC) __GLeeGetProcAddress("glGetTexFilterFuncSGIS"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexFilterFuncSGIS = (GLEEPFNGLTEXFILTERFUNCSGISPROC) __GLeeGetProcAddress("glTexFilterFuncSGIS"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_subtexture(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_subtexture
if ((GLeeFuncPtr_glTexSubImage1DEXT = (GLEEPFNGLTEXSUBIMAGE1DEXTPROC) __GLeeGetProcAddress("glTexSubImage1DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexSubImage2DEXT = (GLEEPFNGLTEXSUBIMAGE2DEXTPROC) __GLeeGetProcAddress("glTexSubImage2DEXT"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_copy_texture(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_copy_texture
if ((GLeeFuncPtr_glCopyTexImage1DEXT = (GLEEPFNGLCOPYTEXIMAGE1DEXTPROC) __GLeeGetProcAddress("glCopyTexImage1DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCopyTexImage2DEXT = (GLEEPFNGLCOPYTEXIMAGE2DEXTPROC) __GLeeGetProcAddress("glCopyTexImage2DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCopyTexSubImage1DEXT = (GLEEPFNGLCOPYTEXSUBIMAGE1DEXTPROC) __GLeeGetProcAddress("glCopyTexSubImage1DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCopyTexSubImage2DEXT = (GLEEPFNGLCOPYTEXSUBIMAGE2DEXTPROC) __GLeeGetProcAddress("glCopyTexSubImage2DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCopyTexSubImage3DEXT = (GLEEPFNGLCOPYTEXSUBIMAGE3DEXTPROC) __GLeeGetProcAddress("glCopyTexSubImage3DEXT"))!=0) nLinked++;
#endif
if (nLinked==5) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_histogram(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_histogram
if ((GLeeFuncPtr_glGetHistogramEXT = (GLEEPFNGLGETHISTOGRAMEXTPROC) __GLeeGetProcAddress("glGetHistogramEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetHistogramParameterfvEXT = (GLEEPFNGLGETHISTOGRAMPARAMETERFVEXTPROC) __GLeeGetProcAddress("glGetHistogramParameterfvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetHistogramParameterivEXT = (GLEEPFNGLGETHISTOGRAMPARAMETERIVEXTPROC) __GLeeGetProcAddress("glGetHistogramParameterivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetMinmaxEXT = (GLEEPFNGLGETMINMAXEXTPROC) __GLeeGetProcAddress("glGetMinmaxEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetMinmaxParameterfvEXT = (GLEEPFNGLGETMINMAXPARAMETERFVEXTPROC) __GLeeGetProcAddress("glGetMinmaxParameterfvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetMinmaxParameterivEXT = (GLEEPFNGLGETMINMAXPARAMETERIVEXTPROC) __GLeeGetProcAddress("glGetMinmaxParameterivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glHistogramEXT = (GLEEPFNGLHISTOGRAMEXTPROC) __GLeeGetProcAddress("glHistogramEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMinmaxEXT = (GLEEPFNGLMINMAXEXTPROC) __GLeeGetProcAddress("glMinmaxEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glResetHistogramEXT = (GLEEPFNGLRESETHISTOGRAMEXTPROC) __GLeeGetProcAddress("glResetHistogramEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glResetMinmaxEXT = (GLEEPFNGLRESETMINMAXEXTPROC) __GLeeGetProcAddress("glResetMinmaxEXT"))!=0) nLinked++;
#endif
if (nLinked==10) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_convolution(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_convolution
if ((GLeeFuncPtr_glConvolutionFilter1DEXT = (GLEEPFNGLCONVOLUTIONFILTER1DEXTPROC) __GLeeGetProcAddress("glConvolutionFilter1DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glConvolutionFilter2DEXT = (GLEEPFNGLCONVOLUTIONFILTER2DEXTPROC) __GLeeGetProcAddress("glConvolutionFilter2DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glConvolutionParameterfEXT = (GLEEPFNGLCONVOLUTIONPARAMETERFEXTPROC) __GLeeGetProcAddress("glConvolutionParameterfEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glConvolutionParameterfvEXT = (GLEEPFNGLCONVOLUTIONPARAMETERFVEXTPROC) __GLeeGetProcAddress("glConvolutionParameterfvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glConvolutionParameteriEXT = (GLEEPFNGLCONVOLUTIONPARAMETERIEXTPROC) __GLeeGetProcAddress("glConvolutionParameteriEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glConvolutionParameterivEXT = (GLEEPFNGLCONVOLUTIONPARAMETERIVEXTPROC) __GLeeGetProcAddress("glConvolutionParameterivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCopyConvolutionFilter1DEXT = (GLEEPFNGLCOPYCONVOLUTIONFILTER1DEXTPROC) __GLeeGetProcAddress("glCopyConvolutionFilter1DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCopyConvolutionFilter2DEXT = (GLEEPFNGLCOPYCONVOLUTIONFILTER2DEXTPROC) __GLeeGetProcAddress("glCopyConvolutionFilter2DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetConvolutionFilterEXT = (GLEEPFNGLGETCONVOLUTIONFILTEREXTPROC) __GLeeGetProcAddress("glGetConvolutionFilterEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetConvolutionParameterfvEXT = (GLEEPFNGLGETCONVOLUTIONPARAMETERFVEXTPROC) __GLeeGetProcAddress("glGetConvolutionParameterfvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetConvolutionParameterivEXT = (GLEEPFNGLGETCONVOLUTIONPARAMETERIVEXTPROC) __GLeeGetProcAddress("glGetConvolutionParameterivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetSeparableFilterEXT = (GLEEPFNGLGETSEPARABLEFILTEREXTPROC) __GLeeGetProcAddress("glGetSeparableFilterEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glSeparableFilter2DEXT = (GLEEPFNGLSEPARABLEFILTER2DEXTPROC) __GLeeGetProcAddress("glSeparableFilter2DEXT"))!=0) nLinked++;
#endif
if (nLinked==13) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SGI_color_matrix(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGI_color_table(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_SGI_color_table
if ((GLeeFuncPtr_glColorTableSGI = (GLEEPFNGLCOLORTABLESGIPROC) __GLeeGetProcAddress("glColorTableSGI"))!=0) nLinked++;
if ((GLeeFuncPtr_glColorTableParameterfvSGI = (GLEEPFNGLCOLORTABLEPARAMETERFVSGIPROC) __GLeeGetProcAddress("glColorTableParameterfvSGI"))!=0) nLinked++;
if ((GLeeFuncPtr_glColorTableParameterivSGI = (GLEEPFNGLCOLORTABLEPARAMETERIVSGIPROC) __GLeeGetProcAddress("glColorTableParameterivSGI"))!=0) nLinked++;
if ((GLeeFuncPtr_glCopyColorTableSGI = (GLEEPFNGLCOPYCOLORTABLESGIPROC) __GLeeGetProcAddress("glCopyColorTableSGI"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetColorTableSGI = (GLEEPFNGLGETCOLORTABLESGIPROC) __GLeeGetProcAddress("glGetColorTableSGI"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetColorTableParameterfvSGI = (GLEEPFNGLGETCOLORTABLEPARAMETERFVSGIPROC) __GLeeGetProcAddress("glGetColorTableParameterfvSGI"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetColorTableParameterivSGI = (GLEEPFNGLGETCOLORTABLEPARAMETERIVSGIPROC) __GLeeGetProcAddress("glGetColorTableParameterivSGI"))!=0) nLinked++;
#endif
if (nLinked==7) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SGIS_pixel_texture(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_SGIS_pixel_texture
if ((GLeeFuncPtr_glPixelTexGenParameteriSGIS = (GLEEPFNGLPIXELTEXGENPARAMETERISGISPROC) __GLeeGetProcAddress("glPixelTexGenParameteriSGIS"))!=0) nLinked++;
if ((GLeeFuncPtr_glPixelTexGenParameterivSGIS = (GLEEPFNGLPIXELTEXGENPARAMETERIVSGISPROC) __GLeeGetProcAddress("glPixelTexGenParameterivSGIS"))!=0) nLinked++;
if ((GLeeFuncPtr_glPixelTexGenParameterfSGIS = (GLEEPFNGLPIXELTEXGENPARAMETERFSGISPROC) __GLeeGetProcAddress("glPixelTexGenParameterfSGIS"))!=0) nLinked++;
if ((GLeeFuncPtr_glPixelTexGenParameterfvSGIS = (GLEEPFNGLPIXELTEXGENPARAMETERFVSGISPROC) __GLeeGetProcAddress("glPixelTexGenParameterfvSGIS"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetPixelTexGenParameterivSGIS = (GLEEPFNGLGETPIXELTEXGENPARAMETERIVSGISPROC) __GLeeGetProcAddress("glGetPixelTexGenParameterivSGIS"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetPixelTexGenParameterfvSGIS = (GLEEPFNGLGETPIXELTEXGENPARAMETERFVSGISPROC) __GLeeGetProcAddress("glGetPixelTexGenParameterfvSGIS"))!=0) nLinked++;
#endif
if (nLinked==6) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SGIX_pixel_texture(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_SGIX_pixel_texture
if ((GLeeFuncPtr_glPixelTexGenSGIX = (GLEEPFNGLPIXELTEXGENSGIXPROC) __GLeeGetProcAddress("glPixelTexGenSGIX"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SGIS_texture4D(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_SGIS_texture4D
if ((GLeeFuncPtr_glTexImage4DSGIS = (GLEEPFNGLTEXIMAGE4DSGISPROC) __GLeeGetProcAddress("glTexImage4DSGIS"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexSubImage4DSGIS = (GLEEPFNGLTEXSUBIMAGE4DSGISPROC) __GLeeGetProcAddress("glTexSubImage4DSGIS"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SGI_texture_color_table(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_cmyka(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_texture_object(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_texture_object
if ((GLeeFuncPtr_glAreTexturesResidentEXT = (GLEEPFNGLARETEXTURESRESIDENTEXTPROC) __GLeeGetProcAddress("glAreTexturesResidentEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glBindTextureEXT = (GLEEPFNGLBINDTEXTUREEXTPROC) __GLeeGetProcAddress("glBindTextureEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glDeleteTexturesEXT = (GLEEPFNGLDELETETEXTURESEXTPROC) __GLeeGetProcAddress("glDeleteTexturesEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGenTexturesEXT = (GLEEPFNGLGENTEXTURESEXTPROC) __GLeeGetProcAddress("glGenTexturesEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glIsTextureEXT = (GLEEPFNGLISTEXTUREEXTPROC) __GLeeGetProcAddress("glIsTextureEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glPrioritizeTexturesEXT = (GLEEPFNGLPRIORITIZETEXTURESEXTPROC) __GLeeGetProcAddress("glPrioritizeTexturesEXT"))!=0) nLinked++;
#endif
if (nLinked==6) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SGIS_detail_texture(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_SGIS_detail_texture
if ((GLeeFuncPtr_glDetailTexFuncSGIS = (GLEEPFNGLDETAILTEXFUNCSGISPROC) __GLeeGetProcAddress("glDetailTexFuncSGIS"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetDetailTexFuncSGIS = (GLEEPFNGLGETDETAILTEXFUNCSGISPROC) __GLeeGetProcAddress("glGetDetailTexFuncSGIS"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SGIS_sharpen_texture(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_SGIS_sharpen_texture
if ((GLeeFuncPtr_glSharpenTexFuncSGIS = (GLEEPFNGLSHARPENTEXFUNCSGISPROC) __GLeeGetProcAddress("glSharpenTexFuncSGIS"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetSharpenTexFuncSGIS = (GLEEPFNGLGETSHARPENTEXFUNCSGISPROC) __GLeeGetProcAddress("glGetSharpenTexFuncSGIS"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_packed_pixels(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIS_texture_lod(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIS_multisample(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_SGIS_multisample
if ((GLeeFuncPtr_glSampleMaskSGIS = (GLEEPFNGLSAMPLEMASKSGISPROC) __GLeeGetProcAddress("glSampleMaskSGIS"))!=0) nLinked++;
if ((GLeeFuncPtr_glSamplePatternSGIS = (GLEEPFNGLSAMPLEPATTERNSGISPROC) __GLeeGetProcAddress("glSamplePatternSGIS"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_rescale_normal(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_vertex_array(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_vertex_array
if ((GLeeFuncPtr_glArrayElementEXT = (GLEEPFNGLARRAYELEMENTEXTPROC) __GLeeGetProcAddress("glArrayElementEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glColorPointerEXT = (GLEEPFNGLCOLORPOINTEREXTPROC) __GLeeGetProcAddress("glColorPointerEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glDrawArraysEXT = (GLEEPFNGLDRAWARRAYSEXTPROC) __GLeeGetProcAddress("glDrawArraysEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glEdgeFlagPointerEXT = (GLEEPFNGLEDGEFLAGPOINTEREXTPROC) __GLeeGetProcAddress("glEdgeFlagPointerEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetPointervEXT = (GLEEPFNGLGETPOINTERVEXTPROC) __GLeeGetProcAddress("glGetPointervEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glIndexPointerEXT = (GLEEPFNGLINDEXPOINTEREXTPROC) __GLeeGetProcAddress("glIndexPointerEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glNormalPointerEXT = (GLEEPFNGLNORMALPOINTEREXTPROC) __GLeeGetProcAddress("glNormalPointerEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexCoordPointerEXT = (GLEEPFNGLTEXCOORDPOINTEREXTPROC) __GLeeGetProcAddress("glTexCoordPointerEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexPointerEXT = (GLEEPFNGLVERTEXPOINTEREXTPROC) __GLeeGetProcAddress("glVertexPointerEXT"))!=0) nLinked++;
#endif
if (nLinked==9) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_misc_attribute(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIS_generate_mipmap(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIX_clipmap(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIX_shadow(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIS_texture_edge_clamp(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIS_texture_border_clamp(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_blend_minmax(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_blend_minmax
if ((GLeeFuncPtr_glBlendEquationEXT = (GLEEPFNGLBLENDEQUATIONEXTPROC) __GLeeGetProcAddress("glBlendEquationEXT"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_blend_subtract(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_blend_logic_op(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIX_interlace(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIX_pixel_tiles(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIS_texture_select(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIX_sprite(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_SGIX_sprite
if ((GLeeFuncPtr_glSpriteParameterfSGIX = (GLEEPFNGLSPRITEPARAMETERFSGIXPROC) __GLeeGetProcAddress("glSpriteParameterfSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glSpriteParameterfvSGIX = (GLEEPFNGLSPRITEPARAMETERFVSGIXPROC) __GLeeGetProcAddress("glSpriteParameterfvSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glSpriteParameteriSGIX = (GLEEPFNGLSPRITEPARAMETERISGIXPROC) __GLeeGetProcAddress("glSpriteParameteriSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glSpriteParameterivSGIX = (GLEEPFNGLSPRITEPARAMETERIVSGIXPROC) __GLeeGetProcAddress("glSpriteParameterivSGIX"))!=0) nLinked++;
#endif
if (nLinked==4) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SGIX_texture_multi_buffer(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_point_parameters(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_point_parameters
if ((GLeeFuncPtr_glPointParameterfEXT = (GLEEPFNGLPOINTPARAMETERFEXTPROC) __GLeeGetProcAddress("glPointParameterfEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glPointParameterfvEXT = (GLEEPFNGLPOINTPARAMETERFVEXTPROC) __GLeeGetProcAddress("glPointParameterfvEXT"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SGIS_point_parameters(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_SGIS_point_parameters
if ((GLeeFuncPtr_glPointParameterfSGIS = (GLEEPFNGLPOINTPARAMETERFSGISPROC) __GLeeGetProcAddress("glPointParameterfSGIS"))!=0) nLinked++;
if ((GLeeFuncPtr_glPointParameterfvSGIS = (GLEEPFNGLPOINTPARAMETERFVSGISPROC) __GLeeGetProcAddress("glPointParameterfvSGIS"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SGIX_instruments(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_SGIX_instruments
if ((GLeeFuncPtr_glGetInstrumentsSGIX = (GLEEPFNGLGETINSTRUMENTSSGIXPROC) __GLeeGetProcAddress("glGetInstrumentsSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glInstrumentsBufferSGIX = (GLEEPFNGLINSTRUMENTSBUFFERSGIXPROC) __GLeeGetProcAddress("glInstrumentsBufferSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glPollInstrumentsSGIX = (GLEEPFNGLPOLLINSTRUMENTSSGIXPROC) __GLeeGetProcAddress("glPollInstrumentsSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glReadInstrumentsSGIX = (GLEEPFNGLREADINSTRUMENTSSGIXPROC) __GLeeGetProcAddress("glReadInstrumentsSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glStartInstrumentsSGIX = (GLEEPFNGLSTARTINSTRUMENTSSGIXPROC) __GLeeGetProcAddress("glStartInstrumentsSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glStopInstrumentsSGIX = (GLEEPFNGLSTOPINSTRUMENTSSGIXPROC) __GLeeGetProcAddress("glStopInstrumentsSGIX"))!=0) nLinked++;
#endif
if (nLinked==6) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SGIX_texture_scale_bias(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIX_framezoom(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_SGIX_framezoom
if ((GLeeFuncPtr_glFrameZoomSGIX = (GLEEPFNGLFRAMEZOOMSGIXPROC) __GLeeGetProcAddress("glFrameZoomSGIX"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SGIX_tag_sample_buffer(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_SGIX_tag_sample_buffer
if ((GLeeFuncPtr_glTagSampleBufferSGIX = (GLEEPFNGLTAGSAMPLEBUFFERSGIXPROC) __GLeeGetProcAddress("glTagSampleBufferSGIX"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_FfdMaskSGIX(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIX_polynomial_ffd(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_SGIX_polynomial_ffd
if ((GLeeFuncPtr_glDeformationMap3dSGIX = (GLEEPFNGLDEFORMATIONMAP3DSGIXPROC) __GLeeGetProcAddress("glDeformationMap3dSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glDeformationMap3fSGIX = (GLEEPFNGLDEFORMATIONMAP3FSGIXPROC) __GLeeGetProcAddress("glDeformationMap3fSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glDeformSGIX = (GLEEPFNGLDEFORMSGIXPROC) __GLeeGetProcAddress("glDeformSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glLoadIdentityDeformationMapSGIX = (GLEEPFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC) __GLeeGetProcAddress("glLoadIdentityDeformationMapSGIX"))!=0) nLinked++;
#endif
if (nLinked==4) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SGIX_reference_plane(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_SGIX_reference_plane
if ((GLeeFuncPtr_glReferencePlaneSGIX = (GLEEPFNGLREFERENCEPLANESGIXPROC) __GLeeGetProcAddress("glReferencePlaneSGIX"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SGIX_flush_raster(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_SGIX_flush_raster
if ((GLeeFuncPtr_glFlushRasterSGIX = (GLEEPFNGLFLUSHRASTERSGIXPROC) __GLeeGetProcAddress("glFlushRasterSGIX"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SGIX_depth_texture(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIS_fog_function(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_SGIS_fog_function
if ((GLeeFuncPtr_glFogFuncSGIS = (GLEEPFNGLFOGFUNCSGISPROC) __GLeeGetProcAddress("glFogFuncSGIS"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetFogFuncSGIS = (GLEEPFNGLGETFOGFUNCSGISPROC) __GLeeGetProcAddress("glGetFogFuncSGIS"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SGIX_fog_offset(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_HP_image_transform(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_HP_image_transform
if ((GLeeFuncPtr_glImageTransformParameteriHP = (GLEEPFNGLIMAGETRANSFORMPARAMETERIHPPROC) __GLeeGetProcAddress("glImageTransformParameteriHP"))!=0) nLinked++;
if ((GLeeFuncPtr_glImageTransformParameterfHP = (GLEEPFNGLIMAGETRANSFORMPARAMETERFHPPROC) __GLeeGetProcAddress("glImageTransformParameterfHP"))!=0) nLinked++;
if ((GLeeFuncPtr_glImageTransformParameterivHP = (GLEEPFNGLIMAGETRANSFORMPARAMETERIVHPPROC) __GLeeGetProcAddress("glImageTransformParameterivHP"))!=0) nLinked++;
if ((GLeeFuncPtr_glImageTransformParameterfvHP = (GLEEPFNGLIMAGETRANSFORMPARAMETERFVHPPROC) __GLeeGetProcAddress("glImageTransformParameterfvHP"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetImageTransformParameterivHP = (GLEEPFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC) __GLeeGetProcAddress("glGetImageTransformParameterivHP"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetImageTransformParameterfvHP = (GLEEPFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC) __GLeeGetProcAddress("glGetImageTransformParameterfvHP"))!=0) nLinked++;
#endif
if (nLinked==6) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_HP_convolution_border_modes(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_INGR_palette_buffer(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIX_texture_add_env(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_color_subtable(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_color_subtable
if ((GLeeFuncPtr_glColorSubTableEXT = (GLEEPFNGLCOLORSUBTABLEEXTPROC) __GLeeGetProcAddress("glColorSubTableEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCopyColorSubTableEXT = (GLEEPFNGLCOPYCOLORSUBTABLEEXTPROC) __GLeeGetProcAddress("glCopyColorSubTableEXT"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_PGI_vertex_hints(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_PGI_misc_hints(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_PGI_misc_hints
if ((GLeeFuncPtr_glHintPGI = (GLEEPFNGLHINTPGIPROC) __GLeeGetProcAddress("glHintPGI"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_paletted_texture(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_paletted_texture
if ((GLeeFuncPtr_glColorTableEXT = (GLEEPFNGLCOLORTABLEEXTPROC) __GLeeGetProcAddress("glColorTableEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetColorTableEXT = (GLEEPFNGLGETCOLORTABLEEXTPROC) __GLeeGetProcAddress("glGetColorTableEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetColorTableParameterivEXT = (GLEEPFNGLGETCOLORTABLEPARAMETERIVEXTPROC) __GLeeGetProcAddress("glGetColorTableParameterivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetColorTableParameterfvEXT = (GLEEPFNGLGETCOLORTABLEPARAMETERFVEXTPROC) __GLeeGetProcAddress("glGetColorTableParameterfvEXT"))!=0) nLinked++;
#endif
if (nLinked==4) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_clip_volume_hint(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIX_list_priority(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_SGIX_list_priority
if ((GLeeFuncPtr_glGetListParameterfvSGIX = (GLEEPFNGLGETLISTPARAMETERFVSGIXPROC) __GLeeGetProcAddress("glGetListParameterfvSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetListParameterivSGIX = (GLEEPFNGLGETLISTPARAMETERIVSGIXPROC) __GLeeGetProcAddress("glGetListParameterivSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glListParameterfSGIX = (GLEEPFNGLLISTPARAMETERFSGIXPROC) __GLeeGetProcAddress("glListParameterfSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glListParameterfvSGIX = (GLEEPFNGLLISTPARAMETERFVSGIXPROC) __GLeeGetProcAddress("glListParameterfvSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glListParameteriSGIX = (GLEEPFNGLLISTPARAMETERISGIXPROC) __GLeeGetProcAddress("glListParameteriSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glListParameterivSGIX = (GLEEPFNGLLISTPARAMETERIVSGIXPROC) __GLeeGetProcAddress("glListParameterivSGIX"))!=0) nLinked++;
#endif
if (nLinked==6) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SGIX_ir_instrument1(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIX_calligraphic_fragment(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIX_texture_lod_bias(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIX_shadow_ambient(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_index_texture(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_index_material(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_index_material
if ((GLeeFuncPtr_glIndexMaterialEXT = (GLEEPFNGLINDEXMATERIALEXTPROC) __GLeeGetProcAddress("glIndexMaterialEXT"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_index_func(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_index_func
if ((GLeeFuncPtr_glIndexFuncEXT = (GLEEPFNGLINDEXFUNCEXTPROC) __GLeeGetProcAddress("glIndexFuncEXT"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_index_array_formats(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_compiled_vertex_array(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_compiled_vertex_array
if ((GLeeFuncPtr_glLockArraysEXT = (GLEEPFNGLLOCKARRAYSEXTPROC) __GLeeGetProcAddress("glLockArraysEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glUnlockArraysEXT = (GLEEPFNGLUNLOCKARRAYSEXTPROC) __GLeeGetProcAddress("glUnlockArraysEXT"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_cull_vertex(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_cull_vertex
if ((GLeeFuncPtr_glCullParameterdvEXT = (GLEEPFNGLCULLPARAMETERDVEXTPROC) __GLeeGetProcAddress("glCullParameterdvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCullParameterfvEXT = (GLEEPFNGLCULLPARAMETERFVEXTPROC) __GLeeGetProcAddress("glCullParameterfvEXT"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SGIX_ycrcb(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIX_fragment_lighting(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_SGIX_fragment_lighting
if ((GLeeFuncPtr_glFragmentColorMaterialSGIX = (GLEEPFNGLFRAGMENTCOLORMATERIALSGIXPROC) __GLeeGetProcAddress("glFragmentColorMaterialSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glFragmentLightfSGIX = (GLEEPFNGLFRAGMENTLIGHTFSGIXPROC) __GLeeGetProcAddress("glFragmentLightfSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glFragmentLightfvSGIX = (GLEEPFNGLFRAGMENTLIGHTFVSGIXPROC) __GLeeGetProcAddress("glFragmentLightfvSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glFragmentLightiSGIX = (GLEEPFNGLFRAGMENTLIGHTISGIXPROC) __GLeeGetProcAddress("glFragmentLightiSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glFragmentLightivSGIX = (GLEEPFNGLFRAGMENTLIGHTIVSGIXPROC) __GLeeGetProcAddress("glFragmentLightivSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glFragmentLightModelfSGIX = (GLEEPFNGLFRAGMENTLIGHTMODELFSGIXPROC) __GLeeGetProcAddress("glFragmentLightModelfSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glFragmentLightModelfvSGIX = (GLEEPFNGLFRAGMENTLIGHTMODELFVSGIXPROC) __GLeeGetProcAddress("glFragmentLightModelfvSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glFragmentLightModeliSGIX = (GLEEPFNGLFRAGMENTLIGHTMODELISGIXPROC) __GLeeGetProcAddress("glFragmentLightModeliSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glFragmentLightModelivSGIX = (GLEEPFNGLFRAGMENTLIGHTMODELIVSGIXPROC) __GLeeGetProcAddress("glFragmentLightModelivSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glFragmentMaterialfSGIX = (GLEEPFNGLFRAGMENTMATERIALFSGIXPROC) __GLeeGetProcAddress("glFragmentMaterialfSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glFragmentMaterialfvSGIX = (GLEEPFNGLFRAGMENTMATERIALFVSGIXPROC) __GLeeGetProcAddress("glFragmentMaterialfvSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glFragmentMaterialiSGIX = (GLEEPFNGLFRAGMENTMATERIALISGIXPROC) __GLeeGetProcAddress("glFragmentMaterialiSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glFragmentMaterialivSGIX = (GLEEPFNGLFRAGMENTMATERIALIVSGIXPROC) __GLeeGetProcAddress("glFragmentMaterialivSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetFragmentLightfvSGIX = (GLEEPFNGLGETFRAGMENTLIGHTFVSGIXPROC) __GLeeGetProcAddress("glGetFragmentLightfvSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetFragmentLightivSGIX = (GLEEPFNGLGETFRAGMENTLIGHTIVSGIXPROC) __GLeeGetProcAddress("glGetFragmentLightivSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetFragmentMaterialfvSGIX = (GLEEPFNGLGETFRAGMENTMATERIALFVSGIXPROC) __GLeeGetProcAddress("glGetFragmentMaterialfvSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetFragmentMaterialivSGIX = (GLEEPFNGLGETFRAGMENTMATERIALIVSGIXPROC) __GLeeGetProcAddress("glGetFragmentMaterialivSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glLightEnviSGIX = (GLEEPFNGLLIGHTENVISGIXPROC) __GLeeGetProcAddress("glLightEnviSGIX"))!=0) nLinked++;
#endif
if (nLinked==18) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_IBM_rasterpos_clip(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_HP_texture_lighting(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_draw_range_elements(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_draw_range_elements
if ((GLeeFuncPtr_glDrawRangeElementsEXT = (GLEEPFNGLDRAWRANGEELEMENTSEXTPROC) __GLeeGetProcAddress("glDrawRangeElementsEXT"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_WIN_phong_shading(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_WIN_specular_fog(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_light_texture(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_light_texture
if ((GLeeFuncPtr_glApplyTextureEXT = (GLEEPFNGLAPPLYTEXTUREEXTPROC) __GLeeGetProcAddress("glApplyTextureEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTextureLightEXT = (GLEEPFNGLTEXTURELIGHTEXTPROC) __GLeeGetProcAddress("glTextureLightEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTextureMaterialEXT = (GLEEPFNGLTEXTUREMATERIALEXTPROC) __GLeeGetProcAddress("glTextureMaterialEXT"))!=0) nLinked++;
#endif
if (nLinked==3) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SGIX_blend_alpha_minmax(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIX_impact_pixel_texture(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_bgra(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIX_async(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_SGIX_async
if ((GLeeFuncPtr_glAsyncMarkerSGIX = (GLEEPFNGLASYNCMARKERSGIXPROC) __GLeeGetProcAddress("glAsyncMarkerSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glFinishAsyncSGIX = (GLEEPFNGLFINISHASYNCSGIXPROC) __GLeeGetProcAddress("glFinishAsyncSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glPollAsyncSGIX = (GLEEPFNGLPOLLASYNCSGIXPROC) __GLeeGetProcAddress("glPollAsyncSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glGenAsyncMarkersSGIX = (GLEEPFNGLGENASYNCMARKERSSGIXPROC) __GLeeGetProcAddress("glGenAsyncMarkersSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glDeleteAsyncMarkersSGIX = (GLEEPFNGLDELETEASYNCMARKERSSGIXPROC) __GLeeGetProcAddress("glDeleteAsyncMarkersSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glIsAsyncMarkerSGIX = (GLEEPFNGLISASYNCMARKERSGIXPROC) __GLeeGetProcAddress("glIsAsyncMarkerSGIX"))!=0) nLinked++;
#endif
if (nLinked==6) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SGIX_async_pixel(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIX_async_histogram(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_INTEL_texture_scissor(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_INTEL_parallel_arrays(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_INTEL_parallel_arrays
if ((GLeeFuncPtr_glVertexPointervINTEL = (GLEEPFNGLVERTEXPOINTERVINTELPROC) __GLeeGetProcAddress("glVertexPointervINTEL"))!=0) nLinked++;
if ((GLeeFuncPtr_glNormalPointervINTEL = (GLEEPFNGLNORMALPOINTERVINTELPROC) __GLeeGetProcAddress("glNormalPointervINTEL"))!=0) nLinked++;
if ((GLeeFuncPtr_glColorPointervINTEL = (GLEEPFNGLCOLORPOINTERVINTELPROC) __GLeeGetProcAddress("glColorPointervINTEL"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexCoordPointervINTEL = (GLEEPFNGLTEXCOORDPOINTERVINTELPROC) __GLeeGetProcAddress("glTexCoordPointervINTEL"))!=0) nLinked++;
#endif
if (nLinked==4) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_HP_occlusion_test(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_pixel_transform(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_pixel_transform
if ((GLeeFuncPtr_glPixelTransformParameteriEXT = (GLEEPFNGLPIXELTRANSFORMPARAMETERIEXTPROC) __GLeeGetProcAddress("glPixelTransformParameteriEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glPixelTransformParameterfEXT = (GLEEPFNGLPIXELTRANSFORMPARAMETERFEXTPROC) __GLeeGetProcAddress("glPixelTransformParameterfEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glPixelTransformParameterivEXT = (GLEEPFNGLPIXELTRANSFORMPARAMETERIVEXTPROC) __GLeeGetProcAddress("glPixelTransformParameterivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glPixelTransformParameterfvEXT = (GLEEPFNGLPIXELTRANSFORMPARAMETERFVEXTPROC) __GLeeGetProcAddress("glPixelTransformParameterfvEXT"))!=0) nLinked++;
#endif
if (nLinked==4) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_pixel_transform_color_table(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_shared_texture_palette(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_separate_specular_color(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_secondary_color(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_secondary_color
if ((GLeeFuncPtr_glSecondaryColor3bEXT = (GLEEPFNGLSECONDARYCOLOR3BEXTPROC) __GLeeGetProcAddress("glSecondaryColor3bEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3bvEXT = (GLEEPFNGLSECONDARYCOLOR3BVEXTPROC) __GLeeGetProcAddress("glSecondaryColor3bvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3dEXT = (GLEEPFNGLSECONDARYCOLOR3DEXTPROC) __GLeeGetProcAddress("glSecondaryColor3dEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3dvEXT = (GLEEPFNGLSECONDARYCOLOR3DVEXTPROC) __GLeeGetProcAddress("glSecondaryColor3dvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3fEXT = (GLEEPFNGLSECONDARYCOLOR3FEXTPROC) __GLeeGetProcAddress("glSecondaryColor3fEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3fvEXT = (GLEEPFNGLSECONDARYCOLOR3FVEXTPROC) __GLeeGetProcAddress("glSecondaryColor3fvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3iEXT = (GLEEPFNGLSECONDARYCOLOR3IEXTPROC) __GLeeGetProcAddress("glSecondaryColor3iEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3ivEXT = (GLEEPFNGLSECONDARYCOLOR3IVEXTPROC) __GLeeGetProcAddress("glSecondaryColor3ivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3sEXT = (GLEEPFNGLSECONDARYCOLOR3SEXTPROC) __GLeeGetProcAddress("glSecondaryColor3sEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3svEXT = (GLEEPFNGLSECONDARYCOLOR3SVEXTPROC) __GLeeGetProcAddress("glSecondaryColor3svEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3ubEXT = (GLEEPFNGLSECONDARYCOLOR3UBEXTPROC) __GLeeGetProcAddress("glSecondaryColor3ubEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3ubvEXT = (GLEEPFNGLSECONDARYCOLOR3UBVEXTPROC) __GLeeGetProcAddress("glSecondaryColor3ubvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3uiEXT = (GLEEPFNGLSECONDARYCOLOR3UIEXTPROC) __GLeeGetProcAddress("glSecondaryColor3uiEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3uivEXT = (GLEEPFNGLSECONDARYCOLOR3UIVEXTPROC) __GLeeGetProcAddress("glSecondaryColor3uivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3usEXT = (GLEEPFNGLSECONDARYCOLOR3USEXTPROC) __GLeeGetProcAddress("glSecondaryColor3usEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3usvEXT = (GLEEPFNGLSECONDARYCOLOR3USVEXTPROC) __GLeeGetProcAddress("glSecondaryColor3usvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColorPointerEXT = (GLEEPFNGLSECONDARYCOLORPOINTEREXTPROC) __GLeeGetProcAddress("glSecondaryColorPointerEXT"))!=0) nLinked++;
#endif
if (nLinked==17) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_texture_perturb_normal(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_texture_perturb_normal
if ((GLeeFuncPtr_glTextureNormalEXT = (GLEEPFNGLTEXTURENORMALEXTPROC) __GLeeGetProcAddress("glTextureNormalEXT"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_multi_draw_arrays(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_multi_draw_arrays
if ((GLeeFuncPtr_glMultiDrawArraysEXT = (GLEEPFNGLMULTIDRAWARRAYSEXTPROC) __GLeeGetProcAddress("glMultiDrawArraysEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiDrawElementsEXT = (GLEEPFNGLMULTIDRAWELEMENTSEXTPROC) __GLeeGetProcAddress("glMultiDrawElementsEXT"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_fog_coord(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_fog_coord
if ((GLeeFuncPtr_glFogCoordfEXT = (GLEEPFNGLFOGCOORDFEXTPROC) __GLeeGetProcAddress("glFogCoordfEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFogCoordfvEXT = (GLEEPFNGLFOGCOORDFVEXTPROC) __GLeeGetProcAddress("glFogCoordfvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFogCoorddEXT = (GLEEPFNGLFOGCOORDDEXTPROC) __GLeeGetProcAddress("glFogCoorddEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFogCoorddvEXT = (GLEEPFNGLFOGCOORDDVEXTPROC) __GLeeGetProcAddress("glFogCoorddvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFogCoordPointerEXT = (GLEEPFNGLFOGCOORDPOINTEREXTPROC) __GLeeGetProcAddress("glFogCoordPointerEXT"))!=0) nLinked++;
#endif
if (nLinked==5) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_REND_screen_coordinates(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_coordinate_frame(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_coordinate_frame
if ((GLeeFuncPtr_glTangent3bEXT = (GLEEPFNGLTANGENT3BEXTPROC) __GLeeGetProcAddress("glTangent3bEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTangent3bvEXT = (GLEEPFNGLTANGENT3BVEXTPROC) __GLeeGetProcAddress("glTangent3bvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTangent3dEXT = (GLEEPFNGLTANGENT3DEXTPROC) __GLeeGetProcAddress("glTangent3dEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTangent3dvEXT = (GLEEPFNGLTANGENT3DVEXTPROC) __GLeeGetProcAddress("glTangent3dvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTangent3fEXT = (GLEEPFNGLTANGENT3FEXTPROC) __GLeeGetProcAddress("glTangent3fEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTangent3fvEXT = (GLEEPFNGLTANGENT3FVEXTPROC) __GLeeGetProcAddress("glTangent3fvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTangent3iEXT = (GLEEPFNGLTANGENT3IEXTPROC) __GLeeGetProcAddress("glTangent3iEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTangent3ivEXT = (GLEEPFNGLTANGENT3IVEXTPROC) __GLeeGetProcAddress("glTangent3ivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTangent3sEXT = (GLEEPFNGLTANGENT3SEXTPROC) __GLeeGetProcAddress("glTangent3sEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTangent3svEXT = (GLEEPFNGLTANGENT3SVEXTPROC) __GLeeGetProcAddress("glTangent3svEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glBinormal3bEXT = (GLEEPFNGLBINORMAL3BEXTPROC) __GLeeGetProcAddress("glBinormal3bEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glBinormal3bvEXT = (GLEEPFNGLBINORMAL3BVEXTPROC) __GLeeGetProcAddress("glBinormal3bvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glBinormal3dEXT = (GLEEPFNGLBINORMAL3DEXTPROC) __GLeeGetProcAddress("glBinormal3dEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glBinormal3dvEXT = (GLEEPFNGLBINORMAL3DVEXTPROC) __GLeeGetProcAddress("glBinormal3dvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glBinormal3fEXT = (GLEEPFNGLBINORMAL3FEXTPROC) __GLeeGetProcAddress("glBinormal3fEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glBinormal3fvEXT = (GLEEPFNGLBINORMAL3FVEXTPROC) __GLeeGetProcAddress("glBinormal3fvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glBinormal3iEXT = (GLEEPFNGLBINORMAL3IEXTPROC) __GLeeGetProcAddress("glBinormal3iEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glBinormal3ivEXT = (GLEEPFNGLBINORMAL3IVEXTPROC) __GLeeGetProcAddress("glBinormal3ivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glBinormal3sEXT = (GLEEPFNGLBINORMAL3SEXTPROC) __GLeeGetProcAddress("glBinormal3sEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glBinormal3svEXT = (GLEEPFNGLBINORMAL3SVEXTPROC) __GLeeGetProcAddress("glBinormal3svEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTangentPointerEXT = (GLEEPFNGLTANGENTPOINTEREXTPROC) __GLeeGetProcAddress("glTangentPointerEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glBinormalPointerEXT = (GLEEPFNGLBINORMALPOINTEREXTPROC) __GLeeGetProcAddress("glBinormalPointerEXT"))!=0) nLinked++;
#endif
if (nLinked==22) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_texture_env_combine(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_APPLE_specular_vector(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_APPLE_transform_hint(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIX_fog_scale(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SUNX_constant_data(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_SUNX_constant_data
if ((GLeeFuncPtr_glFinishTextureSUNX = (GLEEPFNGLFINISHTEXTURESUNXPROC) __GLeeGetProcAddress("glFinishTextureSUNX"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SUN_global_alpha(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_SUN_global_alpha
if ((GLeeFuncPtr_glGlobalAlphaFactorbSUN = (GLEEPFNGLGLOBALALPHAFACTORBSUNPROC) __GLeeGetProcAddress("glGlobalAlphaFactorbSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glGlobalAlphaFactorsSUN = (GLEEPFNGLGLOBALALPHAFACTORSSUNPROC) __GLeeGetProcAddress("glGlobalAlphaFactorsSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glGlobalAlphaFactoriSUN = (GLEEPFNGLGLOBALALPHAFACTORISUNPROC) __GLeeGetProcAddress("glGlobalAlphaFactoriSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glGlobalAlphaFactorfSUN = (GLEEPFNGLGLOBALALPHAFACTORFSUNPROC) __GLeeGetProcAddress("glGlobalAlphaFactorfSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glGlobalAlphaFactordSUN = (GLEEPFNGLGLOBALALPHAFACTORDSUNPROC) __GLeeGetProcAddress("glGlobalAlphaFactordSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glGlobalAlphaFactorubSUN = (GLEEPFNGLGLOBALALPHAFACTORUBSUNPROC) __GLeeGetProcAddress("glGlobalAlphaFactorubSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glGlobalAlphaFactorusSUN = (GLEEPFNGLGLOBALALPHAFACTORUSSUNPROC) __GLeeGetProcAddress("glGlobalAlphaFactorusSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glGlobalAlphaFactoruiSUN = (GLEEPFNGLGLOBALALPHAFACTORUISUNPROC) __GLeeGetProcAddress("glGlobalAlphaFactoruiSUN"))!=0) nLinked++;
#endif
if (nLinked==8) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SUN_triangle_list(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_SUN_triangle_list
if ((GLeeFuncPtr_glReplacementCodeuiSUN = (GLEEPFNGLREPLACEMENTCODEUISUNPROC) __GLeeGetProcAddress("glReplacementCodeuiSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glReplacementCodeusSUN = (GLEEPFNGLREPLACEMENTCODEUSSUNPROC) __GLeeGetProcAddress("glReplacementCodeusSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glReplacementCodeubSUN = (GLEEPFNGLREPLACEMENTCODEUBSUNPROC) __GLeeGetProcAddress("glReplacementCodeubSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glReplacementCodeuivSUN = (GLEEPFNGLREPLACEMENTCODEUIVSUNPROC) __GLeeGetProcAddress("glReplacementCodeuivSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glReplacementCodeusvSUN = (GLEEPFNGLREPLACEMENTCODEUSVSUNPROC) __GLeeGetProcAddress("glReplacementCodeusvSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glReplacementCodeubvSUN = (GLEEPFNGLREPLACEMENTCODEUBVSUNPROC) __GLeeGetProcAddress("glReplacementCodeubvSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glReplacementCodePointerSUN = (GLEEPFNGLREPLACEMENTCODEPOINTERSUNPROC) __GLeeGetProcAddress("glReplacementCodePointerSUN"))!=0) nLinked++;
#endif
if (nLinked==7) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SUN_vertex(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_SUN_vertex
if ((GLeeFuncPtr_glColor4ubVertex2fSUN = (GLEEPFNGLCOLOR4UBVERTEX2FSUNPROC) __GLeeGetProcAddress("glColor4ubVertex2fSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glColor4ubVertex2fvSUN = (GLEEPFNGLCOLOR4UBVERTEX2FVSUNPROC) __GLeeGetProcAddress("glColor4ubVertex2fvSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glColor4ubVertex3fSUN = (GLEEPFNGLCOLOR4UBVERTEX3FSUNPROC) __GLeeGetProcAddress("glColor4ubVertex3fSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glColor4ubVertex3fvSUN = (GLEEPFNGLCOLOR4UBVERTEX3FVSUNPROC) __GLeeGetProcAddress("glColor4ubVertex3fvSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glColor3fVertex3fSUN = (GLEEPFNGLCOLOR3FVERTEX3FSUNPROC) __GLeeGetProcAddress("glColor3fVertex3fSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glColor3fVertex3fvSUN = (GLEEPFNGLCOLOR3FVERTEX3FVSUNPROC) __GLeeGetProcAddress("glColor3fVertex3fvSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glNormal3fVertex3fSUN = (GLEEPFNGLNORMAL3FVERTEX3FSUNPROC) __GLeeGetProcAddress("glNormal3fVertex3fSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glNormal3fVertex3fvSUN = (GLEEPFNGLNORMAL3FVERTEX3FVSUNPROC) __GLeeGetProcAddress("glNormal3fVertex3fvSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glColor4fNormal3fVertex3fSUN = (GLEEPFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC) __GLeeGetProcAddress("glColor4fNormal3fVertex3fSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glColor4fNormal3fVertex3fvSUN = (GLEEPFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC) __GLeeGetProcAddress("glColor4fNormal3fVertex3fvSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexCoord2fVertex3fSUN = (GLEEPFNGLTEXCOORD2FVERTEX3FSUNPROC) __GLeeGetProcAddress("glTexCoord2fVertex3fSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexCoord2fVertex3fvSUN = (GLEEPFNGLTEXCOORD2FVERTEX3FVSUNPROC) __GLeeGetProcAddress("glTexCoord2fVertex3fvSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexCoord4fVertex4fSUN = (GLEEPFNGLTEXCOORD4FVERTEX4FSUNPROC) __GLeeGetProcAddress("glTexCoord4fVertex4fSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexCoord4fVertex4fvSUN = (GLEEPFNGLTEXCOORD4FVERTEX4FVSUNPROC) __GLeeGetProcAddress("glTexCoord4fVertex4fvSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexCoord2fColor4ubVertex3fSUN = (GLEEPFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC) __GLeeGetProcAddress("glTexCoord2fColor4ubVertex3fSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexCoord2fColor4ubVertex3fvSUN = (GLEEPFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC) __GLeeGetProcAddress("glTexCoord2fColor4ubVertex3fvSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexCoord2fColor3fVertex3fSUN = (GLEEPFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC) __GLeeGetProcAddress("glTexCoord2fColor3fVertex3fSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexCoord2fColor3fVertex3fvSUN = (GLEEPFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC) __GLeeGetProcAddress("glTexCoord2fColor3fVertex3fvSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexCoord2fNormal3fVertex3fSUN = (GLEEPFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC) __GLeeGetProcAddress("glTexCoord2fNormal3fVertex3fSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexCoord2fNormal3fVertex3fvSUN = (GLEEPFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC) __GLeeGetProcAddress("glTexCoord2fNormal3fVertex3fvSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexCoord2fColor4fNormal3fVertex3fSUN = (GLEEPFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC) __GLeeGetProcAddress("glTexCoord2fColor4fNormal3fVertex3fSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexCoord2fColor4fNormal3fVertex3fvSUN = (GLEEPFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC) __GLeeGetProcAddress("glTexCoord2fColor4fNormal3fVertex3fvSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexCoord4fColor4fNormal3fVertex4fSUN = (GLEEPFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC) __GLeeGetProcAddress("glTexCoord4fColor4fNormal3fVertex4fSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexCoord4fColor4fNormal3fVertex4fvSUN = (GLEEPFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC) __GLeeGetProcAddress("glTexCoord4fColor4fNormal3fVertex4fvSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glReplacementCodeuiVertex3fSUN = (GLEEPFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC) __GLeeGetProcAddress("glReplacementCodeuiVertex3fSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glReplacementCodeuiVertex3fvSUN = (GLEEPFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC) __GLeeGetProcAddress("glReplacementCodeuiVertex3fvSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glReplacementCodeuiColor4ubVertex3fSUN = (GLEEPFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC) __GLeeGetProcAddress("glReplacementCodeuiColor4ubVertex3fSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glReplacementCodeuiColor4ubVertex3fvSUN = (GLEEPFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC) __GLeeGetProcAddress("glReplacementCodeuiColor4ubVertex3fvSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glReplacementCodeuiColor3fVertex3fSUN = (GLEEPFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC) __GLeeGetProcAddress("glReplacementCodeuiColor3fVertex3fSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glReplacementCodeuiColor3fVertex3fvSUN = (GLEEPFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC) __GLeeGetProcAddress("glReplacementCodeuiColor3fVertex3fvSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glReplacementCodeuiNormal3fVertex3fSUN = (GLEEPFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC) __GLeeGetProcAddress("glReplacementCodeuiNormal3fVertex3fSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glReplacementCodeuiNormal3fVertex3fvSUN = (GLEEPFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC) __GLeeGetProcAddress("glReplacementCodeuiNormal3fVertex3fvSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glReplacementCodeuiColor4fNormal3fVertex3fSUN = (GLEEPFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC) __GLeeGetProcAddress("glReplacementCodeuiColor4fNormal3fVertex3fSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glReplacementCodeuiColor4fNormal3fVertex3fvSUN = (GLEEPFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC) __GLeeGetProcAddress("glReplacementCodeuiColor4fNormal3fVertex3fvSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glReplacementCodeuiTexCoord2fVertex3fSUN = (GLEEPFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC) __GLeeGetProcAddress("glReplacementCodeuiTexCoord2fVertex3fSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glReplacementCodeuiTexCoord2fVertex3fvSUN = (GLEEPFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC) __GLeeGetProcAddress("glReplacementCodeuiTexCoord2fVertex3fvSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = (GLEEPFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC) __GLeeGetProcAddress("glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = (GLEEPFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC) __GLeeGetProcAddress("glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = (GLEEPFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC) __GLeeGetProcAddress("glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN"))!=0) nLinked++;
if ((GLeeFuncPtr_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = (GLEEPFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC) __GLeeGetProcAddress("glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN"))!=0) nLinked++;
#endif
if (nLinked==40) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_blend_func_separate(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_blend_func_separate
if ((GLeeFuncPtr_glBlendFuncSeparateEXT = (GLEEPFNGLBLENDFUNCSEPARATEEXTPROC) __GLeeGetProcAddress("glBlendFuncSeparateEXT"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_INGR_color_clamp(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_INGR_interlace_read(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_stencil_wrap(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_422_pixels(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_texgen_reflection(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_texture_cube_map(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SUN_convolution_border_modes(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_texture_env_add(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_texture_lod_bias(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_texture_filter_anisotropic(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_vertex_weighting(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_vertex_weighting
if ((GLeeFuncPtr_glVertexWeightfEXT = (GLEEPFNGLVERTEXWEIGHTFEXTPROC) __GLeeGetProcAddress("glVertexWeightfEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexWeightfvEXT = (GLEEPFNGLVERTEXWEIGHTFVEXTPROC) __GLeeGetProcAddress("glVertexWeightfvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexWeightPointerEXT = (GLEEPFNGLVERTEXWEIGHTPOINTEREXTPROC) __GLeeGetProcAddress("glVertexWeightPointerEXT"))!=0) nLinked++;
#endif
if (nLinked==3) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_NV_light_max_exponent(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_vertex_array_range(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_NV_vertex_array_range
if ((GLeeFuncPtr_glFlushVertexArrayRangeNV = (GLEEPFNGLFLUSHVERTEXARRAYRANGENVPROC) __GLeeGetProcAddress("glFlushVertexArrayRangeNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexArrayRangeNV = (GLEEPFNGLVERTEXARRAYRANGENVPROC) __GLeeGetProcAddress("glVertexArrayRangeNV"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_NV_register_combiners(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_NV_register_combiners
if ((GLeeFuncPtr_glCombinerParameterfvNV = (GLEEPFNGLCOMBINERPARAMETERFVNVPROC) __GLeeGetProcAddress("glCombinerParameterfvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glCombinerParameterfNV = (GLEEPFNGLCOMBINERPARAMETERFNVPROC) __GLeeGetProcAddress("glCombinerParameterfNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glCombinerParameterivNV = (GLEEPFNGLCOMBINERPARAMETERIVNVPROC) __GLeeGetProcAddress("glCombinerParameterivNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glCombinerParameteriNV = (GLEEPFNGLCOMBINERPARAMETERINVPROC) __GLeeGetProcAddress("glCombinerParameteriNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glCombinerInputNV = (GLEEPFNGLCOMBINERINPUTNVPROC) __GLeeGetProcAddress("glCombinerInputNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glCombinerOutputNV = (GLEEPFNGLCOMBINEROUTPUTNVPROC) __GLeeGetProcAddress("glCombinerOutputNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glFinalCombinerInputNV = (GLEEPFNGLFINALCOMBINERINPUTNVPROC) __GLeeGetProcAddress("glFinalCombinerInputNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetCombinerInputParameterfvNV = (GLEEPFNGLGETCOMBINERINPUTPARAMETERFVNVPROC) __GLeeGetProcAddress("glGetCombinerInputParameterfvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetCombinerInputParameterivNV = (GLEEPFNGLGETCOMBINERINPUTPARAMETERIVNVPROC) __GLeeGetProcAddress("glGetCombinerInputParameterivNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetCombinerOutputParameterfvNV = (GLEEPFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC) __GLeeGetProcAddress("glGetCombinerOutputParameterfvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetCombinerOutputParameterivNV = (GLEEPFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC) __GLeeGetProcAddress("glGetCombinerOutputParameterivNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetFinalCombinerInputParameterfvNV = (GLEEPFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC) __GLeeGetProcAddress("glGetFinalCombinerInputParameterfvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetFinalCombinerInputParameterivNV = (GLEEPFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC) __GLeeGetProcAddress("glGetFinalCombinerInputParameterivNV"))!=0) nLinked++;
#endif
if (nLinked==13) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_NV_fog_distance(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_texgen_emboss(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_blend_square(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_texture_env_combine4(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_MESA_resize_buffers(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_MESA_resize_buffers
if ((GLeeFuncPtr_glResizeBuffersMESA = (GLEEPFNGLRESIZEBUFFERSMESAPROC) __GLeeGetProcAddress("glResizeBuffersMESA"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_MESA_window_pos(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_MESA_window_pos
if ((GLeeFuncPtr_glWindowPos2dMESA = (GLEEPFNGLWINDOWPOS2DMESAPROC) __GLeeGetProcAddress("glWindowPos2dMESA"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos2dvMESA = (GLEEPFNGLWINDOWPOS2DVMESAPROC) __GLeeGetProcAddress("glWindowPos2dvMESA"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos2fMESA = (GLEEPFNGLWINDOWPOS2FMESAPROC) __GLeeGetProcAddress("glWindowPos2fMESA"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos2fvMESA = (GLEEPFNGLWINDOWPOS2FVMESAPROC) __GLeeGetProcAddress("glWindowPos2fvMESA"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos2iMESA = (GLEEPFNGLWINDOWPOS2IMESAPROC) __GLeeGetProcAddress("glWindowPos2iMESA"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos2ivMESA = (GLEEPFNGLWINDOWPOS2IVMESAPROC) __GLeeGetProcAddress("glWindowPos2ivMESA"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos2sMESA = (GLEEPFNGLWINDOWPOS2SMESAPROC) __GLeeGetProcAddress("glWindowPos2sMESA"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos2svMESA = (GLEEPFNGLWINDOWPOS2SVMESAPROC) __GLeeGetProcAddress("glWindowPos2svMESA"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos3dMESA = (GLEEPFNGLWINDOWPOS3DMESAPROC) __GLeeGetProcAddress("glWindowPos3dMESA"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos3dvMESA = (GLEEPFNGLWINDOWPOS3DVMESAPROC) __GLeeGetProcAddress("glWindowPos3dvMESA"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos3fMESA = (GLEEPFNGLWINDOWPOS3FMESAPROC) __GLeeGetProcAddress("glWindowPos3fMESA"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos3fvMESA = (GLEEPFNGLWINDOWPOS3FVMESAPROC) __GLeeGetProcAddress("glWindowPos3fvMESA"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos3iMESA = (GLEEPFNGLWINDOWPOS3IMESAPROC) __GLeeGetProcAddress("glWindowPos3iMESA"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos3ivMESA = (GLEEPFNGLWINDOWPOS3IVMESAPROC) __GLeeGetProcAddress("glWindowPos3ivMESA"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos3sMESA = (GLEEPFNGLWINDOWPOS3SMESAPROC) __GLeeGetProcAddress("glWindowPos3sMESA"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos3svMESA = (GLEEPFNGLWINDOWPOS3SVMESAPROC) __GLeeGetProcAddress("glWindowPos3svMESA"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos4dMESA = (GLEEPFNGLWINDOWPOS4DMESAPROC) __GLeeGetProcAddress("glWindowPos4dMESA"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos4dvMESA = (GLEEPFNGLWINDOWPOS4DVMESAPROC) __GLeeGetProcAddress("glWindowPos4dvMESA"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos4fMESA = (GLEEPFNGLWINDOWPOS4FMESAPROC) __GLeeGetProcAddress("glWindowPos4fMESA"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos4fvMESA = (GLEEPFNGLWINDOWPOS4FVMESAPROC) __GLeeGetProcAddress("glWindowPos4fvMESA"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos4iMESA = (GLEEPFNGLWINDOWPOS4IMESAPROC) __GLeeGetProcAddress("glWindowPos4iMESA"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos4ivMESA = (GLEEPFNGLWINDOWPOS4IVMESAPROC) __GLeeGetProcAddress("glWindowPos4ivMESA"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos4sMESA = (GLEEPFNGLWINDOWPOS4SMESAPROC) __GLeeGetProcAddress("glWindowPos4sMESA"))!=0) nLinked++;
if ((GLeeFuncPtr_glWindowPos4svMESA = (GLEEPFNGLWINDOWPOS4SVMESAPROC) __GLeeGetProcAddress("glWindowPos4svMESA"))!=0) nLinked++;
#endif
if (nLinked==24) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_texture_compression_s3tc(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_IBM_cull_vertex(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_IBM_multimode_draw_arrays(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_IBM_multimode_draw_arrays
if ((GLeeFuncPtr_glMultiModeDrawArraysIBM = (GLEEPFNGLMULTIMODEDRAWARRAYSIBMPROC) __GLeeGetProcAddress("glMultiModeDrawArraysIBM"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiModeDrawElementsIBM = (GLEEPFNGLMULTIMODEDRAWELEMENTSIBMPROC) __GLeeGetProcAddress("glMultiModeDrawElementsIBM"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_IBM_vertex_array_lists(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_IBM_vertex_array_lists
if ((GLeeFuncPtr_glColorPointerListIBM = (GLEEPFNGLCOLORPOINTERLISTIBMPROC) __GLeeGetProcAddress("glColorPointerListIBM"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColorPointerListIBM = (GLEEPFNGLSECONDARYCOLORPOINTERLISTIBMPROC) __GLeeGetProcAddress("glSecondaryColorPointerListIBM"))!=0) nLinked++;
if ((GLeeFuncPtr_glEdgeFlagPointerListIBM = (GLEEPFNGLEDGEFLAGPOINTERLISTIBMPROC) __GLeeGetProcAddress("glEdgeFlagPointerListIBM"))!=0) nLinked++;
if ((GLeeFuncPtr_glFogCoordPointerListIBM = (GLEEPFNGLFOGCOORDPOINTERLISTIBMPROC) __GLeeGetProcAddress("glFogCoordPointerListIBM"))!=0) nLinked++;
if ((GLeeFuncPtr_glIndexPointerListIBM = (GLEEPFNGLINDEXPOINTERLISTIBMPROC) __GLeeGetProcAddress("glIndexPointerListIBM"))!=0) nLinked++;
if ((GLeeFuncPtr_glNormalPointerListIBM = (GLEEPFNGLNORMALPOINTERLISTIBMPROC) __GLeeGetProcAddress("glNormalPointerListIBM"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexCoordPointerListIBM = (GLEEPFNGLTEXCOORDPOINTERLISTIBMPROC) __GLeeGetProcAddress("glTexCoordPointerListIBM"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexPointerListIBM = (GLEEPFNGLVERTEXPOINTERLISTIBMPROC) __GLeeGetProcAddress("glVertexPointerListIBM"))!=0) nLinked++;
#endif
if (nLinked==8) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SGIX_subsample(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIX_ycrcb_subsample(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIX_ycrcba(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGI_depth_pass_instrument(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_3DFX_texture_compression_FXT1(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_3DFX_multisample(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_3DFX_tbuffer(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_3DFX_tbuffer
if ((GLeeFuncPtr_glTbufferMask3DFX = (GLEEPFNGLTBUFFERMASK3DFXPROC) __GLeeGetProcAddress("glTbufferMask3DFX"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_multisample(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_multisample
if ((GLeeFuncPtr_glSampleMaskEXT = (GLEEPFNGLSAMPLEMASKEXTPROC) __GLeeGetProcAddress("glSampleMaskEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glSamplePatternEXT = (GLEEPFNGLSAMPLEPATTERNEXTPROC) __GLeeGetProcAddress("glSamplePatternEXT"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SGIX_vertex_preclip(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIX_convolution_accuracy(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIX_resample(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIS_point_line_texgen(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIS_texture_color_mask(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_SGIS_texture_color_mask
if ((GLeeFuncPtr_glTextureColorMaskSGIS = (GLEEPFNGLTEXTURECOLORMASKSGISPROC) __GLeeGetProcAddress("glTextureColorMaskSGIS"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_texture_env_dot3(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ATI_texture_mirror_once(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_fence(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_NV_fence
if ((GLeeFuncPtr_glDeleteFencesNV = (GLEEPFNGLDELETEFENCESNVPROC) __GLeeGetProcAddress("glDeleteFencesNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGenFencesNV = (GLEEPFNGLGENFENCESNVPROC) __GLeeGetProcAddress("glGenFencesNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glIsFenceNV = (GLEEPFNGLISFENCENVPROC) __GLeeGetProcAddress("glIsFenceNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glTestFenceNV = (GLEEPFNGLTESTFENCENVPROC) __GLeeGetProcAddress("glTestFenceNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetFenceivNV = (GLEEPFNGLGETFENCEIVNVPROC) __GLeeGetProcAddress("glGetFenceivNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glFinishFenceNV = (GLEEPFNGLFINISHFENCENVPROC) __GLeeGetProcAddress("glFinishFenceNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glSetFenceNV = (GLEEPFNGLSETFENCENVPROC) __GLeeGetProcAddress("glSetFenceNV"))!=0) nLinked++;
#endif
if (nLinked==7) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_IBM_texture_mirrored_repeat(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_evaluators(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_NV_evaluators
if ((GLeeFuncPtr_glMapControlPointsNV = (GLEEPFNGLMAPCONTROLPOINTSNVPROC) __GLeeGetProcAddress("glMapControlPointsNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glMapParameterivNV = (GLEEPFNGLMAPPARAMETERIVNVPROC) __GLeeGetProcAddress("glMapParameterivNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glMapParameterfvNV = (GLEEPFNGLMAPPARAMETERFVNVPROC) __GLeeGetProcAddress("glMapParameterfvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetMapControlPointsNV = (GLEEPFNGLGETMAPCONTROLPOINTSNVPROC) __GLeeGetProcAddress("glGetMapControlPointsNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetMapParameterivNV = (GLEEPFNGLGETMAPPARAMETERIVNVPROC) __GLeeGetProcAddress("glGetMapParameterivNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetMapParameterfvNV = (GLEEPFNGLGETMAPPARAMETERFVNVPROC) __GLeeGetProcAddress("glGetMapParameterfvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetMapAttribParameterivNV = (GLEEPFNGLGETMAPATTRIBPARAMETERIVNVPROC) __GLeeGetProcAddress("glGetMapAttribParameterivNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetMapAttribParameterfvNV = (GLEEPFNGLGETMAPATTRIBPARAMETERFVNVPROC) __GLeeGetProcAddress("glGetMapAttribParameterfvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glEvalMapsNV = (GLEEPFNGLEVALMAPSNVPROC) __GLeeGetProcAddress("glEvalMapsNV"))!=0) nLinked++;
#endif
if (nLinked==9) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_NV_packed_depth_stencil(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_register_combiners2(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_NV_register_combiners2
if ((GLeeFuncPtr_glCombinerStageParameterfvNV = (GLEEPFNGLCOMBINERSTAGEPARAMETERFVNVPROC) __GLeeGetProcAddress("glCombinerStageParameterfvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetCombinerStageParameterfvNV = (GLEEPFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC) __GLeeGetProcAddress("glGetCombinerStageParameterfvNV"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_NV_texture_compression_vtc(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_texture_rectangle(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_texture_shader(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_texture_shader2(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_vertex_array_range2(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_vertex_program(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_NV_vertex_program
if ((GLeeFuncPtr_glAreProgramsResidentNV = (GLEEPFNGLAREPROGRAMSRESIDENTNVPROC) __GLeeGetProcAddress("glAreProgramsResidentNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glBindProgramNV = (GLEEPFNGLBINDPROGRAMNVPROC) __GLeeGetProcAddress("glBindProgramNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glDeleteProgramsNV = (GLEEPFNGLDELETEPROGRAMSNVPROC) __GLeeGetProcAddress("glDeleteProgramsNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glExecuteProgramNV = (GLEEPFNGLEXECUTEPROGRAMNVPROC) __GLeeGetProcAddress("glExecuteProgramNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGenProgramsNV = (GLEEPFNGLGENPROGRAMSNVPROC) __GLeeGetProcAddress("glGenProgramsNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetProgramParameterdvNV = (GLEEPFNGLGETPROGRAMPARAMETERDVNVPROC) __GLeeGetProcAddress("glGetProgramParameterdvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetProgramParameterfvNV = (GLEEPFNGLGETPROGRAMPARAMETERFVNVPROC) __GLeeGetProcAddress("glGetProgramParameterfvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetProgramivNV = (GLEEPFNGLGETPROGRAMIVNVPROC) __GLeeGetProcAddress("glGetProgramivNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetProgramStringNV = (GLEEPFNGLGETPROGRAMSTRINGNVPROC) __GLeeGetProcAddress("glGetProgramStringNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetTrackMatrixivNV = (GLEEPFNGLGETTRACKMATRIXIVNVPROC) __GLeeGetProcAddress("glGetTrackMatrixivNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetVertexAttribdvNV = (GLEEPFNGLGETVERTEXATTRIBDVNVPROC) __GLeeGetProcAddress("glGetVertexAttribdvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetVertexAttribfvNV = (GLEEPFNGLGETVERTEXATTRIBFVNVPROC) __GLeeGetProcAddress("glGetVertexAttribfvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetVertexAttribivNV = (GLEEPFNGLGETVERTEXATTRIBIVNVPROC) __GLeeGetProcAddress("glGetVertexAttribivNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetVertexAttribPointervNV = (GLEEPFNGLGETVERTEXATTRIBPOINTERVNVPROC) __GLeeGetProcAddress("glGetVertexAttribPointervNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glIsProgramNV = (GLEEPFNGLISPROGRAMNVPROC) __GLeeGetProcAddress("glIsProgramNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glLoadProgramNV = (GLEEPFNGLLOADPROGRAMNVPROC) __GLeeGetProcAddress("glLoadProgramNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramParameter4dNV = (GLEEPFNGLPROGRAMPARAMETER4DNVPROC) __GLeeGetProcAddress("glProgramParameter4dNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramParameter4dvNV = (GLEEPFNGLPROGRAMPARAMETER4DVNVPROC) __GLeeGetProcAddress("glProgramParameter4dvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramParameter4fNV = (GLEEPFNGLPROGRAMPARAMETER4FNVPROC) __GLeeGetProcAddress("glProgramParameter4fNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramParameter4fvNV = (GLEEPFNGLPROGRAMPARAMETER4FVNVPROC) __GLeeGetProcAddress("glProgramParameter4fvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramParameters4dvNV = (GLEEPFNGLPROGRAMPARAMETERS4DVNVPROC) __GLeeGetProcAddress("glProgramParameters4dvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramParameters4fvNV = (GLEEPFNGLPROGRAMPARAMETERS4FVNVPROC) __GLeeGetProcAddress("glProgramParameters4fvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glRequestResidentProgramsNV = (GLEEPFNGLREQUESTRESIDENTPROGRAMSNVPROC) __GLeeGetProcAddress("glRequestResidentProgramsNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glTrackMatrixNV = (GLEEPFNGLTRACKMATRIXNVPROC) __GLeeGetProcAddress("glTrackMatrixNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribPointerNV = (GLEEPFNGLVERTEXATTRIBPOINTERNVPROC) __GLeeGetProcAddress("glVertexAttribPointerNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib1dNV = (GLEEPFNGLVERTEXATTRIB1DNVPROC) __GLeeGetProcAddress("glVertexAttrib1dNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib1dvNV = (GLEEPFNGLVERTEXATTRIB1DVNVPROC) __GLeeGetProcAddress("glVertexAttrib1dvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib1fNV = (GLEEPFNGLVERTEXATTRIB1FNVPROC) __GLeeGetProcAddress("glVertexAttrib1fNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib1fvNV = (GLEEPFNGLVERTEXATTRIB1FVNVPROC) __GLeeGetProcAddress("glVertexAttrib1fvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib1sNV = (GLEEPFNGLVERTEXATTRIB1SNVPROC) __GLeeGetProcAddress("glVertexAttrib1sNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib1svNV = (GLEEPFNGLVERTEXATTRIB1SVNVPROC) __GLeeGetProcAddress("glVertexAttrib1svNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib2dNV = (GLEEPFNGLVERTEXATTRIB2DNVPROC) __GLeeGetProcAddress("glVertexAttrib2dNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib2dvNV = (GLEEPFNGLVERTEXATTRIB2DVNVPROC) __GLeeGetProcAddress("glVertexAttrib2dvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib2fNV = (GLEEPFNGLVERTEXATTRIB2FNVPROC) __GLeeGetProcAddress("glVertexAttrib2fNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib2fvNV = (GLEEPFNGLVERTEXATTRIB2FVNVPROC) __GLeeGetProcAddress("glVertexAttrib2fvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib2sNV = (GLEEPFNGLVERTEXATTRIB2SNVPROC) __GLeeGetProcAddress("glVertexAttrib2sNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib2svNV = (GLEEPFNGLVERTEXATTRIB2SVNVPROC) __GLeeGetProcAddress("glVertexAttrib2svNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib3dNV = (GLEEPFNGLVERTEXATTRIB3DNVPROC) __GLeeGetProcAddress("glVertexAttrib3dNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib3dvNV = (GLEEPFNGLVERTEXATTRIB3DVNVPROC) __GLeeGetProcAddress("glVertexAttrib3dvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib3fNV = (GLEEPFNGLVERTEXATTRIB3FNVPROC) __GLeeGetProcAddress("glVertexAttrib3fNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib3fvNV = (GLEEPFNGLVERTEXATTRIB3FVNVPROC) __GLeeGetProcAddress("glVertexAttrib3fvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib3sNV = (GLEEPFNGLVERTEXATTRIB3SNVPROC) __GLeeGetProcAddress("glVertexAttrib3sNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib3svNV = (GLEEPFNGLVERTEXATTRIB3SVNVPROC) __GLeeGetProcAddress("glVertexAttrib3svNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4dNV = (GLEEPFNGLVERTEXATTRIB4DNVPROC) __GLeeGetProcAddress("glVertexAttrib4dNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4dvNV = (GLEEPFNGLVERTEXATTRIB4DVNVPROC) __GLeeGetProcAddress("glVertexAttrib4dvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4fNV = (GLEEPFNGLVERTEXATTRIB4FNVPROC) __GLeeGetProcAddress("glVertexAttrib4fNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4fvNV = (GLEEPFNGLVERTEXATTRIB4FVNVPROC) __GLeeGetProcAddress("glVertexAttrib4fvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4sNV = (GLEEPFNGLVERTEXATTRIB4SNVPROC) __GLeeGetProcAddress("glVertexAttrib4sNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4svNV = (GLEEPFNGLVERTEXATTRIB4SVNVPROC) __GLeeGetProcAddress("glVertexAttrib4svNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4ubNV = (GLEEPFNGLVERTEXATTRIB4UBNVPROC) __GLeeGetProcAddress("glVertexAttrib4ubNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4ubvNV = (GLEEPFNGLVERTEXATTRIB4UBVNVPROC) __GLeeGetProcAddress("glVertexAttrib4ubvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribs1dvNV = (GLEEPFNGLVERTEXATTRIBS1DVNVPROC) __GLeeGetProcAddress("glVertexAttribs1dvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribs1fvNV = (GLEEPFNGLVERTEXATTRIBS1FVNVPROC) __GLeeGetProcAddress("glVertexAttribs1fvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribs1svNV = (GLEEPFNGLVERTEXATTRIBS1SVNVPROC) __GLeeGetProcAddress("glVertexAttribs1svNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribs2dvNV = (GLEEPFNGLVERTEXATTRIBS2DVNVPROC) __GLeeGetProcAddress("glVertexAttribs2dvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribs2fvNV = (GLEEPFNGLVERTEXATTRIBS2FVNVPROC) __GLeeGetProcAddress("glVertexAttribs2fvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribs2svNV = (GLEEPFNGLVERTEXATTRIBS2SVNVPROC) __GLeeGetProcAddress("glVertexAttribs2svNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribs3dvNV = (GLEEPFNGLVERTEXATTRIBS3DVNVPROC) __GLeeGetProcAddress("glVertexAttribs3dvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribs3fvNV = (GLEEPFNGLVERTEXATTRIBS3FVNVPROC) __GLeeGetProcAddress("glVertexAttribs3fvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribs3svNV = (GLEEPFNGLVERTEXATTRIBS3SVNVPROC) __GLeeGetProcAddress("glVertexAttribs3svNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribs4dvNV = (GLEEPFNGLVERTEXATTRIBS4DVNVPROC) __GLeeGetProcAddress("glVertexAttribs4dvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribs4fvNV = (GLEEPFNGLVERTEXATTRIBS4FVNVPROC) __GLeeGetProcAddress("glVertexAttribs4fvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribs4svNV = (GLEEPFNGLVERTEXATTRIBS4SVNVPROC) __GLeeGetProcAddress("glVertexAttribs4svNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribs4ubvNV = (GLEEPFNGLVERTEXATTRIBS4UBVNVPROC) __GLeeGetProcAddress("glVertexAttribs4ubvNV"))!=0) nLinked++;
#endif
if (nLinked==64) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SGIX_texture_coordinate_clamp(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIX_scalebias_hint(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_OML_interlace(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_OML_subsample(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_OML_resample(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_copy_depth_to_color(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ATI_envmap_bumpmap(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ATI_envmap_bumpmap
if ((GLeeFuncPtr_glTexBumpParameterivATI = (GLEEPFNGLTEXBUMPPARAMETERIVATIPROC) __GLeeGetProcAddress("glTexBumpParameterivATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexBumpParameterfvATI = (GLEEPFNGLTEXBUMPPARAMETERFVATIPROC) __GLeeGetProcAddress("glTexBumpParameterfvATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetTexBumpParameterivATI = (GLEEPFNGLGETTEXBUMPPARAMETERIVATIPROC) __GLeeGetProcAddress("glGetTexBumpParameterivATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetTexBumpParameterfvATI = (GLEEPFNGLGETTEXBUMPPARAMETERFVATIPROC) __GLeeGetProcAddress("glGetTexBumpParameterfvATI"))!=0) nLinked++;
#endif
if (nLinked==4) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ATI_fragment_shader(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ATI_fragment_shader
if ((GLeeFuncPtr_glGenFragmentShadersATI = (GLEEPFNGLGENFRAGMENTSHADERSATIPROC) __GLeeGetProcAddress("glGenFragmentShadersATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glBindFragmentShaderATI = (GLEEPFNGLBINDFRAGMENTSHADERATIPROC) __GLeeGetProcAddress("glBindFragmentShaderATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glDeleteFragmentShaderATI = (GLEEPFNGLDELETEFRAGMENTSHADERATIPROC) __GLeeGetProcAddress("glDeleteFragmentShaderATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glBeginFragmentShaderATI = (GLEEPFNGLBEGINFRAGMENTSHADERATIPROC) __GLeeGetProcAddress("glBeginFragmentShaderATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glEndFragmentShaderATI = (GLEEPFNGLENDFRAGMENTSHADERATIPROC) __GLeeGetProcAddress("glEndFragmentShaderATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glPassTexCoordATI = (GLEEPFNGLPASSTEXCOORDATIPROC) __GLeeGetProcAddress("glPassTexCoordATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glSampleMapATI = (GLEEPFNGLSAMPLEMAPATIPROC) __GLeeGetProcAddress("glSampleMapATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glColorFragmentOp1ATI = (GLEEPFNGLCOLORFRAGMENTOP1ATIPROC) __GLeeGetProcAddress("glColorFragmentOp1ATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glColorFragmentOp2ATI = (GLEEPFNGLCOLORFRAGMENTOP2ATIPROC) __GLeeGetProcAddress("glColorFragmentOp2ATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glColorFragmentOp3ATI = (GLEEPFNGLCOLORFRAGMENTOP3ATIPROC) __GLeeGetProcAddress("glColorFragmentOp3ATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glAlphaFragmentOp1ATI = (GLEEPFNGLALPHAFRAGMENTOP1ATIPROC) __GLeeGetProcAddress("glAlphaFragmentOp1ATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glAlphaFragmentOp2ATI = (GLEEPFNGLALPHAFRAGMENTOP2ATIPROC) __GLeeGetProcAddress("glAlphaFragmentOp2ATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glAlphaFragmentOp3ATI = (GLEEPFNGLALPHAFRAGMENTOP3ATIPROC) __GLeeGetProcAddress("glAlphaFragmentOp3ATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glSetFragmentShaderConstantATI = (GLEEPFNGLSETFRAGMENTSHADERCONSTANTATIPROC) __GLeeGetProcAddress("glSetFragmentShaderConstantATI"))!=0) nLinked++;
#endif
if (nLinked==14) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ATI_pn_triangles(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ATI_pn_triangles
if ((GLeeFuncPtr_glPNTrianglesiATI = (GLEEPFNGLPNTRIANGLESIATIPROC) __GLeeGetProcAddress("glPNTrianglesiATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glPNTrianglesfATI = (GLEEPFNGLPNTRIANGLESFATIPROC) __GLeeGetProcAddress("glPNTrianglesfATI"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ATI_vertex_array_object(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ATI_vertex_array_object
if ((GLeeFuncPtr_glNewObjectBufferATI = (GLEEPFNGLNEWOBJECTBUFFERATIPROC) __GLeeGetProcAddress("glNewObjectBufferATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glIsObjectBufferATI = (GLEEPFNGLISOBJECTBUFFERATIPROC) __GLeeGetProcAddress("glIsObjectBufferATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glUpdateObjectBufferATI = (GLEEPFNGLUPDATEOBJECTBUFFERATIPROC) __GLeeGetProcAddress("glUpdateObjectBufferATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetObjectBufferfvATI = (GLEEPFNGLGETOBJECTBUFFERFVATIPROC) __GLeeGetProcAddress("glGetObjectBufferfvATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetObjectBufferivATI = (GLEEPFNGLGETOBJECTBUFFERIVATIPROC) __GLeeGetProcAddress("glGetObjectBufferivATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glFreeObjectBufferATI = (GLEEPFNGLFREEOBJECTBUFFERATIPROC) __GLeeGetProcAddress("glFreeObjectBufferATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glArrayObjectATI = (GLEEPFNGLARRAYOBJECTATIPROC) __GLeeGetProcAddress("glArrayObjectATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetArrayObjectfvATI = (GLEEPFNGLGETARRAYOBJECTFVATIPROC) __GLeeGetProcAddress("glGetArrayObjectfvATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetArrayObjectivATI = (GLEEPFNGLGETARRAYOBJECTIVATIPROC) __GLeeGetProcAddress("glGetArrayObjectivATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVariantArrayObjectATI = (GLEEPFNGLVARIANTARRAYOBJECTATIPROC) __GLeeGetProcAddress("glVariantArrayObjectATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetVariantArrayObjectfvATI = (GLEEPFNGLGETVARIANTARRAYOBJECTFVATIPROC) __GLeeGetProcAddress("glGetVariantArrayObjectfvATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetVariantArrayObjectivATI = (GLEEPFNGLGETVARIANTARRAYOBJECTIVATIPROC) __GLeeGetProcAddress("glGetVariantArrayObjectivATI"))!=0) nLinked++;
#endif
if (nLinked==12) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_vertex_shader(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_vertex_shader
if ((GLeeFuncPtr_glBeginVertexShaderEXT = (GLEEPFNGLBEGINVERTEXSHADEREXTPROC) __GLeeGetProcAddress("glBeginVertexShaderEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glEndVertexShaderEXT = (GLEEPFNGLENDVERTEXSHADEREXTPROC) __GLeeGetProcAddress("glEndVertexShaderEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glBindVertexShaderEXT = (GLEEPFNGLBINDVERTEXSHADEREXTPROC) __GLeeGetProcAddress("glBindVertexShaderEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGenVertexShadersEXT = (GLEEPFNGLGENVERTEXSHADERSEXTPROC) __GLeeGetProcAddress("glGenVertexShadersEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glDeleteVertexShaderEXT = (GLEEPFNGLDELETEVERTEXSHADEREXTPROC) __GLeeGetProcAddress("glDeleteVertexShaderEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glShaderOp1EXT = (GLEEPFNGLSHADEROP1EXTPROC) __GLeeGetProcAddress("glShaderOp1EXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glShaderOp2EXT = (GLEEPFNGLSHADEROP2EXTPROC) __GLeeGetProcAddress("glShaderOp2EXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glShaderOp3EXT = (GLEEPFNGLSHADEROP3EXTPROC) __GLeeGetProcAddress("glShaderOp3EXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glSwizzleEXT = (GLEEPFNGLSWIZZLEEXTPROC) __GLeeGetProcAddress("glSwizzleEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glWriteMaskEXT = (GLEEPFNGLWRITEMASKEXTPROC) __GLeeGetProcAddress("glWriteMaskEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glInsertComponentEXT = (GLEEPFNGLINSERTCOMPONENTEXTPROC) __GLeeGetProcAddress("glInsertComponentEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glExtractComponentEXT = (GLEEPFNGLEXTRACTCOMPONENTEXTPROC) __GLeeGetProcAddress("glExtractComponentEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGenSymbolsEXT = (GLEEPFNGLGENSYMBOLSEXTPROC) __GLeeGetProcAddress("glGenSymbolsEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glSetInvariantEXT = (GLEEPFNGLSETINVARIANTEXTPROC) __GLeeGetProcAddress("glSetInvariantEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glSetLocalConstantEXT = (GLEEPFNGLSETLOCALCONSTANTEXTPROC) __GLeeGetProcAddress("glSetLocalConstantEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVariantbvEXT = (GLEEPFNGLVARIANTBVEXTPROC) __GLeeGetProcAddress("glVariantbvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVariantsvEXT = (GLEEPFNGLVARIANTSVEXTPROC) __GLeeGetProcAddress("glVariantsvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVariantivEXT = (GLEEPFNGLVARIANTIVEXTPROC) __GLeeGetProcAddress("glVariantivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVariantfvEXT = (GLEEPFNGLVARIANTFVEXTPROC) __GLeeGetProcAddress("glVariantfvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVariantdvEXT = (GLEEPFNGLVARIANTDVEXTPROC) __GLeeGetProcAddress("glVariantdvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVariantubvEXT = (GLEEPFNGLVARIANTUBVEXTPROC) __GLeeGetProcAddress("glVariantubvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVariantusvEXT = (GLEEPFNGLVARIANTUSVEXTPROC) __GLeeGetProcAddress("glVariantusvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVariantuivEXT = (GLEEPFNGLVARIANTUIVEXTPROC) __GLeeGetProcAddress("glVariantuivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVariantPointerEXT = (GLEEPFNGLVARIANTPOINTEREXTPROC) __GLeeGetProcAddress("glVariantPointerEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glEnableVariantClientStateEXT = (GLEEPFNGLENABLEVARIANTCLIENTSTATEEXTPROC) __GLeeGetProcAddress("glEnableVariantClientStateEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glDisableVariantClientStateEXT = (GLEEPFNGLDISABLEVARIANTCLIENTSTATEEXTPROC) __GLeeGetProcAddress("glDisableVariantClientStateEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glBindLightParameterEXT = (GLEEPFNGLBINDLIGHTPARAMETEREXTPROC) __GLeeGetProcAddress("glBindLightParameterEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glBindMaterialParameterEXT = (GLEEPFNGLBINDMATERIALPARAMETEREXTPROC) __GLeeGetProcAddress("glBindMaterialParameterEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glBindTexGenParameterEXT = (GLEEPFNGLBINDTEXGENPARAMETEREXTPROC) __GLeeGetProcAddress("glBindTexGenParameterEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glBindTextureUnitParameterEXT = (GLEEPFNGLBINDTEXTUREUNITPARAMETEREXTPROC) __GLeeGetProcAddress("glBindTextureUnitParameterEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glBindParameterEXT = (GLEEPFNGLBINDPARAMETEREXTPROC) __GLeeGetProcAddress("glBindParameterEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glIsVariantEnabledEXT = (GLEEPFNGLISVARIANTENABLEDEXTPROC) __GLeeGetProcAddress("glIsVariantEnabledEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetVariantBooleanvEXT = (GLEEPFNGLGETVARIANTBOOLEANVEXTPROC) __GLeeGetProcAddress("glGetVariantBooleanvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetVariantIntegervEXT = (GLEEPFNGLGETVARIANTINTEGERVEXTPROC) __GLeeGetProcAddress("glGetVariantIntegervEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetVariantFloatvEXT = (GLEEPFNGLGETVARIANTFLOATVEXTPROC) __GLeeGetProcAddress("glGetVariantFloatvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetVariantPointervEXT = (GLEEPFNGLGETVARIANTPOINTERVEXTPROC) __GLeeGetProcAddress("glGetVariantPointervEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetInvariantBooleanvEXT = (GLEEPFNGLGETINVARIANTBOOLEANVEXTPROC) __GLeeGetProcAddress("glGetInvariantBooleanvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetInvariantIntegervEXT = (GLEEPFNGLGETINVARIANTINTEGERVEXTPROC) __GLeeGetProcAddress("glGetInvariantIntegervEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetInvariantFloatvEXT = (GLEEPFNGLGETINVARIANTFLOATVEXTPROC) __GLeeGetProcAddress("glGetInvariantFloatvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetLocalConstantBooleanvEXT = (GLEEPFNGLGETLOCALCONSTANTBOOLEANVEXTPROC) __GLeeGetProcAddress("glGetLocalConstantBooleanvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetLocalConstantIntegervEXT = (GLEEPFNGLGETLOCALCONSTANTINTEGERVEXTPROC) __GLeeGetProcAddress("glGetLocalConstantIntegervEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetLocalConstantFloatvEXT = (GLEEPFNGLGETLOCALCONSTANTFLOATVEXTPROC) __GLeeGetProcAddress("glGetLocalConstantFloatvEXT"))!=0) nLinked++;
#endif
if (nLinked==42) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ATI_vertex_streams(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ATI_vertex_streams
if ((GLeeFuncPtr_glVertexStream1sATI = (GLEEPFNGLVERTEXSTREAM1SATIPROC) __GLeeGetProcAddress("glVertexStream1sATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream1svATI = (GLEEPFNGLVERTEXSTREAM1SVATIPROC) __GLeeGetProcAddress("glVertexStream1svATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream1iATI = (GLEEPFNGLVERTEXSTREAM1IATIPROC) __GLeeGetProcAddress("glVertexStream1iATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream1ivATI = (GLEEPFNGLVERTEXSTREAM1IVATIPROC) __GLeeGetProcAddress("glVertexStream1ivATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream1fATI = (GLEEPFNGLVERTEXSTREAM1FATIPROC) __GLeeGetProcAddress("glVertexStream1fATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream1fvATI = (GLEEPFNGLVERTEXSTREAM1FVATIPROC) __GLeeGetProcAddress("glVertexStream1fvATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream1dATI = (GLEEPFNGLVERTEXSTREAM1DATIPROC) __GLeeGetProcAddress("glVertexStream1dATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream1dvATI = (GLEEPFNGLVERTEXSTREAM1DVATIPROC) __GLeeGetProcAddress("glVertexStream1dvATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream2sATI = (GLEEPFNGLVERTEXSTREAM2SATIPROC) __GLeeGetProcAddress("glVertexStream2sATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream2svATI = (GLEEPFNGLVERTEXSTREAM2SVATIPROC) __GLeeGetProcAddress("glVertexStream2svATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream2iATI = (GLEEPFNGLVERTEXSTREAM2IATIPROC) __GLeeGetProcAddress("glVertexStream2iATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream2ivATI = (GLEEPFNGLVERTEXSTREAM2IVATIPROC) __GLeeGetProcAddress("glVertexStream2ivATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream2fATI = (GLEEPFNGLVERTEXSTREAM2FATIPROC) __GLeeGetProcAddress("glVertexStream2fATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream2fvATI = (GLEEPFNGLVERTEXSTREAM2FVATIPROC) __GLeeGetProcAddress("glVertexStream2fvATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream2dATI = (GLEEPFNGLVERTEXSTREAM2DATIPROC) __GLeeGetProcAddress("glVertexStream2dATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream2dvATI = (GLEEPFNGLVERTEXSTREAM2DVATIPROC) __GLeeGetProcAddress("glVertexStream2dvATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream3sATI = (GLEEPFNGLVERTEXSTREAM3SATIPROC) __GLeeGetProcAddress("glVertexStream3sATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream3svATI = (GLEEPFNGLVERTEXSTREAM3SVATIPROC) __GLeeGetProcAddress("glVertexStream3svATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream3iATI = (GLEEPFNGLVERTEXSTREAM3IATIPROC) __GLeeGetProcAddress("glVertexStream3iATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream3ivATI = (GLEEPFNGLVERTEXSTREAM3IVATIPROC) __GLeeGetProcAddress("glVertexStream3ivATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream3fATI = (GLEEPFNGLVERTEXSTREAM3FATIPROC) __GLeeGetProcAddress("glVertexStream3fATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream3fvATI = (GLEEPFNGLVERTEXSTREAM3FVATIPROC) __GLeeGetProcAddress("glVertexStream3fvATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream3dATI = (GLEEPFNGLVERTEXSTREAM3DATIPROC) __GLeeGetProcAddress("glVertexStream3dATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream3dvATI = (GLEEPFNGLVERTEXSTREAM3DVATIPROC) __GLeeGetProcAddress("glVertexStream3dvATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream4sATI = (GLEEPFNGLVERTEXSTREAM4SATIPROC) __GLeeGetProcAddress("glVertexStream4sATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream4svATI = (GLEEPFNGLVERTEXSTREAM4SVATIPROC) __GLeeGetProcAddress("glVertexStream4svATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream4iATI = (GLEEPFNGLVERTEXSTREAM4IATIPROC) __GLeeGetProcAddress("glVertexStream4iATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream4ivATI = (GLEEPFNGLVERTEXSTREAM4IVATIPROC) __GLeeGetProcAddress("glVertexStream4ivATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream4fATI = (GLEEPFNGLVERTEXSTREAM4FATIPROC) __GLeeGetProcAddress("glVertexStream4fATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream4fvATI = (GLEEPFNGLVERTEXSTREAM4FVATIPROC) __GLeeGetProcAddress("glVertexStream4fvATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream4dATI = (GLEEPFNGLVERTEXSTREAM4DATIPROC) __GLeeGetProcAddress("glVertexStream4dATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexStream4dvATI = (GLEEPFNGLVERTEXSTREAM4DVATIPROC) __GLeeGetProcAddress("glVertexStream4dvATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glNormalStream3bATI = (GLEEPFNGLNORMALSTREAM3BATIPROC) __GLeeGetProcAddress("glNormalStream3bATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glNormalStream3bvATI = (GLEEPFNGLNORMALSTREAM3BVATIPROC) __GLeeGetProcAddress("glNormalStream3bvATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glNormalStream3sATI = (GLEEPFNGLNORMALSTREAM3SATIPROC) __GLeeGetProcAddress("glNormalStream3sATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glNormalStream3svATI = (GLEEPFNGLNORMALSTREAM3SVATIPROC) __GLeeGetProcAddress("glNormalStream3svATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glNormalStream3iATI = (GLEEPFNGLNORMALSTREAM3IATIPROC) __GLeeGetProcAddress("glNormalStream3iATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glNormalStream3ivATI = (GLEEPFNGLNORMALSTREAM3IVATIPROC) __GLeeGetProcAddress("glNormalStream3ivATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glNormalStream3fATI = (GLEEPFNGLNORMALSTREAM3FATIPROC) __GLeeGetProcAddress("glNormalStream3fATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glNormalStream3fvATI = (GLEEPFNGLNORMALSTREAM3FVATIPROC) __GLeeGetProcAddress("glNormalStream3fvATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glNormalStream3dATI = (GLEEPFNGLNORMALSTREAM3DATIPROC) __GLeeGetProcAddress("glNormalStream3dATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glNormalStream3dvATI = (GLEEPFNGLNORMALSTREAM3DVATIPROC) __GLeeGetProcAddress("glNormalStream3dvATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glClientActiveVertexStreamATI = (GLEEPFNGLCLIENTACTIVEVERTEXSTREAMATIPROC) __GLeeGetProcAddress("glClientActiveVertexStreamATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexBlendEnviATI = (GLEEPFNGLVERTEXBLENDENVIATIPROC) __GLeeGetProcAddress("glVertexBlendEnviATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexBlendEnvfATI = (GLEEPFNGLVERTEXBLENDENVFATIPROC) __GLeeGetProcAddress("glVertexBlendEnvfATI"))!=0) nLinked++;
#endif
if (nLinked==45) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ATI_element_array(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ATI_element_array
if ((GLeeFuncPtr_glElementPointerATI = (GLEEPFNGLELEMENTPOINTERATIPROC) __GLeeGetProcAddress("glElementPointerATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glDrawElementArrayATI = (GLEEPFNGLDRAWELEMENTARRAYATIPROC) __GLeeGetProcAddress("glDrawElementArrayATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glDrawRangeElementArrayATI = (GLEEPFNGLDRAWRANGEELEMENTARRAYATIPROC) __GLeeGetProcAddress("glDrawRangeElementArrayATI"))!=0) nLinked++;
#endif
if (nLinked==3) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SUN_mesh_array(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_SUN_mesh_array
if ((GLeeFuncPtr_glDrawMeshArraysSUN = (GLEEPFNGLDRAWMESHARRAYSSUNPROC) __GLeeGetProcAddress("glDrawMeshArraysSUN"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SUN_slice_accum(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_multisample_filter_hint(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_depth_clamp(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_occlusion_query(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_NV_occlusion_query
if ((GLeeFuncPtr_glGenOcclusionQueriesNV = (GLEEPFNGLGENOCCLUSIONQUERIESNVPROC) __GLeeGetProcAddress("glGenOcclusionQueriesNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glDeleteOcclusionQueriesNV = (GLEEPFNGLDELETEOCCLUSIONQUERIESNVPROC) __GLeeGetProcAddress("glDeleteOcclusionQueriesNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glIsOcclusionQueryNV = (GLEEPFNGLISOCCLUSIONQUERYNVPROC) __GLeeGetProcAddress("glIsOcclusionQueryNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glBeginOcclusionQueryNV = (GLEEPFNGLBEGINOCCLUSIONQUERYNVPROC) __GLeeGetProcAddress("glBeginOcclusionQueryNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glEndOcclusionQueryNV = (GLEEPFNGLENDOCCLUSIONQUERYNVPROC) __GLeeGetProcAddress("glEndOcclusionQueryNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetOcclusionQueryivNV = (GLEEPFNGLGETOCCLUSIONQUERYIVNVPROC) __GLeeGetProcAddress("glGetOcclusionQueryivNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetOcclusionQueryuivNV = (GLEEPFNGLGETOCCLUSIONQUERYUIVNVPROC) __GLeeGetProcAddress("glGetOcclusionQueryuivNV"))!=0) nLinked++;
#endif
if (nLinked==7) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_NV_point_sprite(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_NV_point_sprite
if ((GLeeFuncPtr_glPointParameteriNV = (GLEEPFNGLPOINTPARAMETERINVPROC) __GLeeGetProcAddress("glPointParameteriNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glPointParameterivNV = (GLEEPFNGLPOINTPARAMETERIVNVPROC) __GLeeGetProcAddress("glPointParameterivNV"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_NV_texture_shader3(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_vertex_program1_1(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_shadow_funcs(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_stencil_two_side(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_stencil_two_side
if ((GLeeFuncPtr_glActiveStencilFaceEXT = (GLEEPFNGLACTIVESTENCILFACEEXTPROC) __GLeeGetProcAddress("glActiveStencilFaceEXT"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ATI_text_fragment_shader(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_APPLE_client_storage(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_APPLE_element_array(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_APPLE_element_array
if ((GLeeFuncPtr_glElementPointerAPPLE = (GLEEPFNGLELEMENTPOINTERAPPLEPROC) __GLeeGetProcAddress("glElementPointerAPPLE"))!=0) nLinked++;
if ((GLeeFuncPtr_glDrawElementArrayAPPLE = (GLEEPFNGLDRAWELEMENTARRAYAPPLEPROC) __GLeeGetProcAddress("glDrawElementArrayAPPLE"))!=0) nLinked++;
if ((GLeeFuncPtr_glDrawRangeElementArrayAPPLE = (GLEEPFNGLDRAWRANGEELEMENTARRAYAPPLEPROC) __GLeeGetProcAddress("glDrawRangeElementArrayAPPLE"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiDrawElementArrayAPPLE = (GLEEPFNGLMULTIDRAWELEMENTARRAYAPPLEPROC) __GLeeGetProcAddress("glMultiDrawElementArrayAPPLE"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiDrawRangeElementArrayAPPLE = (GLEEPFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC) __GLeeGetProcAddress("glMultiDrawRangeElementArrayAPPLE"))!=0) nLinked++;
#endif
if (nLinked==5) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_APPLE_fence(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_APPLE_fence
if ((GLeeFuncPtr_glGenFencesAPPLE = (GLEEPFNGLGENFENCESAPPLEPROC) __GLeeGetProcAddress("glGenFencesAPPLE"))!=0) nLinked++;
if ((GLeeFuncPtr_glDeleteFencesAPPLE = (GLEEPFNGLDELETEFENCESAPPLEPROC) __GLeeGetProcAddress("glDeleteFencesAPPLE"))!=0) nLinked++;
if ((GLeeFuncPtr_glSetFenceAPPLE = (GLEEPFNGLSETFENCEAPPLEPROC) __GLeeGetProcAddress("glSetFenceAPPLE"))!=0) nLinked++;
if ((GLeeFuncPtr_glIsFenceAPPLE = (GLEEPFNGLISFENCEAPPLEPROC) __GLeeGetProcAddress("glIsFenceAPPLE"))!=0) nLinked++;
if ((GLeeFuncPtr_glTestFenceAPPLE = (GLEEPFNGLTESTFENCEAPPLEPROC) __GLeeGetProcAddress("glTestFenceAPPLE"))!=0) nLinked++;
if ((GLeeFuncPtr_glFinishFenceAPPLE = (GLEEPFNGLFINISHFENCEAPPLEPROC) __GLeeGetProcAddress("glFinishFenceAPPLE"))!=0) nLinked++;
if ((GLeeFuncPtr_glTestObjectAPPLE = (GLEEPFNGLTESTOBJECTAPPLEPROC) __GLeeGetProcAddress("glTestObjectAPPLE"))!=0) nLinked++;
if ((GLeeFuncPtr_glFinishObjectAPPLE = (GLEEPFNGLFINISHOBJECTAPPLEPROC) __GLeeGetProcAddress("glFinishObjectAPPLE"))!=0) nLinked++;
#endif
if (nLinked==8) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_APPLE_vertex_array_object(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_APPLE_vertex_array_object
if ((GLeeFuncPtr_glBindVertexArrayAPPLE = (GLEEPFNGLBINDVERTEXARRAYAPPLEPROC) __GLeeGetProcAddress("glBindVertexArrayAPPLE"))!=0) nLinked++;
if ((GLeeFuncPtr_glDeleteVertexArraysAPPLE = (GLEEPFNGLDELETEVERTEXARRAYSAPPLEPROC) __GLeeGetProcAddress("glDeleteVertexArraysAPPLE"))!=0) nLinked++;
if ((GLeeFuncPtr_glGenVertexArraysAPPLE = (GLEEPFNGLGENVERTEXARRAYSAPPLEPROC) __GLeeGetProcAddress("glGenVertexArraysAPPLE"))!=0) nLinked++;
if ((GLeeFuncPtr_glIsVertexArrayAPPLE = (GLEEPFNGLISVERTEXARRAYAPPLEPROC) __GLeeGetProcAddress("glIsVertexArrayAPPLE"))!=0) nLinked++;
#endif
if (nLinked==4) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_APPLE_vertex_array_range(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_APPLE_vertex_array_range
if ((GLeeFuncPtr_glVertexArrayRangeAPPLE = (GLEEPFNGLVERTEXARRAYRANGEAPPLEPROC) __GLeeGetProcAddress("glVertexArrayRangeAPPLE"))!=0) nLinked++;
if ((GLeeFuncPtr_glFlushVertexArrayRangeAPPLE = (GLEEPFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC) __GLeeGetProcAddress("glFlushVertexArrayRangeAPPLE"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexArrayParameteriAPPLE = (GLEEPFNGLVERTEXARRAYPARAMETERIAPPLEPROC) __GLeeGetProcAddress("glVertexArrayParameteriAPPLE"))!=0) nLinked++;
#endif
if (nLinked==3) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_APPLE_ycbcr_422(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_S3_s3tc(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ATI_draw_buffers(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ATI_draw_buffers
if ((GLeeFuncPtr_glDrawBuffersATI = (GLEEPFNGLDRAWBUFFERSATIPROC) __GLeeGetProcAddress("glDrawBuffersATI"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ATI_pixel_format_float(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ATI_texture_env_combine3(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ATI_texture_float(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_float_buffer(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_fragment_program(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_NV_fragment_program
if ((GLeeFuncPtr_glProgramNamedParameter4fNV = (GLEEPFNGLPROGRAMNAMEDPARAMETER4FNVPROC) __GLeeGetProcAddress("glProgramNamedParameter4fNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramNamedParameter4dNV = (GLEEPFNGLPROGRAMNAMEDPARAMETER4DNVPROC) __GLeeGetProcAddress("glProgramNamedParameter4dNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramNamedParameter4fvNV = (GLEEPFNGLPROGRAMNAMEDPARAMETER4FVNVPROC) __GLeeGetProcAddress("glProgramNamedParameter4fvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramNamedParameter4dvNV = (GLEEPFNGLPROGRAMNAMEDPARAMETER4DVNVPROC) __GLeeGetProcAddress("glProgramNamedParameter4dvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetProgramNamedParameterfvNV = (GLEEPFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC) __GLeeGetProcAddress("glGetProgramNamedParameterfvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetProgramNamedParameterdvNV = (GLEEPFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC) __GLeeGetProcAddress("glGetProgramNamedParameterdvNV"))!=0) nLinked++;
#endif
if (nLinked==6) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_NV_half_float(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_NV_half_float
if ((GLeeFuncPtr_glVertex2hNV = (GLEEPFNGLVERTEX2HNVPROC) __GLeeGetProcAddress("glVertex2hNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertex2hvNV = (GLEEPFNGLVERTEX2HVNVPROC) __GLeeGetProcAddress("glVertex2hvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertex3hNV = (GLEEPFNGLVERTEX3HNVPROC) __GLeeGetProcAddress("glVertex3hNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertex3hvNV = (GLEEPFNGLVERTEX3HVNVPROC) __GLeeGetProcAddress("glVertex3hvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertex4hNV = (GLEEPFNGLVERTEX4HNVPROC) __GLeeGetProcAddress("glVertex4hNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertex4hvNV = (GLEEPFNGLVERTEX4HVNVPROC) __GLeeGetProcAddress("glVertex4hvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glNormal3hNV = (GLEEPFNGLNORMAL3HNVPROC) __GLeeGetProcAddress("glNormal3hNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glNormal3hvNV = (GLEEPFNGLNORMAL3HVNVPROC) __GLeeGetProcAddress("glNormal3hvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glColor3hNV = (GLEEPFNGLCOLOR3HNVPROC) __GLeeGetProcAddress("glColor3hNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glColor3hvNV = (GLEEPFNGLCOLOR3HVNVPROC) __GLeeGetProcAddress("glColor3hvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glColor4hNV = (GLEEPFNGLCOLOR4HNVPROC) __GLeeGetProcAddress("glColor4hNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glColor4hvNV = (GLEEPFNGLCOLOR4HVNVPROC) __GLeeGetProcAddress("glColor4hvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexCoord1hNV = (GLEEPFNGLTEXCOORD1HNVPROC) __GLeeGetProcAddress("glTexCoord1hNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexCoord1hvNV = (GLEEPFNGLTEXCOORD1HVNVPROC) __GLeeGetProcAddress("glTexCoord1hvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexCoord2hNV = (GLEEPFNGLTEXCOORD2HNVPROC) __GLeeGetProcAddress("glTexCoord2hNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexCoord2hvNV = (GLEEPFNGLTEXCOORD2HVNVPROC) __GLeeGetProcAddress("glTexCoord2hvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexCoord3hNV = (GLEEPFNGLTEXCOORD3HNVPROC) __GLeeGetProcAddress("glTexCoord3hNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexCoord3hvNV = (GLEEPFNGLTEXCOORD3HVNVPROC) __GLeeGetProcAddress("glTexCoord3hvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexCoord4hNV = (GLEEPFNGLTEXCOORD4HNVPROC) __GLeeGetProcAddress("glTexCoord4hNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexCoord4hvNV = (GLEEPFNGLTEXCOORD4HVNVPROC) __GLeeGetProcAddress("glTexCoord4hvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord1hNV = (GLEEPFNGLMULTITEXCOORD1HNVPROC) __GLeeGetProcAddress("glMultiTexCoord1hNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord1hvNV = (GLEEPFNGLMULTITEXCOORD1HVNVPROC) __GLeeGetProcAddress("glMultiTexCoord1hvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord2hNV = (GLEEPFNGLMULTITEXCOORD2HNVPROC) __GLeeGetProcAddress("glMultiTexCoord2hNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord2hvNV = (GLEEPFNGLMULTITEXCOORD2HVNVPROC) __GLeeGetProcAddress("glMultiTexCoord2hvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord3hNV = (GLEEPFNGLMULTITEXCOORD3HNVPROC) __GLeeGetProcAddress("glMultiTexCoord3hNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord3hvNV = (GLEEPFNGLMULTITEXCOORD3HVNVPROC) __GLeeGetProcAddress("glMultiTexCoord3hvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord4hNV = (GLEEPFNGLMULTITEXCOORD4HNVPROC) __GLeeGetProcAddress("glMultiTexCoord4hNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoord4hvNV = (GLEEPFNGLMULTITEXCOORD4HVNVPROC) __GLeeGetProcAddress("glMultiTexCoord4hvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glFogCoordhNV = (GLEEPFNGLFOGCOORDHNVPROC) __GLeeGetProcAddress("glFogCoordhNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glFogCoordhvNV = (GLEEPFNGLFOGCOORDHVNVPROC) __GLeeGetProcAddress("glFogCoordhvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3hNV = (GLEEPFNGLSECONDARYCOLOR3HNVPROC) __GLeeGetProcAddress("glSecondaryColor3hNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glSecondaryColor3hvNV = (GLEEPFNGLSECONDARYCOLOR3HVNVPROC) __GLeeGetProcAddress("glSecondaryColor3hvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexWeighthNV = (GLEEPFNGLVERTEXWEIGHTHNVPROC) __GLeeGetProcAddress("glVertexWeighthNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexWeighthvNV = (GLEEPFNGLVERTEXWEIGHTHVNVPROC) __GLeeGetProcAddress("glVertexWeighthvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib1hNV = (GLEEPFNGLVERTEXATTRIB1HNVPROC) __GLeeGetProcAddress("glVertexAttrib1hNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib1hvNV = (GLEEPFNGLVERTEXATTRIB1HVNVPROC) __GLeeGetProcAddress("glVertexAttrib1hvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib2hNV = (GLEEPFNGLVERTEXATTRIB2HNVPROC) __GLeeGetProcAddress("glVertexAttrib2hNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib2hvNV = (GLEEPFNGLVERTEXATTRIB2HVNVPROC) __GLeeGetProcAddress("glVertexAttrib2hvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib3hNV = (GLEEPFNGLVERTEXATTRIB3HNVPROC) __GLeeGetProcAddress("glVertexAttrib3hNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib3hvNV = (GLEEPFNGLVERTEXATTRIB3HVNVPROC) __GLeeGetProcAddress("glVertexAttrib3hvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4hNV = (GLEEPFNGLVERTEXATTRIB4HNVPROC) __GLeeGetProcAddress("glVertexAttrib4hNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttrib4hvNV = (GLEEPFNGLVERTEXATTRIB4HVNVPROC) __GLeeGetProcAddress("glVertexAttrib4hvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribs1hvNV = (GLEEPFNGLVERTEXATTRIBS1HVNVPROC) __GLeeGetProcAddress("glVertexAttribs1hvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribs2hvNV = (GLEEPFNGLVERTEXATTRIBS2HVNVPROC) __GLeeGetProcAddress("glVertexAttribs2hvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribs3hvNV = (GLEEPFNGLVERTEXATTRIBS3HVNVPROC) __GLeeGetProcAddress("glVertexAttribs3hvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribs4hvNV = (GLEEPFNGLVERTEXATTRIBS4HVNVPROC) __GLeeGetProcAddress("glVertexAttribs4hvNV"))!=0) nLinked++;
#endif
if (nLinked==46) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_NV_pixel_data_range(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_NV_pixel_data_range
if ((GLeeFuncPtr_glPixelDataRangeNV = (GLEEPFNGLPIXELDATARANGENVPROC) __GLeeGetProcAddress("glPixelDataRangeNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glFlushPixelDataRangeNV = (GLEEPFNGLFLUSHPIXELDATARANGENVPROC) __GLeeGetProcAddress("glFlushPixelDataRangeNV"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_NV_primitive_restart(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_NV_primitive_restart
if ((GLeeFuncPtr_glPrimitiveRestartNV = (GLEEPFNGLPRIMITIVERESTARTNVPROC) __GLeeGetProcAddress("glPrimitiveRestartNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glPrimitiveRestartIndexNV = (GLEEPFNGLPRIMITIVERESTARTINDEXNVPROC) __GLeeGetProcAddress("glPrimitiveRestartIndexNV"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_NV_texture_expand_normal(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_vertex_program2(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_ATI_map_object_buffer(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ATI_map_object_buffer
if ((GLeeFuncPtr_glMapObjectBufferATI = (GLEEPFNGLMAPOBJECTBUFFERATIPROC) __GLeeGetProcAddress("glMapObjectBufferATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glUnmapObjectBufferATI = (GLEEPFNGLUNMAPOBJECTBUFFERATIPROC) __GLeeGetProcAddress("glUnmapObjectBufferATI"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ATI_separate_stencil(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ATI_separate_stencil
if ((GLeeFuncPtr_glStencilOpSeparateATI = (GLEEPFNGLSTENCILOPSEPARATEATIPROC) __GLeeGetProcAddress("glStencilOpSeparateATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glStencilFuncSeparateATI = (GLEEPFNGLSTENCILFUNCSEPARATEATIPROC) __GLeeGetProcAddress("glStencilFuncSeparateATI"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_ATI_vertex_attrib_array_object(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_ATI_vertex_attrib_array_object
if ((GLeeFuncPtr_glVertexAttribArrayObjectATI = (GLEEPFNGLVERTEXATTRIBARRAYOBJECTATIPROC) __GLeeGetProcAddress("glVertexAttribArrayObjectATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetVertexAttribArrayObjectfvATI = (GLEEPFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC) __GLeeGetProcAddress("glGetVertexAttribArrayObjectfvATI"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetVertexAttribArrayObjectivATI = (GLEEPFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC) __GLeeGetProcAddress("glGetVertexAttribArrayObjectivATI"))!=0) nLinked++;
#endif
if (nLinked==3) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_OES_read_format(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_depth_bounds_test(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_depth_bounds_test
if ((GLeeFuncPtr_glDepthBoundsEXT = (GLEEPFNGLDEPTHBOUNDSEXTPROC) __GLeeGetProcAddress("glDepthBoundsEXT"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_texture_mirror_clamp(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_blend_equation_separate(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_blend_equation_separate
if ((GLeeFuncPtr_glBlendEquationSeparateEXT = (GLEEPFNGLBLENDEQUATIONSEPARATEEXTPROC) __GLeeGetProcAddress("glBlendEquationSeparateEXT"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_MESA_pack_invert(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_MESA_ycbcr_texture(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_pixel_buffer_object(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_fragment_program_option(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_fragment_program2(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_vertex_program2_option(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_vertex_program3(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_framebuffer_object(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_framebuffer_object
if ((GLeeFuncPtr_glIsRenderbufferEXT = (GLEEPFNGLISRENDERBUFFEREXTPROC) __GLeeGetProcAddress("glIsRenderbufferEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glBindRenderbufferEXT = (GLEEPFNGLBINDRENDERBUFFEREXTPROC) __GLeeGetProcAddress("glBindRenderbufferEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glDeleteRenderbuffersEXT = (GLEEPFNGLDELETERENDERBUFFERSEXTPROC) __GLeeGetProcAddress("glDeleteRenderbuffersEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGenRenderbuffersEXT = (GLEEPFNGLGENRENDERBUFFERSEXTPROC) __GLeeGetProcAddress("glGenRenderbuffersEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glRenderbufferStorageEXT = (GLEEPFNGLRENDERBUFFERSTORAGEEXTPROC) __GLeeGetProcAddress("glRenderbufferStorageEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetRenderbufferParameterivEXT = (GLEEPFNGLGETRENDERBUFFERPARAMETERIVEXTPROC) __GLeeGetProcAddress("glGetRenderbufferParameterivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glIsFramebufferEXT = (GLEEPFNGLISFRAMEBUFFEREXTPROC) __GLeeGetProcAddress("glIsFramebufferEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glBindFramebufferEXT = (GLEEPFNGLBINDFRAMEBUFFEREXTPROC) __GLeeGetProcAddress("glBindFramebufferEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glDeleteFramebuffersEXT = (GLEEPFNGLDELETEFRAMEBUFFERSEXTPROC) __GLeeGetProcAddress("glDeleteFramebuffersEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGenFramebuffersEXT = (GLEEPFNGLGENFRAMEBUFFERSEXTPROC) __GLeeGetProcAddress("glGenFramebuffersEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCheckFramebufferStatusEXT = (GLEEPFNGLCHECKFRAMEBUFFERSTATUSEXTPROC) __GLeeGetProcAddress("glCheckFramebufferStatusEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFramebufferTexture1DEXT = (GLEEPFNGLFRAMEBUFFERTEXTURE1DEXTPROC) __GLeeGetProcAddress("glFramebufferTexture1DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFramebufferTexture2DEXT = (GLEEPFNGLFRAMEBUFFERTEXTURE2DEXTPROC) __GLeeGetProcAddress("glFramebufferTexture2DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFramebufferTexture3DEXT = (GLEEPFNGLFRAMEBUFFERTEXTURE3DEXTPROC) __GLeeGetProcAddress("glFramebufferTexture3DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFramebufferRenderbufferEXT = (GLEEPFNGLFRAMEBUFFERRENDERBUFFEREXTPROC) __GLeeGetProcAddress("glFramebufferRenderbufferEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetFramebufferAttachmentParameterivEXT = (GLEEPFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC) __GLeeGetProcAddress("glGetFramebufferAttachmentParameterivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGenerateMipmapEXT = (GLEEPFNGLGENERATEMIPMAPEXTPROC) __GLeeGetProcAddress("glGenerateMipmapEXT"))!=0) nLinked++;
#endif
if (nLinked==17) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_GREMEDY_string_marker(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_GREMEDY_string_marker
if ((GLeeFuncPtr_glStringMarkerGREMEDY = (GLEEPFNGLSTRINGMARKERGREMEDYPROC) __GLeeGetProcAddress("glStringMarkerGREMEDY"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_packed_depth_stencil(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_stencil_clear_tag(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_stencil_clear_tag
if ((GLeeFuncPtr_glStencilClearTagEXT = (GLEEPFNGLSTENCILCLEARTAGEXTPROC) __GLeeGetProcAddress("glStencilClearTagEXT"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_texture_sRGB(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_framebuffer_blit(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_framebuffer_blit
if ((GLeeFuncPtr_glBlitFramebufferEXT = (GLEEPFNGLBLITFRAMEBUFFEREXTPROC) __GLeeGetProcAddress("glBlitFramebufferEXT"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_framebuffer_multisample(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_framebuffer_multisample
if ((GLeeFuncPtr_glRenderbufferStorageMultisampleEXT = (GLEEPFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC) __GLeeGetProcAddress("glRenderbufferStorageMultisampleEXT"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_MESAX_texture_stack(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_timer_query(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_timer_query
if ((GLeeFuncPtr_glGetQueryObjecti64vEXT = (GLEEPFNGLGETQUERYOBJECTI64VEXTPROC) __GLeeGetProcAddress("glGetQueryObjecti64vEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetQueryObjectui64vEXT = (GLEEPFNGLGETQUERYOBJECTUI64VEXTPROC) __GLeeGetProcAddress("glGetQueryObjectui64vEXT"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_gpu_program_parameters(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_gpu_program_parameters
if ((GLeeFuncPtr_glProgramEnvParameters4fvEXT = (GLEEPFNGLPROGRAMENVPARAMETERS4FVEXTPROC) __GLeeGetProcAddress("glProgramEnvParameters4fvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramLocalParameters4fvEXT = (GLEEPFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC) __GLeeGetProcAddress("glProgramLocalParameters4fvEXT"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_APPLE_flush_buffer_range(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_APPLE_flush_buffer_range
if ((GLeeFuncPtr_glBufferParameteriAPPLE = (GLEEPFNGLBUFFERPARAMETERIAPPLEPROC) __GLeeGetProcAddress("glBufferParameteriAPPLE"))!=0) nLinked++;
if ((GLeeFuncPtr_glFlushMappedBufferRangeAPPLE = (GLEEPFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC) __GLeeGetProcAddress("glFlushMappedBufferRangeAPPLE"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_gpu_shader4(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_gpu_shader4
if ((GLeeFuncPtr_glGetUniformuivEXT = (GLEEPFNGLGETUNIFORMUIVEXTPROC) __GLeeGetProcAddress("glGetUniformuivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glBindFragDataLocationEXT = (GLEEPFNGLBINDFRAGDATALOCATIONEXTPROC) __GLeeGetProcAddress("glBindFragDataLocationEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetFragDataLocationEXT = (GLEEPFNGLGETFRAGDATALOCATIONEXTPROC) __GLeeGetProcAddress("glGetFragDataLocationEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform1uiEXT = (GLEEPFNGLUNIFORM1UIEXTPROC) __GLeeGetProcAddress("glUniform1uiEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform2uiEXT = (GLEEPFNGLUNIFORM2UIEXTPROC) __GLeeGetProcAddress("glUniform2uiEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform3uiEXT = (GLEEPFNGLUNIFORM3UIEXTPROC) __GLeeGetProcAddress("glUniform3uiEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform4uiEXT = (GLEEPFNGLUNIFORM4UIEXTPROC) __GLeeGetProcAddress("glUniform4uiEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform1uivEXT = (GLEEPFNGLUNIFORM1UIVEXTPROC) __GLeeGetProcAddress("glUniform1uivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform2uivEXT = (GLEEPFNGLUNIFORM2UIVEXTPROC) __GLeeGetProcAddress("glUniform2uivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform3uivEXT = (GLEEPFNGLUNIFORM3UIVEXTPROC) __GLeeGetProcAddress("glUniform3uivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glUniform4uivEXT = (GLEEPFNGLUNIFORM4UIVEXTPROC) __GLeeGetProcAddress("glUniform4uivEXT"))!=0) nLinked++;
#endif
if (nLinked==11) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_draw_instanced(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_draw_instanced
if ((GLeeFuncPtr_glDrawArraysInstancedEXT = (GLEEPFNGLDRAWARRAYSINSTANCEDEXTPROC) __GLeeGetProcAddress("glDrawArraysInstancedEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glDrawElementsInstancedEXT = (GLEEPFNGLDRAWELEMENTSINSTANCEDEXTPROC) __GLeeGetProcAddress("glDrawElementsInstancedEXT"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_packed_float(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_texture_array(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_texture_buffer_object(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_texture_buffer_object
if ((GLeeFuncPtr_glTexBufferEXT = (GLEEPFNGLTEXBUFFEREXTPROC) __GLeeGetProcAddress("glTexBufferEXT"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_texture_compression_latc(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_texture_compression_rgtc(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_texture_shared_exponent(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_depth_buffer_float(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_NV_depth_buffer_float
if ((GLeeFuncPtr_glDepthRangedNV = (GLEEPFNGLDEPTHRANGEDNVPROC) __GLeeGetProcAddress("glDepthRangedNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glClearDepthdNV = (GLEEPFNGLCLEARDEPTHDNVPROC) __GLeeGetProcAddress("glClearDepthdNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glDepthBoundsdNV = (GLEEPFNGLDEPTHBOUNDSDNVPROC) __GLeeGetProcAddress("glDepthBoundsdNV"))!=0) nLinked++;
#endif
if (nLinked==3) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_NV_framebuffer_multisample_coverage(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_NV_framebuffer_multisample_coverage
if ((GLeeFuncPtr_glRenderbufferStorageMultisampleCoverageNV = (GLEEPFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC) __GLeeGetProcAddress("glRenderbufferStorageMultisampleCoverageNV"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_framebuffer_sRGB(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_geometry_shader4(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_parameter_buffer_object(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_NV_parameter_buffer_object
if ((GLeeFuncPtr_glProgramBufferParametersfvNV = (GLEEPFNGLPROGRAMBUFFERPARAMETERSFVNVPROC) __GLeeGetProcAddress("glProgramBufferParametersfvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramBufferParametersIivNV = (GLEEPFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC) __GLeeGetProcAddress("glProgramBufferParametersIivNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramBufferParametersIuivNV = (GLEEPFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC) __GLeeGetProcAddress("glProgramBufferParametersIuivNV"))!=0) nLinked++;
#endif
if (nLinked==3) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_draw_buffers2(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_draw_buffers2
if ((GLeeFuncPtr_glColorMaskIndexedEXT = (GLEEPFNGLCOLORMASKINDEXEDEXTPROC) __GLeeGetProcAddress("glColorMaskIndexedEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetBooleanIndexedvEXT = (GLEEPFNGLGETBOOLEANINDEXEDVEXTPROC) __GLeeGetProcAddress("glGetBooleanIndexedvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetIntegerIndexedvEXT = (GLEEPFNGLGETINTEGERINDEXEDVEXTPROC) __GLeeGetProcAddress("glGetIntegerIndexedvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glEnableIndexedEXT = (GLEEPFNGLENABLEINDEXEDEXTPROC) __GLeeGetProcAddress("glEnableIndexedEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glDisableIndexedEXT = (GLEEPFNGLDISABLEINDEXEDEXTPROC) __GLeeGetProcAddress("glDisableIndexedEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glIsEnabledIndexedEXT = (GLEEPFNGLISENABLEDINDEXEDEXTPROC) __GLeeGetProcAddress("glIsEnabledIndexedEXT"))!=0) nLinked++;
#endif
if (nLinked==6) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_NV_transform_feedback(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_NV_transform_feedback
if ((GLeeFuncPtr_glBeginTransformFeedbackNV = (GLEEPFNGLBEGINTRANSFORMFEEDBACKNVPROC) __GLeeGetProcAddress("glBeginTransformFeedbackNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glEndTransformFeedbackNV = (GLEEPFNGLENDTRANSFORMFEEDBACKNVPROC) __GLeeGetProcAddress("glEndTransformFeedbackNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glTransformFeedbackAttribsNV = (GLEEPFNGLTRANSFORMFEEDBACKATTRIBSNVPROC) __GLeeGetProcAddress("glTransformFeedbackAttribsNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glBindBufferRangeNV = (GLEEPFNGLBINDBUFFERRANGENVPROC) __GLeeGetProcAddress("glBindBufferRangeNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glBindBufferOffsetNV = (GLEEPFNGLBINDBUFFEROFFSETNVPROC) __GLeeGetProcAddress("glBindBufferOffsetNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glBindBufferBaseNV = (GLEEPFNGLBINDBUFFERBASENVPROC) __GLeeGetProcAddress("glBindBufferBaseNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glTransformFeedbackVaryingsNV = (GLEEPFNGLTRANSFORMFEEDBACKVARYINGSNVPROC) __GLeeGetProcAddress("glTransformFeedbackVaryingsNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glActiveVaryingNV = (GLEEPFNGLACTIVEVARYINGNVPROC) __GLeeGetProcAddress("glActiveVaryingNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetVaryingLocationNV = (GLEEPFNGLGETVARYINGLOCATIONNVPROC) __GLeeGetProcAddress("glGetVaryingLocationNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetActiveVaryingNV = (GLEEPFNGLGETACTIVEVARYINGNVPROC) __GLeeGetProcAddress("glGetActiveVaryingNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetTransformFeedbackVaryingNV = (GLEEPFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC) __GLeeGetProcAddress("glGetTransformFeedbackVaryingNV"))!=0) nLinked++;
#endif
if (nLinked==11) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_bindable_uniform(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_bindable_uniform
if ((GLeeFuncPtr_glUniformBufferEXT = (GLEEPFNGLUNIFORMBUFFEREXTPROC) __GLeeGetProcAddress("glUniformBufferEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetUniformBufferSizeEXT = (GLEEPFNGLGETUNIFORMBUFFERSIZEEXTPROC) __GLeeGetProcAddress("glGetUniformBufferSizeEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetUniformOffsetEXT = (GLEEPFNGLGETUNIFORMOFFSETEXTPROC) __GLeeGetProcAddress("glGetUniformOffsetEXT"))!=0) nLinked++;
#endif
if (nLinked==3) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_texture_integer(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_texture_integer
if ((GLeeFuncPtr_glTexParameterIivEXT = (GLEEPFNGLTEXPARAMETERIIVEXTPROC) __GLeeGetProcAddress("glTexParameterIivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexParameterIuivEXT = (GLEEPFNGLTEXPARAMETERIUIVEXTPROC) __GLeeGetProcAddress("glTexParameterIuivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetTexParameterIivEXT = (GLEEPFNGLGETTEXPARAMETERIIVEXTPROC) __GLeeGetProcAddress("glGetTexParameterIivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetTexParameterIuivEXT = (GLEEPFNGLGETTEXPARAMETERIUIVEXTPROC) __GLeeGetProcAddress("glGetTexParameterIuivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glClearColorIiEXT = (GLEEPFNGLCLEARCOLORIIEXTPROC) __GLeeGetProcAddress("glClearColorIiEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glClearColorIuiEXT = (GLEEPFNGLCLEARCOLORIUIEXTPROC) __GLeeGetProcAddress("glClearColorIuiEXT"))!=0) nLinked++;
#endif
if (nLinked==6) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_GREMEDY_frame_terminator(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_GREMEDY_frame_terminator
if ((GLeeFuncPtr_glFrameTerminatorGREMEDY = (GLEEPFNGLFRAMETERMINATORGREMEDYPROC) __GLeeGetProcAddress("glFrameTerminatorGREMEDY"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_NV_conditional_render(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_NV_conditional_render
if ((GLeeFuncPtr_glBeginConditionalRenderNV = (GLEEPFNGLBEGINCONDITIONALRENDERNVPROC) __GLeeGetProcAddress("glBeginConditionalRenderNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glEndConditionalRenderNV = (GLEEPFNGLENDCONDITIONALRENDERNVPROC) __GLeeGetProcAddress("glEndConditionalRenderNV"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_NV_present_video(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_transform_feedback(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_transform_feedback
if ((GLeeFuncPtr_glBeginTransformFeedbackEXT = (GLEEPFNGLBEGINTRANSFORMFEEDBACKEXTPROC) __GLeeGetProcAddress("glBeginTransformFeedbackEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glEndTransformFeedbackEXT = (GLEEPFNGLENDTRANSFORMFEEDBACKEXTPROC) __GLeeGetProcAddress("glEndTransformFeedbackEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glBindBufferRangeEXT = (GLEEPFNGLBINDBUFFERRANGEEXTPROC) __GLeeGetProcAddress("glBindBufferRangeEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glBindBufferOffsetEXT = (GLEEPFNGLBINDBUFFEROFFSETEXTPROC) __GLeeGetProcAddress("glBindBufferOffsetEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glBindBufferBaseEXT = (GLEEPFNGLBINDBUFFERBASEEXTPROC) __GLeeGetProcAddress("glBindBufferBaseEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTransformFeedbackVaryingsEXT = (GLEEPFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC) __GLeeGetProcAddress("glTransformFeedbackVaryingsEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetTransformFeedbackVaryingEXT = (GLEEPFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC) __GLeeGetProcAddress("glGetTransformFeedbackVaryingEXT"))!=0) nLinked++;
#endif
if (nLinked==7) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_direct_state_access(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_direct_state_access
if ((GLeeFuncPtr_glClientAttribDefaultEXT = (GLEEPFNGLCLIENTATTRIBDEFAULTEXTPROC) __GLeeGetProcAddress("glClientAttribDefaultEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glPushClientAttribDefaultEXT = (GLEEPFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC) __GLeeGetProcAddress("glPushClientAttribDefaultEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMatrixLoadfEXT = (GLEEPFNGLMATRIXLOADFEXTPROC) __GLeeGetProcAddress("glMatrixLoadfEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMatrixLoaddEXT = (GLEEPFNGLMATRIXLOADDEXTPROC) __GLeeGetProcAddress("glMatrixLoaddEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMatrixMultfEXT = (GLEEPFNGLMATRIXMULTFEXTPROC) __GLeeGetProcAddress("glMatrixMultfEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMatrixMultdEXT = (GLEEPFNGLMATRIXMULTDEXTPROC) __GLeeGetProcAddress("glMatrixMultdEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMatrixLoadIdentityEXT = (GLEEPFNGLMATRIXLOADIDENTITYEXTPROC) __GLeeGetProcAddress("glMatrixLoadIdentityEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMatrixRotatefEXT = (GLEEPFNGLMATRIXROTATEFEXTPROC) __GLeeGetProcAddress("glMatrixRotatefEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMatrixRotatedEXT = (GLEEPFNGLMATRIXROTATEDEXTPROC) __GLeeGetProcAddress("glMatrixRotatedEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMatrixScalefEXT = (GLEEPFNGLMATRIXSCALEFEXTPROC) __GLeeGetProcAddress("glMatrixScalefEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMatrixScaledEXT = (GLEEPFNGLMATRIXSCALEDEXTPROC) __GLeeGetProcAddress("glMatrixScaledEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMatrixTranslatefEXT = (GLEEPFNGLMATRIXTRANSLATEFEXTPROC) __GLeeGetProcAddress("glMatrixTranslatefEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMatrixTranslatedEXT = (GLEEPFNGLMATRIXTRANSLATEDEXTPROC) __GLeeGetProcAddress("glMatrixTranslatedEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMatrixFrustumEXT = (GLEEPFNGLMATRIXFRUSTUMEXTPROC) __GLeeGetProcAddress("glMatrixFrustumEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMatrixOrthoEXT = (GLEEPFNGLMATRIXORTHOEXTPROC) __GLeeGetProcAddress("glMatrixOrthoEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMatrixPopEXT = (GLEEPFNGLMATRIXPOPEXTPROC) __GLeeGetProcAddress("glMatrixPopEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMatrixPushEXT = (GLEEPFNGLMATRIXPUSHEXTPROC) __GLeeGetProcAddress("glMatrixPushEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMatrixLoadTransposefEXT = (GLEEPFNGLMATRIXLOADTRANSPOSEFEXTPROC) __GLeeGetProcAddress("glMatrixLoadTransposefEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMatrixLoadTransposedEXT = (GLEEPFNGLMATRIXLOADTRANSPOSEDEXTPROC) __GLeeGetProcAddress("glMatrixLoadTransposedEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMatrixMultTransposefEXT = (GLEEPFNGLMATRIXMULTTRANSPOSEFEXTPROC) __GLeeGetProcAddress("glMatrixMultTransposefEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMatrixMultTransposedEXT = (GLEEPFNGLMATRIXMULTTRANSPOSEDEXTPROC) __GLeeGetProcAddress("glMatrixMultTransposedEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTextureParameterfEXT = (GLEEPFNGLTEXTUREPARAMETERFEXTPROC) __GLeeGetProcAddress("glTextureParameterfEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTextureParameterfvEXT = (GLEEPFNGLTEXTUREPARAMETERFVEXTPROC) __GLeeGetProcAddress("glTextureParameterfvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTextureParameteriEXT = (GLEEPFNGLTEXTUREPARAMETERIEXTPROC) __GLeeGetProcAddress("glTextureParameteriEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTextureParameterivEXT = (GLEEPFNGLTEXTUREPARAMETERIVEXTPROC) __GLeeGetProcAddress("glTextureParameterivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTextureImage1DEXT = (GLEEPFNGLTEXTUREIMAGE1DEXTPROC) __GLeeGetProcAddress("glTextureImage1DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTextureImage2DEXT = (GLEEPFNGLTEXTUREIMAGE2DEXTPROC) __GLeeGetProcAddress("glTextureImage2DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTextureSubImage1DEXT = (GLEEPFNGLTEXTURESUBIMAGE1DEXTPROC) __GLeeGetProcAddress("glTextureSubImage1DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTextureSubImage2DEXT = (GLEEPFNGLTEXTURESUBIMAGE2DEXTPROC) __GLeeGetProcAddress("glTextureSubImage2DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCopyTextureImage1DEXT = (GLEEPFNGLCOPYTEXTUREIMAGE1DEXTPROC) __GLeeGetProcAddress("glCopyTextureImage1DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCopyTextureImage2DEXT = (GLEEPFNGLCOPYTEXTUREIMAGE2DEXTPROC) __GLeeGetProcAddress("glCopyTextureImage2DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCopyTextureSubImage1DEXT = (GLEEPFNGLCOPYTEXTURESUBIMAGE1DEXTPROC) __GLeeGetProcAddress("glCopyTextureSubImage1DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCopyTextureSubImage2DEXT = (GLEEPFNGLCOPYTEXTURESUBIMAGE2DEXTPROC) __GLeeGetProcAddress("glCopyTextureSubImage2DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetTextureImageEXT = (GLEEPFNGLGETTEXTUREIMAGEEXTPROC) __GLeeGetProcAddress("glGetTextureImageEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetTextureParameterfvEXT = (GLEEPFNGLGETTEXTUREPARAMETERFVEXTPROC) __GLeeGetProcAddress("glGetTextureParameterfvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetTextureParameterivEXT = (GLEEPFNGLGETTEXTUREPARAMETERIVEXTPROC) __GLeeGetProcAddress("glGetTextureParameterivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetTextureLevelParameterfvEXT = (GLEEPFNGLGETTEXTURELEVELPARAMETERFVEXTPROC) __GLeeGetProcAddress("glGetTextureLevelParameterfvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetTextureLevelParameterivEXT = (GLEEPFNGLGETTEXTURELEVELPARAMETERIVEXTPROC) __GLeeGetProcAddress("glGetTextureLevelParameterivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTextureImage3DEXT = (GLEEPFNGLTEXTUREIMAGE3DEXTPROC) __GLeeGetProcAddress("glTextureImage3DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTextureSubImage3DEXT = (GLEEPFNGLTEXTURESUBIMAGE3DEXTPROC) __GLeeGetProcAddress("glTextureSubImage3DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCopyTextureSubImage3DEXT = (GLEEPFNGLCOPYTEXTURESUBIMAGE3DEXTPROC) __GLeeGetProcAddress("glCopyTextureSubImage3DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexParameterfEXT = (GLEEPFNGLMULTITEXPARAMETERFEXTPROC) __GLeeGetProcAddress("glMultiTexParameterfEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexParameterfvEXT = (GLEEPFNGLMULTITEXPARAMETERFVEXTPROC) __GLeeGetProcAddress("glMultiTexParameterfvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexParameteriEXT = (GLEEPFNGLMULTITEXPARAMETERIEXTPROC) __GLeeGetProcAddress("glMultiTexParameteriEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexParameterivEXT = (GLEEPFNGLMULTITEXPARAMETERIVEXTPROC) __GLeeGetProcAddress("glMultiTexParameterivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexImage1DEXT = (GLEEPFNGLMULTITEXIMAGE1DEXTPROC) __GLeeGetProcAddress("glMultiTexImage1DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexImage2DEXT = (GLEEPFNGLMULTITEXIMAGE2DEXTPROC) __GLeeGetProcAddress("glMultiTexImage2DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexSubImage1DEXT = (GLEEPFNGLMULTITEXSUBIMAGE1DEXTPROC) __GLeeGetProcAddress("glMultiTexSubImage1DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexSubImage2DEXT = (GLEEPFNGLMULTITEXSUBIMAGE2DEXTPROC) __GLeeGetProcAddress("glMultiTexSubImage2DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCopyMultiTexImage1DEXT = (GLEEPFNGLCOPYMULTITEXIMAGE1DEXTPROC) __GLeeGetProcAddress("glCopyMultiTexImage1DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCopyMultiTexImage2DEXT = (GLEEPFNGLCOPYMULTITEXIMAGE2DEXTPROC) __GLeeGetProcAddress("glCopyMultiTexImage2DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCopyMultiTexSubImage1DEXT = (GLEEPFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC) __GLeeGetProcAddress("glCopyMultiTexSubImage1DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCopyMultiTexSubImage2DEXT = (GLEEPFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC) __GLeeGetProcAddress("glCopyMultiTexSubImage2DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetMultiTexImageEXT = (GLEEPFNGLGETMULTITEXIMAGEEXTPROC) __GLeeGetProcAddress("glGetMultiTexImageEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetMultiTexParameterfvEXT = (GLEEPFNGLGETMULTITEXPARAMETERFVEXTPROC) __GLeeGetProcAddress("glGetMultiTexParameterfvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetMultiTexParameterivEXT = (GLEEPFNGLGETMULTITEXPARAMETERIVEXTPROC) __GLeeGetProcAddress("glGetMultiTexParameterivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetMultiTexLevelParameterfvEXT = (GLEEPFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC) __GLeeGetProcAddress("glGetMultiTexLevelParameterfvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetMultiTexLevelParameterivEXT = (GLEEPFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC) __GLeeGetProcAddress("glGetMultiTexLevelParameterivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexImage3DEXT = (GLEEPFNGLMULTITEXIMAGE3DEXTPROC) __GLeeGetProcAddress("glMultiTexImage3DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexSubImage3DEXT = (GLEEPFNGLMULTITEXSUBIMAGE3DEXTPROC) __GLeeGetProcAddress("glMultiTexSubImage3DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCopyMultiTexSubImage3DEXT = (GLEEPFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC) __GLeeGetProcAddress("glCopyMultiTexSubImage3DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glBindMultiTextureEXT = (GLEEPFNGLBINDMULTITEXTUREEXTPROC) __GLeeGetProcAddress("glBindMultiTextureEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glEnableClientStateIndexedEXT = (GLEEPFNGLENABLECLIENTSTATEINDEXEDEXTPROC) __GLeeGetProcAddress("glEnableClientStateIndexedEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glDisableClientStateIndexedEXT = (GLEEPFNGLDISABLECLIENTSTATEINDEXEDEXTPROC) __GLeeGetProcAddress("glDisableClientStateIndexedEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexCoordPointerEXT = (GLEEPFNGLMULTITEXCOORDPOINTEREXTPROC) __GLeeGetProcAddress("glMultiTexCoordPointerEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexEnvfEXT = (GLEEPFNGLMULTITEXENVFEXTPROC) __GLeeGetProcAddress("glMultiTexEnvfEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexEnvfvEXT = (GLEEPFNGLMULTITEXENVFVEXTPROC) __GLeeGetProcAddress("glMultiTexEnvfvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexEnviEXT = (GLEEPFNGLMULTITEXENVIEXTPROC) __GLeeGetProcAddress("glMultiTexEnviEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexEnvivEXT = (GLEEPFNGLMULTITEXENVIVEXTPROC) __GLeeGetProcAddress("glMultiTexEnvivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexGendEXT = (GLEEPFNGLMULTITEXGENDEXTPROC) __GLeeGetProcAddress("glMultiTexGendEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexGendvEXT = (GLEEPFNGLMULTITEXGENDVEXTPROC) __GLeeGetProcAddress("glMultiTexGendvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexGenfEXT = (GLEEPFNGLMULTITEXGENFEXTPROC) __GLeeGetProcAddress("glMultiTexGenfEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexGenfvEXT = (GLEEPFNGLMULTITEXGENFVEXTPROC) __GLeeGetProcAddress("glMultiTexGenfvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexGeniEXT = (GLEEPFNGLMULTITEXGENIEXTPROC) __GLeeGetProcAddress("glMultiTexGeniEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexGenivEXT = (GLEEPFNGLMULTITEXGENIVEXTPROC) __GLeeGetProcAddress("glMultiTexGenivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetMultiTexEnvfvEXT = (GLEEPFNGLGETMULTITEXENVFVEXTPROC) __GLeeGetProcAddress("glGetMultiTexEnvfvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetMultiTexEnvivEXT = (GLEEPFNGLGETMULTITEXENVIVEXTPROC) __GLeeGetProcAddress("glGetMultiTexEnvivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetMultiTexGendvEXT = (GLEEPFNGLGETMULTITEXGENDVEXTPROC) __GLeeGetProcAddress("glGetMultiTexGendvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetMultiTexGenfvEXT = (GLEEPFNGLGETMULTITEXGENFVEXTPROC) __GLeeGetProcAddress("glGetMultiTexGenfvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetMultiTexGenivEXT = (GLEEPFNGLGETMULTITEXGENIVEXTPROC) __GLeeGetProcAddress("glGetMultiTexGenivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetFloatIndexedvEXT = (GLEEPFNGLGETFLOATINDEXEDVEXTPROC) __GLeeGetProcAddress("glGetFloatIndexedvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetDoubleIndexedvEXT = (GLEEPFNGLGETDOUBLEINDEXEDVEXTPROC) __GLeeGetProcAddress("glGetDoubleIndexedvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetPointerIndexedvEXT = (GLEEPFNGLGETPOINTERINDEXEDVEXTPROC) __GLeeGetProcAddress("glGetPointerIndexedvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCompressedTextureImage3DEXT = (GLEEPFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC) __GLeeGetProcAddress("glCompressedTextureImage3DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCompressedTextureImage2DEXT = (GLEEPFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC) __GLeeGetProcAddress("glCompressedTextureImage2DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCompressedTextureImage1DEXT = (GLEEPFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC) __GLeeGetProcAddress("glCompressedTextureImage1DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCompressedTextureSubImage3DEXT = (GLEEPFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC) __GLeeGetProcAddress("glCompressedTextureSubImage3DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCompressedTextureSubImage2DEXT = (GLEEPFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC) __GLeeGetProcAddress("glCompressedTextureSubImage2DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCompressedTextureSubImage1DEXT = (GLEEPFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC) __GLeeGetProcAddress("glCompressedTextureSubImage1DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetCompressedTextureImageEXT = (GLEEPFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC) __GLeeGetProcAddress("glGetCompressedTextureImageEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCompressedMultiTexImage3DEXT = (GLEEPFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC) __GLeeGetProcAddress("glCompressedMultiTexImage3DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCompressedMultiTexImage2DEXT = (GLEEPFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC) __GLeeGetProcAddress("glCompressedMultiTexImage2DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCompressedMultiTexImage1DEXT = (GLEEPFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC) __GLeeGetProcAddress("glCompressedMultiTexImage1DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCompressedMultiTexSubImage3DEXT = (GLEEPFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC) __GLeeGetProcAddress("glCompressedMultiTexSubImage3DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCompressedMultiTexSubImage2DEXT = (GLEEPFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC) __GLeeGetProcAddress("glCompressedMultiTexSubImage2DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCompressedMultiTexSubImage1DEXT = (GLEEPFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC) __GLeeGetProcAddress("glCompressedMultiTexSubImage1DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetCompressedMultiTexImageEXT = (GLEEPFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC) __GLeeGetProcAddress("glGetCompressedMultiTexImageEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glNamedProgramStringEXT = (GLEEPFNGLNAMEDPROGRAMSTRINGEXTPROC) __GLeeGetProcAddress("glNamedProgramStringEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glNamedProgramLocalParameter4dEXT = (GLEEPFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC) __GLeeGetProcAddress("glNamedProgramLocalParameter4dEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glNamedProgramLocalParameter4dvEXT = (GLEEPFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC) __GLeeGetProcAddress("glNamedProgramLocalParameter4dvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glNamedProgramLocalParameter4fEXT = (GLEEPFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC) __GLeeGetProcAddress("glNamedProgramLocalParameter4fEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glNamedProgramLocalParameter4fvEXT = (GLEEPFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC) __GLeeGetProcAddress("glNamedProgramLocalParameter4fvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetNamedProgramLocalParameterdvEXT = (GLEEPFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC) __GLeeGetProcAddress("glGetNamedProgramLocalParameterdvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetNamedProgramLocalParameterfvEXT = (GLEEPFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC) __GLeeGetProcAddress("glGetNamedProgramLocalParameterfvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetNamedProgramivEXT = (GLEEPFNGLGETNAMEDPROGRAMIVEXTPROC) __GLeeGetProcAddress("glGetNamedProgramivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetNamedProgramStringEXT = (GLEEPFNGLGETNAMEDPROGRAMSTRINGEXTPROC) __GLeeGetProcAddress("glGetNamedProgramStringEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glNamedProgramLocalParameters4fvEXT = (GLEEPFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC) __GLeeGetProcAddress("glNamedProgramLocalParameters4fvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glNamedProgramLocalParameterI4iEXT = (GLEEPFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC) __GLeeGetProcAddress("glNamedProgramLocalParameterI4iEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glNamedProgramLocalParameterI4ivEXT = (GLEEPFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC) __GLeeGetProcAddress("glNamedProgramLocalParameterI4ivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glNamedProgramLocalParametersI4ivEXT = (GLEEPFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC) __GLeeGetProcAddress("glNamedProgramLocalParametersI4ivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glNamedProgramLocalParameterI4uiEXT = (GLEEPFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC) __GLeeGetProcAddress("glNamedProgramLocalParameterI4uiEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glNamedProgramLocalParameterI4uivEXT = (GLEEPFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC) __GLeeGetProcAddress("glNamedProgramLocalParameterI4uivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glNamedProgramLocalParametersI4uivEXT = (GLEEPFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC) __GLeeGetProcAddress("glNamedProgramLocalParametersI4uivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetNamedProgramLocalParameterIivEXT = (GLEEPFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC) __GLeeGetProcAddress("glGetNamedProgramLocalParameterIivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetNamedProgramLocalParameterIuivEXT = (GLEEPFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC) __GLeeGetProcAddress("glGetNamedProgramLocalParameterIuivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTextureParameterIivEXT = (GLEEPFNGLTEXTUREPARAMETERIIVEXTPROC) __GLeeGetProcAddress("glTextureParameterIivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTextureParameterIuivEXT = (GLEEPFNGLTEXTUREPARAMETERIUIVEXTPROC) __GLeeGetProcAddress("glTextureParameterIuivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetTextureParameterIivEXT = (GLEEPFNGLGETTEXTUREPARAMETERIIVEXTPROC) __GLeeGetProcAddress("glGetTextureParameterIivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetTextureParameterIuivEXT = (GLEEPFNGLGETTEXTUREPARAMETERIUIVEXTPROC) __GLeeGetProcAddress("glGetTextureParameterIuivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexParameterIivEXT = (GLEEPFNGLMULTITEXPARAMETERIIVEXTPROC) __GLeeGetProcAddress("glMultiTexParameterIivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexParameterIuivEXT = (GLEEPFNGLMULTITEXPARAMETERIUIVEXTPROC) __GLeeGetProcAddress("glMultiTexParameterIuivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetMultiTexParameterIivEXT = (GLEEPFNGLGETMULTITEXPARAMETERIIVEXTPROC) __GLeeGetProcAddress("glGetMultiTexParameterIivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetMultiTexParameterIuivEXT = (GLEEPFNGLGETMULTITEXPARAMETERIUIVEXTPROC) __GLeeGetProcAddress("glGetMultiTexParameterIuivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniform1fEXT = (GLEEPFNGLPROGRAMUNIFORM1FEXTPROC) __GLeeGetProcAddress("glProgramUniform1fEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniform2fEXT = (GLEEPFNGLPROGRAMUNIFORM2FEXTPROC) __GLeeGetProcAddress("glProgramUniform2fEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniform3fEXT = (GLEEPFNGLPROGRAMUNIFORM3FEXTPROC) __GLeeGetProcAddress("glProgramUniform3fEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniform4fEXT = (GLEEPFNGLPROGRAMUNIFORM4FEXTPROC) __GLeeGetProcAddress("glProgramUniform4fEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniform1iEXT = (GLEEPFNGLPROGRAMUNIFORM1IEXTPROC) __GLeeGetProcAddress("glProgramUniform1iEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniform2iEXT = (GLEEPFNGLPROGRAMUNIFORM2IEXTPROC) __GLeeGetProcAddress("glProgramUniform2iEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniform3iEXT = (GLEEPFNGLPROGRAMUNIFORM3IEXTPROC) __GLeeGetProcAddress("glProgramUniform3iEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniform4iEXT = (GLEEPFNGLPROGRAMUNIFORM4IEXTPROC) __GLeeGetProcAddress("glProgramUniform4iEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniform1fvEXT = (GLEEPFNGLPROGRAMUNIFORM1FVEXTPROC) __GLeeGetProcAddress("glProgramUniform1fvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniform2fvEXT = (GLEEPFNGLPROGRAMUNIFORM2FVEXTPROC) __GLeeGetProcAddress("glProgramUniform2fvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniform3fvEXT = (GLEEPFNGLPROGRAMUNIFORM3FVEXTPROC) __GLeeGetProcAddress("glProgramUniform3fvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniform4fvEXT = (GLEEPFNGLPROGRAMUNIFORM4FVEXTPROC) __GLeeGetProcAddress("glProgramUniform4fvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniform1ivEXT = (GLEEPFNGLPROGRAMUNIFORM1IVEXTPROC) __GLeeGetProcAddress("glProgramUniform1ivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniform2ivEXT = (GLEEPFNGLPROGRAMUNIFORM2IVEXTPROC) __GLeeGetProcAddress("glProgramUniform2ivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniform3ivEXT = (GLEEPFNGLPROGRAMUNIFORM3IVEXTPROC) __GLeeGetProcAddress("glProgramUniform3ivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniform4ivEXT = (GLEEPFNGLPROGRAMUNIFORM4IVEXTPROC) __GLeeGetProcAddress("glProgramUniform4ivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniformMatrix2fvEXT = (GLEEPFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC) __GLeeGetProcAddress("glProgramUniformMatrix2fvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniformMatrix3fvEXT = (GLEEPFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC) __GLeeGetProcAddress("glProgramUniformMatrix3fvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniformMatrix4fvEXT = (GLEEPFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC) __GLeeGetProcAddress("glProgramUniformMatrix4fvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniformMatrix2x3fvEXT = (GLEEPFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC) __GLeeGetProcAddress("glProgramUniformMatrix2x3fvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniformMatrix3x2fvEXT = (GLEEPFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC) __GLeeGetProcAddress("glProgramUniformMatrix3x2fvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniformMatrix2x4fvEXT = (GLEEPFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC) __GLeeGetProcAddress("glProgramUniformMatrix2x4fvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniformMatrix4x2fvEXT = (GLEEPFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC) __GLeeGetProcAddress("glProgramUniformMatrix4x2fvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniformMatrix3x4fvEXT = (GLEEPFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC) __GLeeGetProcAddress("glProgramUniformMatrix3x4fvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniformMatrix4x3fvEXT = (GLEEPFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC) __GLeeGetProcAddress("glProgramUniformMatrix4x3fvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniform1uiEXT = (GLEEPFNGLPROGRAMUNIFORM1UIEXTPROC) __GLeeGetProcAddress("glProgramUniform1uiEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniform2uiEXT = (GLEEPFNGLPROGRAMUNIFORM2UIEXTPROC) __GLeeGetProcAddress("glProgramUniform2uiEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniform3uiEXT = (GLEEPFNGLPROGRAMUNIFORM3UIEXTPROC) __GLeeGetProcAddress("glProgramUniform3uiEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniform4uiEXT = (GLEEPFNGLPROGRAMUNIFORM4UIEXTPROC) __GLeeGetProcAddress("glProgramUniform4uiEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniform1uivEXT = (GLEEPFNGLPROGRAMUNIFORM1UIVEXTPROC) __GLeeGetProcAddress("glProgramUniform1uivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniform2uivEXT = (GLEEPFNGLPROGRAMUNIFORM2UIVEXTPROC) __GLeeGetProcAddress("glProgramUniform2uivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniform3uivEXT = (GLEEPFNGLPROGRAMUNIFORM3UIVEXTPROC) __GLeeGetProcAddress("glProgramUniform3uivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramUniform4uivEXT = (GLEEPFNGLPROGRAMUNIFORM4UIVEXTPROC) __GLeeGetProcAddress("glProgramUniform4uivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glNamedBufferDataEXT = (GLEEPFNGLNAMEDBUFFERDATAEXTPROC) __GLeeGetProcAddress("glNamedBufferDataEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glNamedBufferSubDataEXT = (GLEEPFNGLNAMEDBUFFERSUBDATAEXTPROC) __GLeeGetProcAddress("glNamedBufferSubDataEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMapNamedBufferEXT = (GLEEPFNGLMAPNAMEDBUFFEREXTPROC) __GLeeGetProcAddress("glMapNamedBufferEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glUnmapNamedBufferEXT = (GLEEPFNGLUNMAPNAMEDBUFFEREXTPROC) __GLeeGetProcAddress("glUnmapNamedBufferEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetNamedBufferParameterivEXT = (GLEEPFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC) __GLeeGetProcAddress("glGetNamedBufferParameterivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetNamedBufferPointervEXT = (GLEEPFNGLGETNAMEDBUFFERPOINTERVEXTPROC) __GLeeGetProcAddress("glGetNamedBufferPointervEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetNamedBufferSubDataEXT = (GLEEPFNGLGETNAMEDBUFFERSUBDATAEXTPROC) __GLeeGetProcAddress("glGetNamedBufferSubDataEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTextureBufferEXT = (GLEEPFNGLTEXTUREBUFFEREXTPROC) __GLeeGetProcAddress("glTextureBufferEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexBufferEXT = (GLEEPFNGLMULTITEXBUFFEREXTPROC) __GLeeGetProcAddress("glMultiTexBufferEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glNamedRenderbufferStorageEXT = (GLEEPFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC) __GLeeGetProcAddress("glNamedRenderbufferStorageEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetNamedRenderbufferParameterivEXT = (GLEEPFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC) __GLeeGetProcAddress("glGetNamedRenderbufferParameterivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glCheckNamedFramebufferStatusEXT = (GLEEPFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC) __GLeeGetProcAddress("glCheckNamedFramebufferStatusEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glNamedFramebufferTexture1DEXT = (GLEEPFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC) __GLeeGetProcAddress("glNamedFramebufferTexture1DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glNamedFramebufferTexture2DEXT = (GLEEPFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC) __GLeeGetProcAddress("glNamedFramebufferTexture2DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glNamedFramebufferTexture3DEXT = (GLEEPFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC) __GLeeGetProcAddress("glNamedFramebufferTexture3DEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glNamedFramebufferRenderbufferEXT = (GLEEPFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC) __GLeeGetProcAddress("glNamedFramebufferRenderbufferEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetNamedFramebufferAttachmentParameterivEXT = (GLEEPFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC) __GLeeGetProcAddress("glGetNamedFramebufferAttachmentParameterivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGenerateTextureMipmapEXT = (GLEEPFNGLGENERATETEXTUREMIPMAPEXTPROC) __GLeeGetProcAddress("glGenerateTextureMipmapEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGenerateMultiTexMipmapEXT = (GLEEPFNGLGENERATEMULTITEXMIPMAPEXTPROC) __GLeeGetProcAddress("glGenerateMultiTexMipmapEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFramebufferDrawBufferEXT = (GLEEPFNGLFRAMEBUFFERDRAWBUFFEREXTPROC) __GLeeGetProcAddress("glFramebufferDrawBufferEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFramebufferDrawBuffersEXT = (GLEEPFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC) __GLeeGetProcAddress("glFramebufferDrawBuffersEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFramebufferReadBufferEXT = (GLEEPFNGLFRAMEBUFFERREADBUFFEREXTPROC) __GLeeGetProcAddress("glFramebufferReadBufferEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetFramebufferParameterivEXT = (GLEEPFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC) __GLeeGetProcAddress("glGetFramebufferParameterivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glNamedRenderbufferStorageMultisampleEXT = (GLEEPFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC) __GLeeGetProcAddress("glNamedRenderbufferStorageMultisampleEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glNamedRenderbufferStorageMultisampleCoverageEXT = (GLEEPFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC) __GLeeGetProcAddress("glNamedRenderbufferStorageMultisampleCoverageEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glNamedFramebufferTextureEXT = (GLEEPFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC) __GLeeGetProcAddress("glNamedFramebufferTextureEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glNamedFramebufferTextureLayerEXT = (GLEEPFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC) __GLeeGetProcAddress("glNamedFramebufferTextureLayerEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glNamedFramebufferTextureFaceEXT = (GLEEPFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC) __GLeeGetProcAddress("glNamedFramebufferTextureFaceEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glTextureRenderbufferEXT = (GLEEPFNGLTEXTURERENDERBUFFEREXTPROC) __GLeeGetProcAddress("glTextureRenderbufferEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glMultiTexRenderbufferEXT = (GLEEPFNGLMULTITEXRENDERBUFFEREXTPROC) __GLeeGetProcAddress("glMultiTexRenderbufferEXT"))!=0) nLinked++;
#endif
if (nLinked==186) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_vertex_array_bgra(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_texture_swizzle(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_explicit_multisample(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_NV_explicit_multisample
if ((GLeeFuncPtr_glGetMultisamplefvNV = (GLEEPFNGLGETMULTISAMPLEFVNVPROC) __GLeeGetProcAddress("glGetMultisamplefvNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glSampleMaskIndexedNV = (GLEEPFNGLSAMPLEMASKINDEXEDNVPROC) __GLeeGetProcAddress("glSampleMaskIndexedNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glTexRenderbufferNV = (GLEEPFNGLTEXRENDERBUFFERNVPROC) __GLeeGetProcAddress("glTexRenderbufferNV"))!=0) nLinked++;
#endif
if (nLinked==3) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_NV_transform_feedback2(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_NV_transform_feedback2
if ((GLeeFuncPtr_glBindTransformFeedbackNV = (GLEEPFNGLBINDTRANSFORMFEEDBACKNVPROC) __GLeeGetProcAddress("glBindTransformFeedbackNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glDeleteTransformFeedbacksNV = (GLEEPFNGLDELETETRANSFORMFEEDBACKSNVPROC) __GLeeGetProcAddress("glDeleteTransformFeedbacksNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGenTransformFeedbacksNV = (GLEEPFNGLGENTRANSFORMFEEDBACKSNVPROC) __GLeeGetProcAddress("glGenTransformFeedbacksNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glIsTransformFeedbackNV = (GLEEPFNGLISTRANSFORMFEEDBACKNVPROC) __GLeeGetProcAddress("glIsTransformFeedbackNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glPauseTransformFeedbackNV = (GLEEPFNGLPAUSETRANSFORMFEEDBACKNVPROC) __GLeeGetProcAddress("glPauseTransformFeedbackNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glResumeTransformFeedbackNV = (GLEEPFNGLRESUMETRANSFORMFEEDBACKNVPROC) __GLeeGetProcAddress("glResumeTransformFeedbackNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glDrawTransformFeedbackNV = (GLEEPFNGLDRAWTRANSFORMFEEDBACKNVPROC) __GLeeGetProcAddress("glDrawTransformFeedbackNV"))!=0) nLinked++;
#endif
if (nLinked==7) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SGIX_texture_select(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_INGR_blend_func_separate(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_INGR_blend_func_separate
if ((GLeeFuncPtr_glBlendFuncSeparateINGR = (GLEEPFNGLBLENDFUNCSEPARATEINGRPROC) __GLeeGetProcAddress("glBlendFuncSeparateINGR"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SGIX_depth_pass_instrument(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIX_igloo_interface(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_SGIX_igloo_interface
if ((GLeeFuncPtr_glIglooInterfaceSGIX = (GLEEPFNGLIGLOOINTERFACESGIXPROC) __GLeeGetProcAddress("glIglooInterfaceSGIX"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_fragment_lighting(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_fragment_lighting
if ((GLeeFuncPtr_glFragmentLightModeliEXT = (GLEEPFNGLFRAGMENTLIGHTMODELIEXTPROC) __GLeeGetProcAddress("glFragmentLightModeliEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFragmentLightModelfEXT = (GLEEPFNGLFRAGMENTLIGHTMODELFEXTPROC) __GLeeGetProcAddress("glFragmentLightModelfEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFragmentLightModelivEXT = (GLEEPFNGLFRAGMENTLIGHTMODELIVEXTPROC) __GLeeGetProcAddress("glFragmentLightModelivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFragmentLightModelfvEXT = (GLEEPFNGLFRAGMENTLIGHTMODELFVEXTPROC) __GLeeGetProcAddress("glFragmentLightModelfvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFragmentLightiEXT = (GLEEPFNGLFRAGMENTLIGHTIEXTPROC) __GLeeGetProcAddress("glFragmentLightiEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFragmentLightfEXT = (GLEEPFNGLFRAGMENTLIGHTFEXTPROC) __GLeeGetProcAddress("glFragmentLightfEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFragmentLightivEXT = (GLEEPFNGLFRAGMENTLIGHTIVEXTPROC) __GLeeGetProcAddress("glFragmentLightivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFragmentLightfvEXT = (GLEEPFNGLFRAGMENTLIGHTFVEXTPROC) __GLeeGetProcAddress("glFragmentLightfvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetFragmentLightivEXT = (GLEEPFNGLGETFRAGMENTLIGHTIVEXTPROC) __GLeeGetProcAddress("glGetFragmentLightivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetFragmentLightfvEXT = (GLEEPFNGLGETFRAGMENTLIGHTFVEXTPROC) __GLeeGetProcAddress("glGetFragmentLightfvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFragmentMaterialfEXT = (GLEEPFNGLFRAGMENTMATERIALFEXTPROC) __GLeeGetProcAddress("glFragmentMaterialfEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFragmentMaterialiEXT = (GLEEPFNGLFRAGMENTMATERIALIEXTPROC) __GLeeGetProcAddress("glFragmentMaterialiEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFragmentMaterialfvEXT = (GLEEPFNGLFRAGMENTMATERIALFVEXTPROC) __GLeeGetProcAddress("glFragmentMaterialfvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFragmentMaterialivEXT = (GLEEPFNGLFRAGMENTMATERIALIVEXTPROC) __GLeeGetProcAddress("glFragmentMaterialivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFragmentColorMaterialEXT = (GLEEPFNGLFRAGMENTCOLORMATERIALEXTPROC) __GLeeGetProcAddress("glFragmentColorMaterialEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetFragmentMaterialfvEXT = (GLEEPFNGLGETFRAGMENTMATERIALFVEXTPROC) __GLeeGetProcAddress("glGetFragmentMaterialfvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetFragmentMaterialivEXT = (GLEEPFNGLGETFRAGMENTMATERIALIVEXTPROC) __GLeeGetProcAddress("glGetFragmentMaterialivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glLightEnviEXT = (GLEEPFNGLLIGHTENVIEXTPROC) __GLeeGetProcAddress("glLightEnviEXT"))!=0) nLinked++;
#endif
if (nLinked==18) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_geometry_shader4(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_geometry_shader4
if ((GLeeFuncPtr_glProgramParameteriEXT = (GLEEPFNGLPROGRAMPARAMETERIEXTPROC) __GLeeGetProcAddress("glProgramParameteriEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFramebufferTextureEXT = (GLEEPFNGLFRAMEBUFFERTEXTUREEXTPROC) __GLeeGetProcAddress("glFramebufferTextureEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFramebufferTextureLayerEXT = (GLEEPFNGLFRAMEBUFFERTEXTURELAYEREXTPROC) __GLeeGetProcAddress("glFramebufferTextureLayerEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFramebufferTextureFaceEXT = (GLEEPFNGLFRAMEBUFFERTEXTUREFACEEXTPROC) __GLeeGetProcAddress("glFramebufferTextureFaceEXT"))!=0) nLinked++;
#endif
if (nLinked==4) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_scene_marker(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_EXT_scene_marker
if ((GLeeFuncPtr_glBeginSceneEXT = (GLEEPFNGLBEGINSCENEEXTPROC) __GLeeGetProcAddress("glBeginSceneEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glEndSceneEXT = (GLEEPFNGLENDSCENEEXTPROC) __GLeeGetProcAddress("glEndSceneEXT"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_EXT_texture_compression_dxt1(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_EXT_texture_env(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_IBM_static_data(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_NV_gpu_program4(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_NV_gpu_program4
if ((GLeeFuncPtr_glProgramLocalParameterI4iNV = (GLEEPFNGLPROGRAMLOCALPARAMETERI4INVPROC) __GLeeGetProcAddress("glProgramLocalParameterI4iNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramLocalParameterI4ivNV = (GLEEPFNGLPROGRAMLOCALPARAMETERI4IVNVPROC) __GLeeGetProcAddress("glProgramLocalParameterI4ivNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramLocalParametersI4ivNV = (GLEEPFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC) __GLeeGetProcAddress("glProgramLocalParametersI4ivNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramLocalParameterI4uiNV = (GLEEPFNGLPROGRAMLOCALPARAMETERI4UINVPROC) __GLeeGetProcAddress("glProgramLocalParameterI4uiNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramLocalParameterI4uivNV = (GLEEPFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC) __GLeeGetProcAddress("glProgramLocalParameterI4uivNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramLocalParametersI4uivNV = (GLEEPFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC) __GLeeGetProcAddress("glProgramLocalParametersI4uivNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramEnvParameterI4iNV = (GLEEPFNGLPROGRAMENVPARAMETERI4INVPROC) __GLeeGetProcAddress("glProgramEnvParameterI4iNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramEnvParameterI4ivNV = (GLEEPFNGLPROGRAMENVPARAMETERI4IVNVPROC) __GLeeGetProcAddress("glProgramEnvParameterI4ivNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramEnvParametersI4ivNV = (GLEEPFNGLPROGRAMENVPARAMETERSI4IVNVPROC) __GLeeGetProcAddress("glProgramEnvParametersI4ivNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramEnvParameterI4uiNV = (GLEEPFNGLPROGRAMENVPARAMETERI4UINVPROC) __GLeeGetProcAddress("glProgramEnvParameterI4uiNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramEnvParameterI4uivNV = (GLEEPFNGLPROGRAMENVPARAMETERI4UIVNVPROC) __GLeeGetProcAddress("glProgramEnvParameterI4uivNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glProgramEnvParametersI4uivNV = (GLEEPFNGLPROGRAMENVPARAMETERSI4UIVNVPROC) __GLeeGetProcAddress("glProgramEnvParametersI4uivNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetProgramLocalParameterIivNV = (GLEEPFNGLGETPROGRAMLOCALPARAMETERIIVNVPROC) __GLeeGetProcAddress("glGetProgramLocalParameterIivNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetProgramLocalParameterIuivNV = (GLEEPFNGLGETPROGRAMLOCALPARAMETERIUIVNVPROC) __GLeeGetProcAddress("glGetProgramLocalParameterIuivNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetProgramEnvParameterIivNV = (GLEEPFNGLGETPROGRAMENVPARAMETERIIVNVPROC) __GLeeGetProcAddress("glGetProgramEnvParameterIivNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetProgramEnvParameterIuivNV = (GLEEPFNGLGETPROGRAMENVPARAMETERIUIVNVPROC) __GLeeGetProcAddress("glGetProgramEnvParameterIuivNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glFramebufferTextureEXT = (GLEEPFNGLFRAMEBUFFERTEXTUREEXTPROC) __GLeeGetProcAddress("glFramebufferTextureEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFramebufferTextureLayerEXT = (GLEEPFNGLFRAMEBUFFERTEXTURELAYEREXTPROC) __GLeeGetProcAddress("glFramebufferTextureLayerEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glFramebufferTextureFaceEXT = (GLEEPFNGLFRAMEBUFFERTEXTUREFACEEXTPROC) __GLeeGetProcAddress("glFramebufferTextureFaceEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI2iEXT = (GLEEPFNGLVERTEXATTRIBI2IEXTPROC) __GLeeGetProcAddress("glVertexAttribI2iEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI3iEXT = (GLEEPFNGLVERTEXATTRIBI3IEXTPROC) __GLeeGetProcAddress("glVertexAttribI3iEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI4iEXT = (GLEEPFNGLVERTEXATTRIBI4IEXTPROC) __GLeeGetProcAddress("glVertexAttribI4iEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI1uiEXT = (GLEEPFNGLVERTEXATTRIBI1UIEXTPROC) __GLeeGetProcAddress("glVertexAttribI1uiEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI2uiEXT = (GLEEPFNGLVERTEXATTRIBI2UIEXTPROC) __GLeeGetProcAddress("glVertexAttribI2uiEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI3uiEXT = (GLEEPFNGLVERTEXATTRIBI3UIEXTPROC) __GLeeGetProcAddress("glVertexAttribI3uiEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI4uiEXT = (GLEEPFNGLVERTEXATTRIBI4UIEXTPROC) __GLeeGetProcAddress("glVertexAttribI4uiEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI1ivEXT = (GLEEPFNGLVERTEXATTRIBI1IVEXTPROC) __GLeeGetProcAddress("glVertexAttribI1ivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI2ivEXT = (GLEEPFNGLVERTEXATTRIBI2IVEXTPROC) __GLeeGetProcAddress("glVertexAttribI2ivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI3ivEXT = (GLEEPFNGLVERTEXATTRIBI3IVEXTPROC) __GLeeGetProcAddress("glVertexAttribI3ivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI4ivEXT = (GLEEPFNGLVERTEXATTRIBI4IVEXTPROC) __GLeeGetProcAddress("glVertexAttribI4ivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI1uivEXT = (GLEEPFNGLVERTEXATTRIBI1UIVEXTPROC) __GLeeGetProcAddress("glVertexAttribI1uivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI2uivEXT = (GLEEPFNGLVERTEXATTRIBI2UIVEXTPROC) __GLeeGetProcAddress("glVertexAttribI2uivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI3uivEXT = (GLEEPFNGLVERTEXATTRIBI3UIVEXTPROC) __GLeeGetProcAddress("glVertexAttribI3uivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI4uivEXT = (GLEEPFNGLVERTEXATTRIBI4UIVEXTPROC) __GLeeGetProcAddress("glVertexAttribI4uivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI4bvEXT = (GLEEPFNGLVERTEXATTRIBI4BVEXTPROC) __GLeeGetProcAddress("glVertexAttribI4bvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI4svEXT = (GLEEPFNGLVERTEXATTRIBI4SVEXTPROC) __GLeeGetProcAddress("glVertexAttribI4svEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI4ubvEXT = (GLEEPFNGLVERTEXATTRIBI4UBVEXTPROC) __GLeeGetProcAddress("glVertexAttribI4ubvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribI4usvEXT = (GLEEPFNGLVERTEXATTRIBI4USVEXTPROC) __GLeeGetProcAddress("glVertexAttribI4usvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glVertexAttribIPointerEXT = (GLEEPFNGLVERTEXATTRIBIPOINTEREXTPROC) __GLeeGetProcAddress("glVertexAttribIPointerEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetVertexAttribIivEXT = (GLEEPFNGLGETVERTEXATTRIBIIVEXTPROC) __GLeeGetProcAddress("glGetVertexAttribIivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetVertexAttribIuivEXT = (GLEEPFNGLGETVERTEXATTRIBIUIVEXTPROC) __GLeeGetProcAddress("glGetVertexAttribIuivEXT"))!=0) nLinked++;
#endif
if (nLinked==41) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_OES_byte_coordinates(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_OES_compressed_paletted_texture(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_OES_single_precision(void)
{
GLint nLinked=0;
#ifdef __GLEE_GL_OES_single_precision
if ((GLeeFuncPtr_glDepthRangefOES = (GLEEPFNGLDEPTHRANGEFOESPROC) __GLeeGetProcAddress("glDepthRangefOES"))!=0) nLinked++;
if ((GLeeFuncPtr_glFrustumfOES = (GLEEPFNGLFRUSTUMFOESPROC) __GLeeGetProcAddress("glFrustumfOES"))!=0) nLinked++;
if ((GLeeFuncPtr_glOrthofOES = (GLEEPFNGLORTHOFOESPROC) __GLeeGetProcAddress("glOrthofOES"))!=0) nLinked++;
if ((GLeeFuncPtr_glClipPlanefOES = (GLEEPFNGLCLIPPLANEFOESPROC) __GLeeGetProcAddress("glClipPlanefOES"))!=0) nLinked++;
if ((GLeeFuncPtr_glGetClipPlanefOES = (GLEEPFNGLGETCLIPPLANEFOESPROC) __GLeeGetProcAddress("glGetClipPlanefOES"))!=0) nLinked++;
if ((GLeeFuncPtr_glClearDepthfOES = (GLEEPFNGLCLEARDEPTHFOESPROC) __GLeeGetProcAddress("glClearDepthfOES"))!=0) nLinked++;
#endif
if (nLinked==6) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GL_SGIX_pixel_texture_bits(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GL_SGIX_texture_range(void) {return GLEE_LINK_COMPLETE;}
GLEE_LINK_FUNCTION __GLeeGLLoadFunction[322];
void initGLLoadFunctions(void)
{
__GLeeGLLoadFunction[0]=__GLeeLink_GL_VERSION_1_2;
__GLeeGLLoadFunction[1]=__GLeeLink_GL_ARB_imaging;
__GLeeGLLoadFunction[2]=__GLeeLink_GL_VERSION_1_3;
__GLeeGLLoadFunction[3]=__GLeeLink_GL_VERSION_1_4;
__GLeeGLLoadFunction[4]=__GLeeLink_GL_VERSION_1_5;
__GLeeGLLoadFunction[5]=__GLeeLink_GL_VERSION_2_0;
__GLeeGLLoadFunction[6]=__GLeeLink_GL_VERSION_2_1;
__GLeeGLLoadFunction[7]=__GLeeLink_GL_VERSION_3_0;
__GLeeGLLoadFunction[8]=__GLeeLink_GL_ARB_multitexture;
__GLeeGLLoadFunction[9]=__GLeeLink_GL_ARB_transpose_matrix;
__GLeeGLLoadFunction[10]=__GLeeLink_GL_ARB_multisample;
__GLeeGLLoadFunction[11]=__GLeeLink_GL_ARB_texture_env_add;
__GLeeGLLoadFunction[12]=__GLeeLink_GL_ARB_texture_cube_map;
__GLeeGLLoadFunction[13]=__GLeeLink_GL_ARB_texture_compression;
__GLeeGLLoadFunction[14]=__GLeeLink_GL_ARB_texture_border_clamp;
__GLeeGLLoadFunction[15]=__GLeeLink_GL_ARB_point_parameters;
__GLeeGLLoadFunction[16]=__GLeeLink_GL_ARB_vertex_blend;
__GLeeGLLoadFunction[17]=__GLeeLink_GL_ARB_matrix_palette;
__GLeeGLLoadFunction[18]=__GLeeLink_GL_ARB_texture_env_combine;
__GLeeGLLoadFunction[19]=__GLeeLink_GL_ARB_texture_env_crossbar;
__GLeeGLLoadFunction[20]=__GLeeLink_GL_ARB_texture_env_dot3;
__GLeeGLLoadFunction[21]=__GLeeLink_GL_ARB_texture_mirrored_repeat;
__GLeeGLLoadFunction[22]=__GLeeLink_GL_ARB_depth_texture;
__GLeeGLLoadFunction[23]=__GLeeLink_GL_ARB_shadow;
__GLeeGLLoadFunction[24]=__GLeeLink_GL_ARB_shadow_ambient;
__GLeeGLLoadFunction[25]=__GLeeLink_GL_ARB_window_pos;
__GLeeGLLoadFunction[26]=__GLeeLink_GL_ARB_vertex_program;
__GLeeGLLoadFunction[27]=__GLeeLink_GL_ARB_fragment_program;
__GLeeGLLoadFunction[28]=__GLeeLink_GL_ARB_vertex_buffer_object;
__GLeeGLLoadFunction[29]=__GLeeLink_GL_ARB_occlusion_query;
__GLeeGLLoadFunction[30]=__GLeeLink_GL_ARB_shader_objects;
__GLeeGLLoadFunction[31]=__GLeeLink_GL_ARB_vertex_shader;
__GLeeGLLoadFunction[32]=__GLeeLink_GL_ARB_fragment_shader;
__GLeeGLLoadFunction[33]=__GLeeLink_GL_ARB_shading_language_100;
__GLeeGLLoadFunction[34]=__GLeeLink_GL_ARB_texture_non_power_of_two;
__GLeeGLLoadFunction[35]=__GLeeLink_GL_ARB_point_sprite;
__GLeeGLLoadFunction[36]=__GLeeLink_GL_ARB_fragment_program_shadow;
__GLeeGLLoadFunction[37]=__GLeeLink_GL_ARB_draw_buffers;
__GLeeGLLoadFunction[38]=__GLeeLink_GL_ARB_texture_rectangle;
__GLeeGLLoadFunction[39]=__GLeeLink_GL_ARB_color_buffer_float;
__GLeeGLLoadFunction[40]=__GLeeLink_GL_ARB_half_float_pixel;
__GLeeGLLoadFunction[41]=__GLeeLink_GL_ARB_texture_float;
__GLeeGLLoadFunction[42]=__GLeeLink_GL_ARB_pixel_buffer_object;
__GLeeGLLoadFunction[43]=__GLeeLink_GL_ARB_depth_buffer_float;
__GLeeGLLoadFunction[44]=__GLeeLink_GL_ARB_draw_instanced;
__GLeeGLLoadFunction[45]=__GLeeLink_GL_ARB_framebuffer_object;
__GLeeGLLoadFunction[46]=__GLeeLink_GL_ARB_framebuffer_sRGB;
__GLeeGLLoadFunction[47]=__GLeeLink_GL_ARB_geometry_shader4;
__GLeeGLLoadFunction[48]=__GLeeLink_GL_ARB_half_float_vertex;
__GLeeGLLoadFunction[49]=__GLeeLink_GL_ARB_instanced_arrays;
__GLeeGLLoadFunction[50]=__GLeeLink_GL_ARB_map_buffer_range;
__GLeeGLLoadFunction[51]=__GLeeLink_GL_ARB_texture_buffer_object;
__GLeeGLLoadFunction[52]=__GLeeLink_GL_ARB_texture_compression_rgtc;
__GLeeGLLoadFunction[53]=__GLeeLink_GL_ARB_texture_rg;
__GLeeGLLoadFunction[54]=__GLeeLink_GL_ARB_vertex_array_object;
__GLeeGLLoadFunction[55]=__GLeeLink_GL_EXT_abgr;
__GLeeGLLoadFunction[56]=__GLeeLink_GL_EXT_blend_color;
__GLeeGLLoadFunction[57]=__GLeeLink_GL_EXT_polygon_offset;
__GLeeGLLoadFunction[58]=__GLeeLink_GL_EXT_texture;
__GLeeGLLoadFunction[59]=__GLeeLink_GL_EXT_texture3D;
__GLeeGLLoadFunction[60]=__GLeeLink_GL_SGIS_texture_filter4;
__GLeeGLLoadFunction[61]=__GLeeLink_GL_EXT_subtexture;
__GLeeGLLoadFunction[62]=__GLeeLink_GL_EXT_copy_texture;
__GLeeGLLoadFunction[63]=__GLeeLink_GL_EXT_histogram;
__GLeeGLLoadFunction[64]=__GLeeLink_GL_EXT_convolution;
__GLeeGLLoadFunction[65]=__GLeeLink_GL_SGI_color_matrix;
__GLeeGLLoadFunction[66]=__GLeeLink_GL_SGI_color_table;
__GLeeGLLoadFunction[67]=__GLeeLink_GL_SGIS_pixel_texture;
__GLeeGLLoadFunction[68]=__GLeeLink_GL_SGIX_pixel_texture;
__GLeeGLLoadFunction[69]=__GLeeLink_GL_SGIS_texture4D;
__GLeeGLLoadFunction[70]=__GLeeLink_GL_SGI_texture_color_table;
__GLeeGLLoadFunction[71]=__GLeeLink_GL_EXT_cmyka;
__GLeeGLLoadFunction[72]=__GLeeLink_GL_EXT_texture_object;
__GLeeGLLoadFunction[73]=__GLeeLink_GL_SGIS_detail_texture;
__GLeeGLLoadFunction[74]=__GLeeLink_GL_SGIS_sharpen_texture;
__GLeeGLLoadFunction[75]=__GLeeLink_GL_EXT_packed_pixels;
__GLeeGLLoadFunction[76]=__GLeeLink_GL_SGIS_texture_lod;
__GLeeGLLoadFunction[77]=__GLeeLink_GL_SGIS_multisample;
__GLeeGLLoadFunction[78]=__GLeeLink_GL_EXT_rescale_normal;
__GLeeGLLoadFunction[79]=__GLeeLink_GL_EXT_vertex_array;
__GLeeGLLoadFunction[80]=__GLeeLink_GL_EXT_misc_attribute;
__GLeeGLLoadFunction[81]=__GLeeLink_GL_SGIS_generate_mipmap;
__GLeeGLLoadFunction[82]=__GLeeLink_GL_SGIX_clipmap;
__GLeeGLLoadFunction[83]=__GLeeLink_GL_SGIX_shadow;
__GLeeGLLoadFunction[84]=__GLeeLink_GL_SGIS_texture_edge_clamp;
__GLeeGLLoadFunction[85]=__GLeeLink_GL_SGIS_texture_border_clamp;
__GLeeGLLoadFunction[86]=__GLeeLink_GL_EXT_blend_minmax;
__GLeeGLLoadFunction[87]=__GLeeLink_GL_EXT_blend_subtract;
__GLeeGLLoadFunction[88]=__GLeeLink_GL_EXT_blend_logic_op;
__GLeeGLLoadFunction[89]=__GLeeLink_GL_SGIX_interlace;
__GLeeGLLoadFunction[90]=__GLeeLink_GL_SGIX_pixel_tiles;
__GLeeGLLoadFunction[91]=__GLeeLink_GL_SGIS_texture_select;
__GLeeGLLoadFunction[92]=__GLeeLink_GL_SGIX_sprite;
__GLeeGLLoadFunction[93]=__GLeeLink_GL_SGIX_texture_multi_buffer;
__GLeeGLLoadFunction[94]=__GLeeLink_GL_EXT_point_parameters;
__GLeeGLLoadFunction[95]=__GLeeLink_GL_SGIS_point_parameters;
__GLeeGLLoadFunction[96]=__GLeeLink_GL_SGIX_instruments;
__GLeeGLLoadFunction[97]=__GLeeLink_GL_SGIX_texture_scale_bias;
__GLeeGLLoadFunction[98]=__GLeeLink_GL_SGIX_framezoom;
__GLeeGLLoadFunction[99]=__GLeeLink_GL_SGIX_tag_sample_buffer;
__GLeeGLLoadFunction[100]=__GLeeLink_GL_FfdMaskSGIX;
__GLeeGLLoadFunction[101]=__GLeeLink_GL_SGIX_polynomial_ffd;
__GLeeGLLoadFunction[102]=__GLeeLink_GL_SGIX_reference_plane;
__GLeeGLLoadFunction[103]=__GLeeLink_GL_SGIX_flush_raster;
__GLeeGLLoadFunction[104]=__GLeeLink_GL_SGIX_depth_texture;
__GLeeGLLoadFunction[105]=__GLeeLink_GL_SGIS_fog_function;
__GLeeGLLoadFunction[106]=__GLeeLink_GL_SGIX_fog_offset;
__GLeeGLLoadFunction[107]=__GLeeLink_GL_HP_image_transform;
__GLeeGLLoadFunction[108]=__GLeeLink_GL_HP_convolution_border_modes;
__GLeeGLLoadFunction[109]=__GLeeLink_GL_INGR_palette_buffer;
__GLeeGLLoadFunction[110]=__GLeeLink_GL_SGIX_texture_add_env;
__GLeeGLLoadFunction[111]=__GLeeLink_GL_EXT_color_subtable;
__GLeeGLLoadFunction[112]=__GLeeLink_GL_PGI_vertex_hints;
__GLeeGLLoadFunction[113]=__GLeeLink_GL_PGI_misc_hints;
__GLeeGLLoadFunction[114]=__GLeeLink_GL_EXT_paletted_texture;
__GLeeGLLoadFunction[115]=__GLeeLink_GL_EXT_clip_volume_hint;
__GLeeGLLoadFunction[116]=__GLeeLink_GL_SGIX_list_priority;
__GLeeGLLoadFunction[117]=__GLeeLink_GL_SGIX_ir_instrument1;
__GLeeGLLoadFunction[118]=__GLeeLink_GL_SGIX_calligraphic_fragment;
__GLeeGLLoadFunction[119]=__GLeeLink_GL_SGIX_texture_lod_bias;
__GLeeGLLoadFunction[120]=__GLeeLink_GL_SGIX_shadow_ambient;
__GLeeGLLoadFunction[121]=__GLeeLink_GL_EXT_index_texture;
__GLeeGLLoadFunction[122]=__GLeeLink_GL_EXT_index_material;
__GLeeGLLoadFunction[123]=__GLeeLink_GL_EXT_index_func;
__GLeeGLLoadFunction[124]=__GLeeLink_GL_EXT_index_array_formats;
__GLeeGLLoadFunction[125]=__GLeeLink_GL_EXT_compiled_vertex_array;
__GLeeGLLoadFunction[126]=__GLeeLink_GL_EXT_cull_vertex;
__GLeeGLLoadFunction[127]=__GLeeLink_GL_SGIX_ycrcb;
__GLeeGLLoadFunction[128]=__GLeeLink_GL_SGIX_fragment_lighting;
__GLeeGLLoadFunction[129]=__GLeeLink_GL_IBM_rasterpos_clip;
__GLeeGLLoadFunction[130]=__GLeeLink_GL_HP_texture_lighting;
__GLeeGLLoadFunction[131]=__GLeeLink_GL_EXT_draw_range_elements;
__GLeeGLLoadFunction[132]=__GLeeLink_GL_WIN_phong_shading;
__GLeeGLLoadFunction[133]=__GLeeLink_GL_WIN_specular_fog;
__GLeeGLLoadFunction[134]=__GLeeLink_GL_EXT_light_texture;
__GLeeGLLoadFunction[135]=__GLeeLink_GL_SGIX_blend_alpha_minmax;
__GLeeGLLoadFunction[136]=__GLeeLink_GL_SGIX_impact_pixel_texture;
__GLeeGLLoadFunction[137]=__GLeeLink_GL_EXT_bgra;
__GLeeGLLoadFunction[138]=__GLeeLink_GL_SGIX_async;
__GLeeGLLoadFunction[139]=__GLeeLink_GL_SGIX_async_pixel;
__GLeeGLLoadFunction[140]=__GLeeLink_GL_SGIX_async_histogram;
__GLeeGLLoadFunction[141]=__GLeeLink_GL_INTEL_texture_scissor;
__GLeeGLLoadFunction[142]=__GLeeLink_GL_INTEL_parallel_arrays;
__GLeeGLLoadFunction[143]=__GLeeLink_GL_HP_occlusion_test;
__GLeeGLLoadFunction[144]=__GLeeLink_GL_EXT_pixel_transform;
__GLeeGLLoadFunction[145]=__GLeeLink_GL_EXT_pixel_transform_color_table;
__GLeeGLLoadFunction[146]=__GLeeLink_GL_EXT_shared_texture_palette;
__GLeeGLLoadFunction[147]=__GLeeLink_GL_EXT_separate_specular_color;
__GLeeGLLoadFunction[148]=__GLeeLink_GL_EXT_secondary_color;
__GLeeGLLoadFunction[149]=__GLeeLink_GL_EXT_texture_perturb_normal;
__GLeeGLLoadFunction[150]=__GLeeLink_GL_EXT_multi_draw_arrays;
__GLeeGLLoadFunction[151]=__GLeeLink_GL_EXT_fog_coord;
__GLeeGLLoadFunction[152]=__GLeeLink_GL_REND_screen_coordinates;
__GLeeGLLoadFunction[153]=__GLeeLink_GL_EXT_coordinate_frame;
__GLeeGLLoadFunction[154]=__GLeeLink_GL_EXT_texture_env_combine;
__GLeeGLLoadFunction[155]=__GLeeLink_GL_APPLE_specular_vector;
__GLeeGLLoadFunction[156]=__GLeeLink_GL_APPLE_transform_hint;
__GLeeGLLoadFunction[157]=__GLeeLink_GL_SGIX_fog_scale;
__GLeeGLLoadFunction[158]=__GLeeLink_GL_SUNX_constant_data;
__GLeeGLLoadFunction[159]=__GLeeLink_GL_SUN_global_alpha;
__GLeeGLLoadFunction[160]=__GLeeLink_GL_SUN_triangle_list;
__GLeeGLLoadFunction[161]=__GLeeLink_GL_SUN_vertex;
__GLeeGLLoadFunction[162]=__GLeeLink_GL_EXT_blend_func_separate;
__GLeeGLLoadFunction[163]=__GLeeLink_GL_INGR_color_clamp;
__GLeeGLLoadFunction[164]=__GLeeLink_GL_INGR_interlace_read;
__GLeeGLLoadFunction[165]=__GLeeLink_GL_EXT_stencil_wrap;
__GLeeGLLoadFunction[166]=__GLeeLink_GL_EXT_422_pixels;
__GLeeGLLoadFunction[167]=__GLeeLink_GL_NV_texgen_reflection;
__GLeeGLLoadFunction[168]=__GLeeLink_GL_EXT_texture_cube_map;
__GLeeGLLoadFunction[169]=__GLeeLink_GL_SUN_convolution_border_modes;
__GLeeGLLoadFunction[170]=__GLeeLink_GL_EXT_texture_env_add;
__GLeeGLLoadFunction[171]=__GLeeLink_GL_EXT_texture_lod_bias;
__GLeeGLLoadFunction[172]=__GLeeLink_GL_EXT_texture_filter_anisotropic;
__GLeeGLLoadFunction[173]=__GLeeLink_GL_EXT_vertex_weighting;
__GLeeGLLoadFunction[174]=__GLeeLink_GL_NV_light_max_exponent;
__GLeeGLLoadFunction[175]=__GLeeLink_GL_NV_vertex_array_range;
__GLeeGLLoadFunction[176]=__GLeeLink_GL_NV_register_combiners;
__GLeeGLLoadFunction[177]=__GLeeLink_GL_NV_fog_distance;
__GLeeGLLoadFunction[178]=__GLeeLink_GL_NV_texgen_emboss;
__GLeeGLLoadFunction[179]=__GLeeLink_GL_NV_blend_square;
__GLeeGLLoadFunction[180]=__GLeeLink_GL_NV_texture_env_combine4;
__GLeeGLLoadFunction[181]=__GLeeLink_GL_MESA_resize_buffers;
__GLeeGLLoadFunction[182]=__GLeeLink_GL_MESA_window_pos;
__GLeeGLLoadFunction[183]=__GLeeLink_GL_EXT_texture_compression_s3tc;
__GLeeGLLoadFunction[184]=__GLeeLink_GL_IBM_cull_vertex;
__GLeeGLLoadFunction[185]=__GLeeLink_GL_IBM_multimode_draw_arrays;
__GLeeGLLoadFunction[186]=__GLeeLink_GL_IBM_vertex_array_lists;
__GLeeGLLoadFunction[187]=__GLeeLink_GL_SGIX_subsample;
__GLeeGLLoadFunction[188]=__GLeeLink_GL_SGIX_ycrcb_subsample;
__GLeeGLLoadFunction[189]=__GLeeLink_GL_SGIX_ycrcba;
__GLeeGLLoadFunction[190]=__GLeeLink_GL_SGI_depth_pass_instrument;
__GLeeGLLoadFunction[191]=__GLeeLink_GL_3DFX_texture_compression_FXT1;
__GLeeGLLoadFunction[192]=__GLeeLink_GL_3DFX_multisample;
__GLeeGLLoadFunction[193]=__GLeeLink_GL_3DFX_tbuffer;
__GLeeGLLoadFunction[194]=__GLeeLink_GL_EXT_multisample;
__GLeeGLLoadFunction[195]=__GLeeLink_GL_SGIX_vertex_preclip;
__GLeeGLLoadFunction[196]=__GLeeLink_GL_SGIX_convolution_accuracy;
__GLeeGLLoadFunction[197]=__GLeeLink_GL_SGIX_resample;
__GLeeGLLoadFunction[198]=__GLeeLink_GL_SGIS_point_line_texgen;
__GLeeGLLoadFunction[199]=__GLeeLink_GL_SGIS_texture_color_mask;
__GLeeGLLoadFunction[200]=__GLeeLink_GL_EXT_texture_env_dot3;
__GLeeGLLoadFunction[201]=__GLeeLink_GL_ATI_texture_mirror_once;
__GLeeGLLoadFunction[202]=__GLeeLink_GL_NV_fence;
__GLeeGLLoadFunction[203]=__GLeeLink_GL_IBM_texture_mirrored_repeat;
__GLeeGLLoadFunction[204]=__GLeeLink_GL_NV_evaluators;
__GLeeGLLoadFunction[205]=__GLeeLink_GL_NV_packed_depth_stencil;
__GLeeGLLoadFunction[206]=__GLeeLink_GL_NV_register_combiners2;
__GLeeGLLoadFunction[207]=__GLeeLink_GL_NV_texture_compression_vtc;
__GLeeGLLoadFunction[208]=__GLeeLink_GL_NV_texture_rectangle;
__GLeeGLLoadFunction[209]=__GLeeLink_GL_NV_texture_shader;
__GLeeGLLoadFunction[210]=__GLeeLink_GL_NV_texture_shader2;
__GLeeGLLoadFunction[211]=__GLeeLink_GL_NV_vertex_array_range2;
__GLeeGLLoadFunction[212]=__GLeeLink_GL_NV_vertex_program;
__GLeeGLLoadFunction[213]=__GLeeLink_GL_SGIX_texture_coordinate_clamp;
__GLeeGLLoadFunction[214]=__GLeeLink_GL_SGIX_scalebias_hint;
__GLeeGLLoadFunction[215]=__GLeeLink_GL_OML_interlace;
__GLeeGLLoadFunction[216]=__GLeeLink_GL_OML_subsample;
__GLeeGLLoadFunction[217]=__GLeeLink_GL_OML_resample;
__GLeeGLLoadFunction[218]=__GLeeLink_GL_NV_copy_depth_to_color;
__GLeeGLLoadFunction[219]=__GLeeLink_GL_ATI_envmap_bumpmap;
__GLeeGLLoadFunction[220]=__GLeeLink_GL_ATI_fragment_shader;
__GLeeGLLoadFunction[221]=__GLeeLink_GL_ATI_pn_triangles;
__GLeeGLLoadFunction[222]=__GLeeLink_GL_ATI_vertex_array_object;
__GLeeGLLoadFunction[223]=__GLeeLink_GL_EXT_vertex_shader;
__GLeeGLLoadFunction[224]=__GLeeLink_GL_ATI_vertex_streams;
__GLeeGLLoadFunction[225]=__GLeeLink_GL_ATI_element_array;
__GLeeGLLoadFunction[226]=__GLeeLink_GL_SUN_mesh_array;
__GLeeGLLoadFunction[227]=__GLeeLink_GL_SUN_slice_accum;
__GLeeGLLoadFunction[228]=__GLeeLink_GL_NV_multisample_filter_hint;
__GLeeGLLoadFunction[229]=__GLeeLink_GL_NV_depth_clamp;
__GLeeGLLoadFunction[230]=__GLeeLink_GL_NV_occlusion_query;
__GLeeGLLoadFunction[231]=__GLeeLink_GL_NV_point_sprite;
__GLeeGLLoadFunction[232]=__GLeeLink_GL_NV_texture_shader3;
__GLeeGLLoadFunction[233]=__GLeeLink_GL_NV_vertex_program1_1;
__GLeeGLLoadFunction[234]=__GLeeLink_GL_EXT_shadow_funcs;
__GLeeGLLoadFunction[235]=__GLeeLink_GL_EXT_stencil_two_side;
__GLeeGLLoadFunction[236]=__GLeeLink_GL_ATI_text_fragment_shader;
__GLeeGLLoadFunction[237]=__GLeeLink_GL_APPLE_client_storage;
__GLeeGLLoadFunction[238]=__GLeeLink_GL_APPLE_element_array;
__GLeeGLLoadFunction[239]=__GLeeLink_GL_APPLE_fence;
__GLeeGLLoadFunction[240]=__GLeeLink_GL_APPLE_vertex_array_object;
__GLeeGLLoadFunction[241]=__GLeeLink_GL_APPLE_vertex_array_range;
__GLeeGLLoadFunction[242]=__GLeeLink_GL_APPLE_ycbcr_422;
__GLeeGLLoadFunction[243]=__GLeeLink_GL_S3_s3tc;
__GLeeGLLoadFunction[244]=__GLeeLink_GL_ATI_draw_buffers;
__GLeeGLLoadFunction[245]=__GLeeLink_GL_ATI_pixel_format_float;
__GLeeGLLoadFunction[246]=__GLeeLink_GL_ATI_texture_env_combine3;
__GLeeGLLoadFunction[247]=__GLeeLink_GL_ATI_texture_float;
__GLeeGLLoadFunction[248]=__GLeeLink_GL_NV_float_buffer;
__GLeeGLLoadFunction[249]=__GLeeLink_GL_NV_fragment_program;
__GLeeGLLoadFunction[250]=__GLeeLink_GL_NV_half_float;
__GLeeGLLoadFunction[251]=__GLeeLink_GL_NV_pixel_data_range;
__GLeeGLLoadFunction[252]=__GLeeLink_GL_NV_primitive_restart;
__GLeeGLLoadFunction[253]=__GLeeLink_GL_NV_texture_expand_normal;
__GLeeGLLoadFunction[254]=__GLeeLink_GL_NV_vertex_program2;
__GLeeGLLoadFunction[255]=__GLeeLink_GL_ATI_map_object_buffer;
__GLeeGLLoadFunction[256]=__GLeeLink_GL_ATI_separate_stencil;
__GLeeGLLoadFunction[257]=__GLeeLink_GL_ATI_vertex_attrib_array_object;
__GLeeGLLoadFunction[258]=__GLeeLink_GL_OES_read_format;
__GLeeGLLoadFunction[259]=__GLeeLink_GL_EXT_depth_bounds_test;
__GLeeGLLoadFunction[260]=__GLeeLink_GL_EXT_texture_mirror_clamp;
__GLeeGLLoadFunction[261]=__GLeeLink_GL_EXT_blend_equation_separate;
__GLeeGLLoadFunction[262]=__GLeeLink_GL_MESA_pack_invert;
__GLeeGLLoadFunction[263]=__GLeeLink_GL_MESA_ycbcr_texture;
__GLeeGLLoadFunction[264]=__GLeeLink_GL_EXT_pixel_buffer_object;
__GLeeGLLoadFunction[265]=__GLeeLink_GL_NV_fragment_program_option;
__GLeeGLLoadFunction[266]=__GLeeLink_GL_NV_fragment_program2;
__GLeeGLLoadFunction[267]=__GLeeLink_GL_NV_vertex_program2_option;
__GLeeGLLoadFunction[268]=__GLeeLink_GL_NV_vertex_program3;
__GLeeGLLoadFunction[269]=__GLeeLink_GL_EXT_framebuffer_object;
__GLeeGLLoadFunction[270]=__GLeeLink_GL_GREMEDY_string_marker;
__GLeeGLLoadFunction[271]=__GLeeLink_GL_EXT_packed_depth_stencil;
__GLeeGLLoadFunction[272]=__GLeeLink_GL_EXT_stencil_clear_tag;
__GLeeGLLoadFunction[273]=__GLeeLink_GL_EXT_texture_sRGB;
__GLeeGLLoadFunction[274]=__GLeeLink_GL_EXT_framebuffer_blit;
__GLeeGLLoadFunction[275]=__GLeeLink_GL_EXT_framebuffer_multisample;
__GLeeGLLoadFunction[276]=__GLeeLink_GL_MESAX_texture_stack;
__GLeeGLLoadFunction[277]=__GLeeLink_GL_EXT_timer_query;
__GLeeGLLoadFunction[278]=__GLeeLink_GL_EXT_gpu_program_parameters;
__GLeeGLLoadFunction[279]=__GLeeLink_GL_APPLE_flush_buffer_range;
__GLeeGLLoadFunction[280]=__GLeeLink_GL_EXT_gpu_shader4;
__GLeeGLLoadFunction[281]=__GLeeLink_GL_EXT_draw_instanced;
__GLeeGLLoadFunction[282]=__GLeeLink_GL_EXT_packed_float;
__GLeeGLLoadFunction[283]=__GLeeLink_GL_EXT_texture_array;
__GLeeGLLoadFunction[284]=__GLeeLink_GL_EXT_texture_buffer_object;
__GLeeGLLoadFunction[285]=__GLeeLink_GL_EXT_texture_compression_latc;
__GLeeGLLoadFunction[286]=__GLeeLink_GL_EXT_texture_compression_rgtc;
__GLeeGLLoadFunction[287]=__GLeeLink_GL_EXT_texture_shared_exponent;
__GLeeGLLoadFunction[288]=__GLeeLink_GL_NV_depth_buffer_float;
__GLeeGLLoadFunction[289]=__GLeeLink_GL_NV_framebuffer_multisample_coverage;
__GLeeGLLoadFunction[290]=__GLeeLink_GL_EXT_framebuffer_sRGB;
__GLeeGLLoadFunction[291]=__GLeeLink_GL_NV_geometry_shader4;
__GLeeGLLoadFunction[292]=__GLeeLink_GL_NV_parameter_buffer_object;
__GLeeGLLoadFunction[293]=__GLeeLink_GL_EXT_draw_buffers2;
__GLeeGLLoadFunction[294]=__GLeeLink_GL_NV_transform_feedback;
__GLeeGLLoadFunction[295]=__GLeeLink_GL_EXT_bindable_uniform;
__GLeeGLLoadFunction[296]=__GLeeLink_GL_EXT_texture_integer;
__GLeeGLLoadFunction[297]=__GLeeLink_GL_GREMEDY_frame_terminator;
__GLeeGLLoadFunction[298]=__GLeeLink_GL_NV_conditional_render;
__GLeeGLLoadFunction[299]=__GLeeLink_GL_NV_present_video;
__GLeeGLLoadFunction[300]=__GLeeLink_GL_EXT_transform_feedback;
__GLeeGLLoadFunction[301]=__GLeeLink_GL_EXT_direct_state_access;
__GLeeGLLoadFunction[302]=__GLeeLink_GL_EXT_vertex_array_bgra;
__GLeeGLLoadFunction[303]=__GLeeLink_GL_EXT_texture_swizzle;
__GLeeGLLoadFunction[304]=__GLeeLink_GL_NV_explicit_multisample;
__GLeeGLLoadFunction[305]=__GLeeLink_GL_NV_transform_feedback2;
__GLeeGLLoadFunction[306]=__GLeeLink_GL_SGIX_texture_select;
__GLeeGLLoadFunction[307]=__GLeeLink_GL_INGR_blend_func_separate;
__GLeeGLLoadFunction[308]=__GLeeLink_GL_SGIX_depth_pass_instrument;
__GLeeGLLoadFunction[309]=__GLeeLink_GL_SGIX_igloo_interface;
__GLeeGLLoadFunction[310]=__GLeeLink_GL_EXT_fragment_lighting;
__GLeeGLLoadFunction[311]=__GLeeLink_GL_EXT_geometry_shader4;
__GLeeGLLoadFunction[312]=__GLeeLink_GL_EXT_scene_marker;
__GLeeGLLoadFunction[313]=__GLeeLink_GL_EXT_texture_compression_dxt1;
__GLeeGLLoadFunction[314]=__GLeeLink_GL_EXT_texture_env;
__GLeeGLLoadFunction[315]=__GLeeLink_GL_IBM_static_data;
__GLeeGLLoadFunction[316]=__GLeeLink_GL_NV_gpu_program4;
__GLeeGLLoadFunction[317]=__GLeeLink_GL_OES_byte_coordinates;
__GLeeGLLoadFunction[318]=__GLeeLink_GL_OES_compressed_paletted_texture;
__GLeeGLLoadFunction[319]=__GLeeLink_GL_OES_single_precision;
__GLeeGLLoadFunction[320]=__GLeeLink_GL_SGIX_pixel_texture_bits;
__GLeeGLLoadFunction[321]=__GLeeLink_GL_SGIX_texture_range;
}
#ifdef WIN32
GLuint __GLeeLink_WGL_ARB_buffer_region(void)
{
GLint nLinked=0;
#ifdef __GLEE_WGL_ARB_buffer_region
if ((GLeeFuncPtr_wglCreateBufferRegionARB = (GLEEPFNWGLCREATEBUFFERREGIONARBPROC) __GLeeGetProcAddress("wglCreateBufferRegionARB"))!=0) nLinked++;
if ((GLeeFuncPtr_wglDeleteBufferRegionARB = (GLEEPFNWGLDELETEBUFFERREGIONARBPROC) __GLeeGetProcAddress("wglDeleteBufferRegionARB"))!=0) nLinked++;
if ((GLeeFuncPtr_wglSaveBufferRegionARB = (GLEEPFNWGLSAVEBUFFERREGIONARBPROC) __GLeeGetProcAddress("wglSaveBufferRegionARB"))!=0) nLinked++;
if ((GLeeFuncPtr_wglRestoreBufferRegionARB = (GLEEPFNWGLRESTOREBUFFERREGIONARBPROC) __GLeeGetProcAddress("wglRestoreBufferRegionARB"))!=0) nLinked++;
#endif
if (nLinked==4) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_WGL_ARB_multisample(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_WGL_ARB_extensions_string(void)
{
GLint nLinked=0;
#ifdef __GLEE_WGL_ARB_extensions_string
if ((GLeeFuncPtr_wglGetExtensionsStringARB = (GLEEPFNWGLGETEXTENSIONSSTRINGARBPROC) __GLeeGetProcAddress("wglGetExtensionsStringARB"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_WGL_ARB_pixel_format(void)
{
GLint nLinked=0;
#ifdef __GLEE_WGL_ARB_pixel_format
if ((GLeeFuncPtr_wglGetPixelFormatAttribivARB = (GLEEPFNWGLGETPIXELFORMATATTRIBIVARBPROC) __GLeeGetProcAddress("wglGetPixelFormatAttribivARB"))!=0) nLinked++;
if ((GLeeFuncPtr_wglGetPixelFormatAttribfvARB = (GLEEPFNWGLGETPIXELFORMATATTRIBFVARBPROC) __GLeeGetProcAddress("wglGetPixelFormatAttribfvARB"))!=0) nLinked++;
if ((GLeeFuncPtr_wglChoosePixelFormatARB = (GLEEPFNWGLCHOOSEPIXELFORMATARBPROC) __GLeeGetProcAddress("wglChoosePixelFormatARB"))!=0) nLinked++;
#endif
if (nLinked==3) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_WGL_ARB_make_current_read(void)
{
GLint nLinked=0;
#ifdef __GLEE_WGL_ARB_make_current_read
if ((GLeeFuncPtr_wglMakeContextCurrentARB = (GLEEPFNWGLMAKECONTEXTCURRENTARBPROC) __GLeeGetProcAddress("wglMakeContextCurrentARB"))!=0) nLinked++;
if ((GLeeFuncPtr_wglGetCurrentReadDCARB = (GLEEPFNWGLGETCURRENTREADDCARBPROC) __GLeeGetProcAddress("wglGetCurrentReadDCARB"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_WGL_ARB_pbuffer(void)
{
GLint nLinked=0;
#ifdef __GLEE_WGL_ARB_pbuffer
if ((GLeeFuncPtr_wglCreatePbufferARB = (GLEEPFNWGLCREATEPBUFFERARBPROC) __GLeeGetProcAddress("wglCreatePbufferARB"))!=0) nLinked++;
if ((GLeeFuncPtr_wglGetPbufferDCARB = (GLEEPFNWGLGETPBUFFERDCARBPROC) __GLeeGetProcAddress("wglGetPbufferDCARB"))!=0) nLinked++;
if ((GLeeFuncPtr_wglReleasePbufferDCARB = (GLEEPFNWGLRELEASEPBUFFERDCARBPROC) __GLeeGetProcAddress("wglReleasePbufferDCARB"))!=0) nLinked++;
if ((GLeeFuncPtr_wglDestroyPbufferARB = (GLEEPFNWGLDESTROYPBUFFERARBPROC) __GLeeGetProcAddress("wglDestroyPbufferARB"))!=0) nLinked++;
if ((GLeeFuncPtr_wglQueryPbufferARB = (GLEEPFNWGLQUERYPBUFFERARBPROC) __GLeeGetProcAddress("wglQueryPbufferARB"))!=0) nLinked++;
#endif
if (nLinked==5) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_WGL_ARB_render_texture(void)
{
GLint nLinked=0;
#ifdef __GLEE_WGL_ARB_render_texture
if ((GLeeFuncPtr_wglBindTexImageARB = (GLEEPFNWGLBINDTEXIMAGEARBPROC) __GLeeGetProcAddress("wglBindTexImageARB"))!=0) nLinked++;
if ((GLeeFuncPtr_wglReleaseTexImageARB = (GLEEPFNWGLRELEASETEXIMAGEARBPROC) __GLeeGetProcAddress("wglReleaseTexImageARB"))!=0) nLinked++;
if ((GLeeFuncPtr_wglSetPbufferAttribARB = (GLEEPFNWGLSETPBUFFERATTRIBARBPROC) __GLeeGetProcAddress("wglSetPbufferAttribARB"))!=0) nLinked++;
#endif
if (nLinked==3) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_WGL_ARB_pixel_format_float(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_WGL_ARB_create_context(void)
{
GLint nLinked=0;
#ifdef __GLEE_WGL_ARB_create_context
if ((GLeeFuncPtr_wglCreateContextAttribsARB = (GLEEPFNWGLCREATECONTEXTATTRIBSARBPROC) __GLeeGetProcAddress("wglCreateContextAttribsARB"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_WGL_EXT_make_current_read(void)
{
GLint nLinked=0;
#ifdef __GLEE_WGL_EXT_make_current_read
if ((GLeeFuncPtr_wglMakeContextCurrentEXT = (GLEEPFNWGLMAKECONTEXTCURRENTEXTPROC) __GLeeGetProcAddress("wglMakeContextCurrentEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_wglGetCurrentReadDCEXT = (GLEEPFNWGLGETCURRENTREADDCEXTPROC) __GLeeGetProcAddress("wglGetCurrentReadDCEXT"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_WGL_EXT_pixel_format(void)
{
GLint nLinked=0;
#ifdef __GLEE_WGL_EXT_pixel_format
if ((GLeeFuncPtr_wglGetPixelFormatAttribivEXT = (GLEEPFNWGLGETPIXELFORMATATTRIBIVEXTPROC) __GLeeGetProcAddress("wglGetPixelFormatAttribivEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_wglGetPixelFormatAttribfvEXT = (GLEEPFNWGLGETPIXELFORMATATTRIBFVEXTPROC) __GLeeGetProcAddress("wglGetPixelFormatAttribfvEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_wglChoosePixelFormatEXT = (GLEEPFNWGLCHOOSEPIXELFORMATEXTPROC) __GLeeGetProcAddress("wglChoosePixelFormatEXT"))!=0) nLinked++;
#endif
if (nLinked==3) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_WGL_EXT_pbuffer(void)
{
GLint nLinked=0;
#ifdef __GLEE_WGL_EXT_pbuffer
if ((GLeeFuncPtr_wglCreatePbufferEXT = (GLEEPFNWGLCREATEPBUFFEREXTPROC) __GLeeGetProcAddress("wglCreatePbufferEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_wglGetPbufferDCEXT = (GLEEPFNWGLGETPBUFFERDCEXTPROC) __GLeeGetProcAddress("wglGetPbufferDCEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_wglReleasePbufferDCEXT = (GLEEPFNWGLRELEASEPBUFFERDCEXTPROC) __GLeeGetProcAddress("wglReleasePbufferDCEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_wglDestroyPbufferEXT = (GLEEPFNWGLDESTROYPBUFFEREXTPROC) __GLeeGetProcAddress("wglDestroyPbufferEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_wglQueryPbufferEXT = (GLEEPFNWGLQUERYPBUFFEREXTPROC) __GLeeGetProcAddress("wglQueryPbufferEXT"))!=0) nLinked++;
#endif
if (nLinked==5) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_WGL_EXT_depth_float(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_WGL_3DFX_multisample(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_WGL_EXT_multisample(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_WGL_I3D_digital_video_control(void)
{
GLint nLinked=0;
#ifdef __GLEE_WGL_I3D_digital_video_control
if ((GLeeFuncPtr_wglGetDigitalVideoParametersI3D = (GLEEPFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC) __GLeeGetProcAddress("wglGetDigitalVideoParametersI3D"))!=0) nLinked++;
if ((GLeeFuncPtr_wglSetDigitalVideoParametersI3D = (GLEEPFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC) __GLeeGetProcAddress("wglSetDigitalVideoParametersI3D"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_WGL_I3D_gamma(void)
{
GLint nLinked=0;
#ifdef __GLEE_WGL_I3D_gamma
if ((GLeeFuncPtr_wglGetGammaTableParametersI3D = (GLEEPFNWGLGETGAMMATABLEPARAMETERSI3DPROC) __GLeeGetProcAddress("wglGetGammaTableParametersI3D"))!=0) nLinked++;
if ((GLeeFuncPtr_wglSetGammaTableParametersI3D = (GLEEPFNWGLSETGAMMATABLEPARAMETERSI3DPROC) __GLeeGetProcAddress("wglSetGammaTableParametersI3D"))!=0) nLinked++;
if ((GLeeFuncPtr_wglGetGammaTableI3D = (GLEEPFNWGLGETGAMMATABLEI3DPROC) __GLeeGetProcAddress("wglGetGammaTableI3D"))!=0) nLinked++;
if ((GLeeFuncPtr_wglSetGammaTableI3D = (GLEEPFNWGLSETGAMMATABLEI3DPROC) __GLeeGetProcAddress("wglSetGammaTableI3D"))!=0) nLinked++;
#endif
if (nLinked==4) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_WGL_I3D_genlock(void)
{
GLint nLinked=0;
#ifdef __GLEE_WGL_I3D_genlock
if ((GLeeFuncPtr_wglEnableGenlockI3D = (GLEEPFNWGLENABLEGENLOCKI3DPROC) __GLeeGetProcAddress("wglEnableGenlockI3D"))!=0) nLinked++;
if ((GLeeFuncPtr_wglDisableGenlockI3D = (GLEEPFNWGLDISABLEGENLOCKI3DPROC) __GLeeGetProcAddress("wglDisableGenlockI3D"))!=0) nLinked++;
if ((GLeeFuncPtr_wglIsEnabledGenlockI3D = (GLEEPFNWGLISENABLEDGENLOCKI3DPROC) __GLeeGetProcAddress("wglIsEnabledGenlockI3D"))!=0) nLinked++;
if ((GLeeFuncPtr_wglGenlockSourceI3D = (GLEEPFNWGLGENLOCKSOURCEI3DPROC) __GLeeGetProcAddress("wglGenlockSourceI3D"))!=0) nLinked++;
if ((GLeeFuncPtr_wglGetGenlockSourceI3D = (GLEEPFNWGLGETGENLOCKSOURCEI3DPROC) __GLeeGetProcAddress("wglGetGenlockSourceI3D"))!=0) nLinked++;
if ((GLeeFuncPtr_wglGenlockSourceEdgeI3D = (GLEEPFNWGLGENLOCKSOURCEEDGEI3DPROC) __GLeeGetProcAddress("wglGenlockSourceEdgeI3D"))!=0) nLinked++;
if ((GLeeFuncPtr_wglGetGenlockSourceEdgeI3D = (GLEEPFNWGLGETGENLOCKSOURCEEDGEI3DPROC) __GLeeGetProcAddress("wglGetGenlockSourceEdgeI3D"))!=0) nLinked++;
if ((GLeeFuncPtr_wglGenlockSampleRateI3D = (GLEEPFNWGLGENLOCKSAMPLERATEI3DPROC) __GLeeGetProcAddress("wglGenlockSampleRateI3D"))!=0) nLinked++;
if ((GLeeFuncPtr_wglGetGenlockSampleRateI3D = (GLEEPFNWGLGETGENLOCKSAMPLERATEI3DPROC) __GLeeGetProcAddress("wglGetGenlockSampleRateI3D"))!=0) nLinked++;
if ((GLeeFuncPtr_wglGenlockSourceDelayI3D = (GLEEPFNWGLGENLOCKSOURCEDELAYI3DPROC) __GLeeGetProcAddress("wglGenlockSourceDelayI3D"))!=0) nLinked++;
if ((GLeeFuncPtr_wglGetGenlockSourceDelayI3D = (GLEEPFNWGLGETGENLOCKSOURCEDELAYI3DPROC) __GLeeGetProcAddress("wglGetGenlockSourceDelayI3D"))!=0) nLinked++;
if ((GLeeFuncPtr_wglQueryGenlockMaxSourceDelayI3D = (GLEEPFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC) __GLeeGetProcAddress("wglQueryGenlockMaxSourceDelayI3D"))!=0) nLinked++;
#endif
if (nLinked==12) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_WGL_I3D_image_buffer(void)
{
GLint nLinked=0;
#ifdef __GLEE_WGL_I3D_image_buffer
if ((GLeeFuncPtr_wglCreateImageBufferI3D = (GLEEPFNWGLCREATEIMAGEBUFFERI3DPROC) __GLeeGetProcAddress("wglCreateImageBufferI3D"))!=0) nLinked++;
if ((GLeeFuncPtr_wglDestroyImageBufferI3D = (GLEEPFNWGLDESTROYIMAGEBUFFERI3DPROC) __GLeeGetProcAddress("wglDestroyImageBufferI3D"))!=0) nLinked++;
if ((GLeeFuncPtr_wglAssociateImageBufferEventsI3D = (GLEEPFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC) __GLeeGetProcAddress("wglAssociateImageBufferEventsI3D"))!=0) nLinked++;
if ((GLeeFuncPtr_wglReleaseImageBufferEventsI3D = (GLEEPFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC) __GLeeGetProcAddress("wglReleaseImageBufferEventsI3D"))!=0) nLinked++;
#endif
if (nLinked==4) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_WGL_I3D_swap_frame_lock(void)
{
GLint nLinked=0;
#ifdef __GLEE_WGL_I3D_swap_frame_lock
if ((GLeeFuncPtr_wglEnableFrameLockI3D = (GLEEPFNWGLENABLEFRAMELOCKI3DPROC) __GLeeGetProcAddress("wglEnableFrameLockI3D"))!=0) nLinked++;
if ((GLeeFuncPtr_wglDisableFrameLockI3D = (GLEEPFNWGLDISABLEFRAMELOCKI3DPROC) __GLeeGetProcAddress("wglDisableFrameLockI3D"))!=0) nLinked++;
if ((GLeeFuncPtr_wglIsEnabledFrameLockI3D = (GLEEPFNWGLISENABLEDFRAMELOCKI3DPROC) __GLeeGetProcAddress("wglIsEnabledFrameLockI3D"))!=0) nLinked++;
if ((GLeeFuncPtr_wglQueryFrameLockMasterI3D = (GLEEPFNWGLQUERYFRAMELOCKMASTERI3DPROC) __GLeeGetProcAddress("wglQueryFrameLockMasterI3D"))!=0) nLinked++;
#endif
if (nLinked==4) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_WGL_NV_render_depth_texture(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_WGL_NV_render_texture_rectangle(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_WGL_ATI_pixel_format_float(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_WGL_NV_float_buffer(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_WGL_3DL_stereo_control(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_WGL_EXT_pixel_format_packed_float(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_WGL_EXT_framebuffer_sRGB(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_WGL_NV_present_video(void)
{
GLint nLinked=0;
#ifdef __GLEE_WGL_NV_present_video
if ((GLeeFuncPtr_wglEnumerateVideoDevicesNV = (GLEEPFNWGLENUMERATEVIDEODEVICESNVPROC) __GLeeGetProcAddress("wglEnumerateVideoDevicesNV"))!=0) nLinked++;
if ((GLeeFuncPtr_wglBindVideoDeviceNV = (GLEEPFNWGLBINDVIDEODEVICENVPROC) __GLeeGetProcAddress("wglBindVideoDeviceNV"))!=0) nLinked++;
if ((GLeeFuncPtr_wglQueryCurrentContextNV = (GLEEPFNWGLQUERYCURRENTCONTEXTNVPROC) __GLeeGetProcAddress("wglQueryCurrentContextNV"))!=0) nLinked++;
#endif
if (nLinked==3) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_WGL_NV_swap_group(void)
{
GLint nLinked=0;
#ifdef __GLEE_WGL_NV_swap_group
if ((GLeeFuncPtr_wglJoinSwapGroupNV = (GLEEPFNWGLJOINSWAPGROUPNVPROC) __GLeeGetProcAddress("wglJoinSwapGroupNV"))!=0) nLinked++;
if ((GLeeFuncPtr_wglBindSwapBarrierNV = (GLEEPFNWGLBINDSWAPBARRIERNVPROC) __GLeeGetProcAddress("wglBindSwapBarrierNV"))!=0) nLinked++;
if ((GLeeFuncPtr_wglQuerySwapGroupNV = (GLEEPFNWGLQUERYSWAPGROUPNVPROC) __GLeeGetProcAddress("wglQuerySwapGroupNV"))!=0) nLinked++;
if ((GLeeFuncPtr_wglQueryMaxSwapGroupsNV = (GLEEPFNWGLQUERYMAXSWAPGROUPSNVPROC) __GLeeGetProcAddress("wglQueryMaxSwapGroupsNV"))!=0) nLinked++;
if ((GLeeFuncPtr_wglQueryFrameCountNV = (GLEEPFNWGLQUERYFRAMECOUNTNVPROC) __GLeeGetProcAddress("wglQueryFrameCountNV"))!=0) nLinked++;
if ((GLeeFuncPtr_wglResetFrameCountNV = (GLEEPFNWGLRESETFRAMECOUNTNVPROC) __GLeeGetProcAddress("wglResetFrameCountNV"))!=0) nLinked++;
#endif
if (nLinked==6) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_WGL_NV_gpu_affinity(void)
{
GLint nLinked=0;
#ifdef __GLEE_WGL_NV_gpu_affinity
if ((GLeeFuncPtr_wglEnumGpusNV = (GLEEPFNWGLENUMGPUSNVPROC) __GLeeGetProcAddress("wglEnumGpusNV"))!=0) nLinked++;
if ((GLeeFuncPtr_wglEnumGpuDevicesNV = (GLEEPFNWGLENUMGPUDEVICESNVPROC) __GLeeGetProcAddress("wglEnumGpuDevicesNV"))!=0) nLinked++;
if ((GLeeFuncPtr_wglCreateAffinityDCNV = (GLEEPFNWGLCREATEAFFINITYDCNVPROC) __GLeeGetProcAddress("wglCreateAffinityDCNV"))!=0) nLinked++;
if ((GLeeFuncPtr_wglEnumGpusFromAffinityDCNV = (GLEEPFNWGLENUMGPUSFROMAFFINITYDCNVPROC) __GLeeGetProcAddress("wglEnumGpusFromAffinityDCNV"))!=0) nLinked++;
if ((GLeeFuncPtr_wglDeleteDCNV = (GLEEPFNWGLDELETEDCNVPROC) __GLeeGetProcAddress("wglDeleteDCNV"))!=0) nLinked++;
#endif
if (nLinked==5) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_WGL_EXT_display_color_table(void)
{
GLint nLinked=0;
#ifdef __GLEE_WGL_EXT_display_color_table
if ((GLeeFuncPtr_wglCreateDisplayColorTableEXT = (GLEEPFNWGLCREATEDISPLAYCOLORTABLEEXTPROC) __GLeeGetProcAddress("wglCreateDisplayColorTableEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_wglLoadDisplayColorTableEXT = (GLEEPFNWGLLOADDISPLAYCOLORTABLEEXTPROC) __GLeeGetProcAddress("wglLoadDisplayColorTableEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_wglBindDisplayColorTableEXT = (GLEEPFNWGLBINDDISPLAYCOLORTABLEEXTPROC) __GLeeGetProcAddress("wglBindDisplayColorTableEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_wglDestroyDisplayColorTableEXT = (GLEEPFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC) __GLeeGetProcAddress("wglDestroyDisplayColorTableEXT"))!=0) nLinked++;
#endif
if (nLinked==4) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_WGL_EXT_extensions_string(void)
{
GLint nLinked=0;
#ifdef __GLEE_WGL_EXT_extensions_string
if ((GLeeFuncPtr_wglGetExtensionsStringEXT = (GLEEPFNWGLGETEXTENSIONSSTRINGEXTPROC) __GLeeGetProcAddress("wglGetExtensionsStringEXT"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_WGL_EXT_swap_control(void)
{
GLint nLinked=0;
#ifdef __GLEE_WGL_EXT_swap_control
if ((GLeeFuncPtr_wglSwapIntervalEXT = (GLEEPFNWGLSWAPINTERVALEXTPROC) __GLeeGetProcAddress("wglSwapIntervalEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_wglGetSwapIntervalEXT = (GLEEPFNWGLGETSWAPINTERVALEXTPROC) __GLeeGetProcAddress("wglGetSwapIntervalEXT"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_WGL_NV_vertex_array_range(void)
{
GLint nLinked=0;
#ifdef __GLEE_WGL_NV_vertex_array_range
if ((GLeeFuncPtr_wglAllocateMemoryNV = (GLEEPFNWGLALLOCATEMEMORYNVPROC) __GLeeGetProcAddress("wglAllocateMemoryNV"))!=0) nLinked++;
if ((GLeeFuncPtr_wglFreeMemoryNV = (GLEEPFNWGLFREEMEMORYNVPROC) __GLeeGetProcAddress("wglFreeMemoryNV"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_WGL_OML_sync_control(void)
{
GLint nLinked=0;
#ifdef __GLEE_WGL_OML_sync_control
if ((GLeeFuncPtr_wglGetSyncValuesOML = (GLEEPFNWGLGETSYNCVALUESOMLPROC) __GLeeGetProcAddress("wglGetSyncValuesOML"))!=0) nLinked++;
if ((GLeeFuncPtr_wglGetMscRateOML = (GLEEPFNWGLGETMSCRATEOMLPROC) __GLeeGetProcAddress("wglGetMscRateOML"))!=0) nLinked++;
if ((GLeeFuncPtr_wglSwapBuffersMscOML = (GLEEPFNWGLSWAPBUFFERSMSCOMLPROC) __GLeeGetProcAddress("wglSwapBuffersMscOML"))!=0) nLinked++;
if ((GLeeFuncPtr_wglSwapLayerBuffersMscOML = (GLEEPFNWGLSWAPLAYERBUFFERSMSCOMLPROC) __GLeeGetProcAddress("wglSwapLayerBuffersMscOML"))!=0) nLinked++;
if ((GLeeFuncPtr_wglWaitForMscOML = (GLEEPFNWGLWAITFORMSCOMLPROC) __GLeeGetProcAddress("wglWaitForMscOML"))!=0) nLinked++;
if ((GLeeFuncPtr_wglWaitForSbcOML = (GLEEPFNWGLWAITFORSBCOMLPROC) __GLeeGetProcAddress("wglWaitForSbcOML"))!=0) nLinked++;
#endif
if (nLinked==6) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_WGL_I3D_swap_frame_usage(void)
{
GLint nLinked=0;
#ifdef __GLEE_WGL_I3D_swap_frame_usage
if ((GLeeFuncPtr_wglGetFrameUsageI3D = (GLEEPFNWGLGETFRAMEUSAGEI3DPROC) __GLeeGetProcAddress("wglGetFrameUsageI3D"))!=0) nLinked++;
if ((GLeeFuncPtr_wglBeginFrameTrackingI3D = (GLEEPFNWGLBEGINFRAMETRACKINGI3DPROC) __GLeeGetProcAddress("wglBeginFrameTrackingI3D"))!=0) nLinked++;
if ((GLeeFuncPtr_wglEndFrameTrackingI3D = (GLEEPFNWGLENDFRAMETRACKINGI3DPROC) __GLeeGetProcAddress("wglEndFrameTrackingI3D"))!=0) nLinked++;
if ((GLeeFuncPtr_wglQueryFrameTrackingI3D = (GLEEPFNWGLQUERYFRAMETRACKINGI3DPROC) __GLeeGetProcAddress("wglQueryFrameTrackingI3D"))!=0) nLinked++;
#endif
if (nLinked==4) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_WGL_NV_video_output(void)
{
GLint nLinked=0;
#ifdef __GLEE_WGL_NV_video_output
if ((GLeeFuncPtr_wglGetVideoDeviceNV = (GLEEPFNWGLGETVIDEODEVICENVPROC) __GLeeGetProcAddress("wglGetVideoDeviceNV"))!=0) nLinked++;
if ((GLeeFuncPtr_wglReleaseVideoDeviceNV = (GLEEPFNWGLRELEASEVIDEODEVICENVPROC) __GLeeGetProcAddress("wglReleaseVideoDeviceNV"))!=0) nLinked++;
if ((GLeeFuncPtr_wglBindVideoImageNV = (GLEEPFNWGLBINDVIDEOIMAGENVPROC) __GLeeGetProcAddress("wglBindVideoImageNV"))!=0) nLinked++;
if ((GLeeFuncPtr_wglReleaseVideoImageNV = (GLEEPFNWGLRELEASEVIDEOIMAGENVPROC) __GLeeGetProcAddress("wglReleaseVideoImageNV"))!=0) nLinked++;
if ((GLeeFuncPtr_wglSendPbufferToVideoNV = (GLEEPFNWGLSENDPBUFFERTOVIDEONVPROC) __GLeeGetProcAddress("wglSendPbufferToVideoNV"))!=0) nLinked++;
if ((GLeeFuncPtr_wglGetVideoInfoNV = (GLEEPFNWGLGETVIDEOINFONVPROC) __GLeeGetProcAddress("wglGetVideoInfoNV"))!=0) nLinked++;
#endif
if (nLinked==6) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLEE_LINK_FUNCTION __GLeeWGLLoadFunction[37];
void initWGLLoadFunctions(void)
{
__GLeeWGLLoadFunction[0]=__GLeeLink_WGL_ARB_buffer_region;
__GLeeWGLLoadFunction[1]=__GLeeLink_WGL_ARB_multisample;
__GLeeWGLLoadFunction[2]=__GLeeLink_WGL_ARB_extensions_string;
__GLeeWGLLoadFunction[3]=__GLeeLink_WGL_ARB_pixel_format;
__GLeeWGLLoadFunction[4]=__GLeeLink_WGL_ARB_make_current_read;
__GLeeWGLLoadFunction[5]=__GLeeLink_WGL_ARB_pbuffer;
__GLeeWGLLoadFunction[6]=__GLeeLink_WGL_ARB_render_texture;
__GLeeWGLLoadFunction[7]=__GLeeLink_WGL_ARB_pixel_format_float;
__GLeeWGLLoadFunction[8]=__GLeeLink_WGL_ARB_create_context;
__GLeeWGLLoadFunction[9]=__GLeeLink_WGL_EXT_make_current_read;
__GLeeWGLLoadFunction[10]=__GLeeLink_WGL_EXT_pixel_format;
__GLeeWGLLoadFunction[11]=__GLeeLink_WGL_EXT_pbuffer;
__GLeeWGLLoadFunction[12]=__GLeeLink_WGL_EXT_depth_float;
__GLeeWGLLoadFunction[13]=__GLeeLink_WGL_3DFX_multisample;
__GLeeWGLLoadFunction[14]=__GLeeLink_WGL_EXT_multisample;
__GLeeWGLLoadFunction[15]=__GLeeLink_WGL_I3D_digital_video_control;
__GLeeWGLLoadFunction[16]=__GLeeLink_WGL_I3D_gamma;
__GLeeWGLLoadFunction[17]=__GLeeLink_WGL_I3D_genlock;
__GLeeWGLLoadFunction[18]=__GLeeLink_WGL_I3D_image_buffer;
__GLeeWGLLoadFunction[19]=__GLeeLink_WGL_I3D_swap_frame_lock;
__GLeeWGLLoadFunction[20]=__GLeeLink_WGL_NV_render_depth_texture;
__GLeeWGLLoadFunction[21]=__GLeeLink_WGL_NV_render_texture_rectangle;
__GLeeWGLLoadFunction[22]=__GLeeLink_WGL_ATI_pixel_format_float;
__GLeeWGLLoadFunction[23]=__GLeeLink_WGL_NV_float_buffer;
__GLeeWGLLoadFunction[24]=__GLeeLink_WGL_3DL_stereo_control;
__GLeeWGLLoadFunction[25]=__GLeeLink_WGL_EXT_pixel_format_packed_float;
__GLeeWGLLoadFunction[26]=__GLeeLink_WGL_EXT_framebuffer_sRGB;
__GLeeWGLLoadFunction[27]=__GLeeLink_WGL_NV_present_video;
__GLeeWGLLoadFunction[28]=__GLeeLink_WGL_NV_swap_group;
__GLeeWGLLoadFunction[29]=__GLeeLink_WGL_NV_gpu_affinity;
__GLeeWGLLoadFunction[30]=__GLeeLink_WGL_EXT_display_color_table;
__GLeeWGLLoadFunction[31]=__GLeeLink_WGL_EXT_extensions_string;
__GLeeWGLLoadFunction[32]=__GLeeLink_WGL_EXT_swap_control;
__GLeeWGLLoadFunction[33]=__GLeeLink_WGL_NV_vertex_array_range;
__GLeeWGLLoadFunction[34]=__GLeeLink_WGL_OML_sync_control;
__GLeeWGLLoadFunction[35]=__GLeeLink_WGL_I3D_swap_frame_usage;
__GLeeWGLLoadFunction[36]=__GLeeLink_WGL_NV_video_output;
}
#elif defined(__APPLE__) || defined(__APPLE_CC__)
#else /* Linux */
GLuint __GLeeLink_GLX_VERSION_1_3(void)
{
GLint nLinked=0;
#ifdef __GLEE_GLX_VERSION_1_3
if ((GLeeFuncPtr_glXGetFBConfigs = (GLEEPFNGLXGETFBCONFIGSPROC) __GLeeGetProcAddress("glXGetFBConfigs"))!=0) nLinked++;
if ((GLeeFuncPtr_glXChooseFBConfig = (GLEEPFNGLXCHOOSEFBCONFIGPROC) __GLeeGetProcAddress("glXChooseFBConfig"))!=0) nLinked++;
if ((GLeeFuncPtr_glXGetFBConfigAttrib = (GLEEPFNGLXGETFBCONFIGATTRIBPROC) __GLeeGetProcAddress("glXGetFBConfigAttrib"))!=0) nLinked++;
if ((GLeeFuncPtr_glXGetVisualFromFBConfig = (GLEEPFNGLXGETVISUALFROMFBCONFIGPROC) __GLeeGetProcAddress("glXGetVisualFromFBConfig"))!=0) nLinked++;
if ((GLeeFuncPtr_glXCreateWindow = (GLEEPFNGLXCREATEWINDOWPROC) __GLeeGetProcAddress("glXCreateWindow"))!=0) nLinked++;
if ((GLeeFuncPtr_glXDestroyWindow = (GLEEPFNGLXDESTROYWINDOWPROC) __GLeeGetProcAddress("glXDestroyWindow"))!=0) nLinked++;
if ((GLeeFuncPtr_glXCreatePixmap = (GLEEPFNGLXCREATEPIXMAPPROC) __GLeeGetProcAddress("glXCreatePixmap"))!=0) nLinked++;
if ((GLeeFuncPtr_glXDestroyPixmap = (GLEEPFNGLXDESTROYPIXMAPPROC) __GLeeGetProcAddress("glXDestroyPixmap"))!=0) nLinked++;
if ((GLeeFuncPtr_glXCreatePbuffer = (GLEEPFNGLXCREATEPBUFFERPROC) __GLeeGetProcAddress("glXCreatePbuffer"))!=0) nLinked++;
if ((GLeeFuncPtr_glXDestroyPbuffer = (GLEEPFNGLXDESTROYPBUFFERPROC) __GLeeGetProcAddress("glXDestroyPbuffer"))!=0) nLinked++;
if ((GLeeFuncPtr_glXQueryDrawable = (GLEEPFNGLXQUERYDRAWABLEPROC) __GLeeGetProcAddress("glXQueryDrawable"))!=0) nLinked++;
if ((GLeeFuncPtr_glXCreateNewContext = (GLEEPFNGLXCREATENEWCONTEXTPROC) __GLeeGetProcAddress("glXCreateNewContext"))!=0) nLinked++;
if ((GLeeFuncPtr_glXMakeContextCurrent = (GLEEPFNGLXMAKECONTEXTCURRENTPROC) __GLeeGetProcAddress("glXMakeContextCurrent"))!=0) nLinked++;
if ((GLeeFuncPtr_glXGetCurrentReadDrawable = (GLEEPFNGLXGETCURRENTREADDRAWABLEPROC) __GLeeGetProcAddress("glXGetCurrentReadDrawable"))!=0) nLinked++;
if ((GLeeFuncPtr_glXGetCurrentDisplay = (GLEEPFNGLXGETCURRENTDISPLAYPROC) __GLeeGetProcAddress("glXGetCurrentDisplay"))!=0) nLinked++;
if ((GLeeFuncPtr_glXQueryContext = (GLEEPFNGLXQUERYCONTEXTPROC) __GLeeGetProcAddress("glXQueryContext"))!=0) nLinked++;
if ((GLeeFuncPtr_glXSelectEvent = (GLEEPFNGLXSELECTEVENTPROC) __GLeeGetProcAddress("glXSelectEvent"))!=0) nLinked++;
if ((GLeeFuncPtr_glXGetSelectedEvent = (GLEEPFNGLXGETSELECTEDEVENTPROC) __GLeeGetProcAddress("glXGetSelectedEvent"))!=0) nLinked++;
#endif
if (nLinked==18) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GLX_VERSION_1_4(void)
{
GLint nLinked=0;
#ifdef __GLEE_GLX_VERSION_1_4
if ((GLeeFuncPtr_glXGetProcAddress = (GLEEPFNGLXGETPROCADDRESSPROC) __GLeeGetProcAddress("glXGetProcAddress"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GLX_ARB_multisample(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GLX_ARB_fbconfig_float(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GLX_ARB_create_context(void)
{
GLint nLinked=0;
#ifdef __GLEE_GLX_ARB_create_context
if ((GLeeFuncPtr_glXCreateContextAttribsARB = (GLEEPFNGLXCREATECONTEXTATTRIBSARBPROC) __GLeeGetProcAddress("glXCreateContextAttribsARB"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GLX_SGIS_multisample(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GLX_EXT_visual_info(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GLX_SGI_swap_control(void)
{
GLint nLinked=0;
#ifdef __GLEE_GLX_SGI_swap_control
if ((GLeeFuncPtr_glXSwapIntervalSGI = (GLEEPFNGLXSWAPINTERVALSGIPROC) __GLeeGetProcAddress("glXSwapIntervalSGI"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GLX_SGI_video_sync(void)
{
GLint nLinked=0;
#ifdef __GLEE_GLX_SGI_video_sync
if ((GLeeFuncPtr_glXGetVideoSyncSGI = (GLEEPFNGLXGETVIDEOSYNCSGIPROC) __GLeeGetProcAddress("glXGetVideoSyncSGI"))!=0) nLinked++;
if ((GLeeFuncPtr_glXWaitVideoSyncSGI = (GLEEPFNGLXWAITVIDEOSYNCSGIPROC) __GLeeGetProcAddress("glXWaitVideoSyncSGI"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GLX_SGI_make_current_read(void)
{
GLint nLinked=0;
#ifdef __GLEE_GLX_SGI_make_current_read
if ((GLeeFuncPtr_glXMakeCurrentReadSGI = (GLEEPFNGLXMAKECURRENTREADSGIPROC) __GLeeGetProcAddress("glXMakeCurrentReadSGI"))!=0) nLinked++;
if ((GLeeFuncPtr_glXGetCurrentReadDrawableSGI = (GLEEPFNGLXGETCURRENTREADDRAWABLESGIPROC) __GLeeGetProcAddress("glXGetCurrentReadDrawableSGI"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GLX_EXT_visual_rating(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GLX_EXT_import_context(void)
{
GLint nLinked=0;
#ifdef __GLEE_GLX_EXT_import_context
if ((GLeeFuncPtr_glXGetCurrentDisplayEXT = (GLEEPFNGLXGETCURRENTDISPLAYEXTPROC) __GLeeGetProcAddress("glXGetCurrentDisplayEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glXQueryContextInfoEXT = (GLEEPFNGLXQUERYCONTEXTINFOEXTPROC) __GLeeGetProcAddress("glXQueryContextInfoEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glXGetContextIDEXT = (GLEEPFNGLXGETCONTEXTIDEXTPROC) __GLeeGetProcAddress("glXGetContextIDEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glXImportContextEXT = (GLEEPFNGLXIMPORTCONTEXTEXTPROC) __GLeeGetProcAddress("glXImportContextEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glXFreeContextEXT = (GLEEPFNGLXFREECONTEXTEXTPROC) __GLeeGetProcAddress("glXFreeContextEXT"))!=0) nLinked++;
#endif
if (nLinked==5) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GLX_SGIX_fbconfig(void)
{
GLint nLinked=0;
#ifdef __GLEE_GLX_SGIX_fbconfig
if ((GLeeFuncPtr_glXGetFBConfigAttribSGIX = (GLEEPFNGLXGETFBCONFIGATTRIBSGIXPROC) __GLeeGetProcAddress("glXGetFBConfigAttribSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glXChooseFBConfigSGIX = (GLEEPFNGLXCHOOSEFBCONFIGSGIXPROC) __GLeeGetProcAddress("glXChooseFBConfigSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glXCreateGLXPixmapWithConfigSGIX = (GLEEPFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC) __GLeeGetProcAddress("glXCreateGLXPixmapWithConfigSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glXCreateContextWithConfigSGIX = (GLEEPFNGLXCREATECONTEXTWITHCONFIGSGIXPROC) __GLeeGetProcAddress("glXCreateContextWithConfigSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glXGetVisualFromFBConfigSGIX = (GLEEPFNGLXGETVISUALFROMFBCONFIGSGIXPROC) __GLeeGetProcAddress("glXGetVisualFromFBConfigSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glXGetFBConfigFromVisualSGIX = (GLEEPFNGLXGETFBCONFIGFROMVISUALSGIXPROC) __GLeeGetProcAddress("glXGetFBConfigFromVisualSGIX"))!=0) nLinked++;
#endif
if (nLinked==6) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GLX_SGIX_pbuffer(void)
{
GLint nLinked=0;
#ifdef __GLEE_GLX_SGIX_pbuffer
if ((GLeeFuncPtr_glXCreateGLXPbufferSGIX = (GLEEPFNGLXCREATEGLXPBUFFERSGIXPROC) __GLeeGetProcAddress("glXCreateGLXPbufferSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glXDestroyGLXPbufferSGIX = (GLEEPFNGLXDESTROYGLXPBUFFERSGIXPROC) __GLeeGetProcAddress("glXDestroyGLXPbufferSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glXQueryGLXPbufferSGIX = (GLEEPFNGLXQUERYGLXPBUFFERSGIXPROC) __GLeeGetProcAddress("glXQueryGLXPbufferSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glXSelectEventSGIX = (GLEEPFNGLXSELECTEVENTSGIXPROC) __GLeeGetProcAddress("glXSelectEventSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glXGetSelectedEventSGIX = (GLEEPFNGLXGETSELECTEDEVENTSGIXPROC) __GLeeGetProcAddress("glXGetSelectedEventSGIX"))!=0) nLinked++;
#endif
if (nLinked==5) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GLX_SGI_cushion(void)
{
GLint nLinked=0;
#ifdef __GLEE_GLX_SGI_cushion
if ((GLeeFuncPtr_glXCushionSGI = (GLEEPFNGLXCUSHIONSGIPROC) __GLeeGetProcAddress("glXCushionSGI"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GLX_SGIX_video_resize(void)
{
GLint nLinked=0;
#ifdef __GLEE_GLX_SGIX_video_resize
if ((GLeeFuncPtr_glXBindChannelToWindowSGIX = (GLEEPFNGLXBINDCHANNELTOWINDOWSGIXPROC) __GLeeGetProcAddress("glXBindChannelToWindowSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glXChannelRectSGIX = (GLEEPFNGLXCHANNELRECTSGIXPROC) __GLeeGetProcAddress("glXChannelRectSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glXQueryChannelRectSGIX = (GLEEPFNGLXQUERYCHANNELRECTSGIXPROC) __GLeeGetProcAddress("glXQueryChannelRectSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glXQueryChannelDeltasSGIX = (GLEEPFNGLXQUERYCHANNELDELTASSGIXPROC) __GLeeGetProcAddress("glXQueryChannelDeltasSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glXChannelRectSyncSGIX = (GLEEPFNGLXCHANNELRECTSYNCSGIXPROC) __GLeeGetProcAddress("glXChannelRectSyncSGIX"))!=0) nLinked++;
#endif
if (nLinked==5) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GLX_SGIX_swap_group(void)
{
GLint nLinked=0;
#ifdef __GLEE_GLX_SGIX_swap_group
if ((GLeeFuncPtr_glXJoinSwapGroupSGIX = (GLEEPFNGLXJOINSWAPGROUPSGIXPROC) __GLeeGetProcAddress("glXJoinSwapGroupSGIX"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GLX_SGIX_swap_barrier(void)
{
GLint nLinked=0;
#ifdef __GLEE_GLX_SGIX_swap_barrier
if ((GLeeFuncPtr_glXBindSwapBarrierSGIX = (GLEEPFNGLXBINDSWAPBARRIERSGIXPROC) __GLeeGetProcAddress("glXBindSwapBarrierSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glXQueryMaxSwapBarriersSGIX = (GLEEPFNGLXQUERYMAXSWAPBARRIERSSGIXPROC) __GLeeGetProcAddress("glXQueryMaxSwapBarriersSGIX"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GLX_SGIS_blended_overlay(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GLX_SGIS_shared_multisample(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GLX_SUN_get_transparent_index(void)
{
GLint nLinked=0;
#ifdef __GLEE_GLX_SUN_get_transparent_index
if ((GLeeFuncPtr_glXGetTransparentIndexSUN = (GLEEPFNGLXGETTRANSPARENTINDEXSUNPROC) __GLeeGetProcAddress("glXGetTransparentIndexSUN"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GLX_3DFX_multisample(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GLX_MESA_copy_sub_buffer(void)
{
GLint nLinked=0;
#ifdef __GLEE_GLX_MESA_copy_sub_buffer
if ((GLeeFuncPtr_glXCopySubBufferMESA = (GLEEPFNGLXCOPYSUBBUFFERMESAPROC) __GLeeGetProcAddress("glXCopySubBufferMESA"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GLX_MESA_pixmap_colormap(void)
{
GLint nLinked=0;
#ifdef __GLEE_GLX_MESA_pixmap_colormap
if ((GLeeFuncPtr_glXCreateGLXPixmapMESA = (GLEEPFNGLXCREATEGLXPIXMAPMESAPROC) __GLeeGetProcAddress("glXCreateGLXPixmapMESA"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GLX_MESA_release_buffers(void)
{
GLint nLinked=0;
#ifdef __GLEE_GLX_MESA_release_buffers
if ((GLeeFuncPtr_glXReleaseBuffersMESA = (GLEEPFNGLXRELEASEBUFFERSMESAPROC) __GLeeGetProcAddress("glXReleaseBuffersMESA"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GLX_MESA_set_3dfx_mode(void)
{
GLint nLinked=0;
#ifdef __GLEE_GLX_MESA_set_3dfx_mode
if ((GLeeFuncPtr_glXSet3DfxModeMESA = (GLEEPFNGLXSET3DFXMODEMESAPROC) __GLeeGetProcAddress("glXSet3DfxModeMESA"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GLX_SGIX_visual_select_group(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GLX_OML_swap_method(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GLX_OML_sync_control(void)
{
GLint nLinked=0;
#ifdef __GLEE_GLX_OML_sync_control
if ((GLeeFuncPtr_glXGetSyncValuesOML = (GLEEPFNGLXGETSYNCVALUESOMLPROC) __GLeeGetProcAddress("glXGetSyncValuesOML"))!=0) nLinked++;
if ((GLeeFuncPtr_glXGetMscRateOML = (GLEEPFNGLXGETMSCRATEOMLPROC) __GLeeGetProcAddress("glXGetMscRateOML"))!=0) nLinked++;
if ((GLeeFuncPtr_glXSwapBuffersMscOML = (GLEEPFNGLXSWAPBUFFERSMSCOMLPROC) __GLeeGetProcAddress("glXSwapBuffersMscOML"))!=0) nLinked++;
if ((GLeeFuncPtr_glXWaitForMscOML = (GLEEPFNGLXWAITFORMSCOMLPROC) __GLeeGetProcAddress("glXWaitForMscOML"))!=0) nLinked++;
if ((GLeeFuncPtr_glXWaitForSbcOML = (GLEEPFNGLXWAITFORSBCOMLPROC) __GLeeGetProcAddress("glXWaitForSbcOML"))!=0) nLinked++;
#endif
if (nLinked==5) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GLX_NV_float_buffer(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GLX_SGIX_hyperpipe(void)
{
GLint nLinked=0;
#ifdef __GLEE_GLX_SGIX_hyperpipe
if ((GLeeFuncPtr_glXQueryHyperpipeNetworkSGIX = (GLEEPFNGLXQUERYHYPERPIPENETWORKSGIXPROC) __GLeeGetProcAddress("glXQueryHyperpipeNetworkSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glXHyperpipeConfigSGIX = (GLEEPFNGLXHYPERPIPECONFIGSGIXPROC) __GLeeGetProcAddress("glXHyperpipeConfigSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glXQueryHyperpipeConfigSGIX = (GLEEPFNGLXQUERYHYPERPIPECONFIGSGIXPROC) __GLeeGetProcAddress("glXQueryHyperpipeConfigSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glXDestroyHyperpipeConfigSGIX = (GLEEPFNGLXDESTROYHYPERPIPECONFIGSGIXPROC) __GLeeGetProcAddress("glXDestroyHyperpipeConfigSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glXBindHyperpipeSGIX = (GLEEPFNGLXBINDHYPERPIPESGIXPROC) __GLeeGetProcAddress("glXBindHyperpipeSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glXQueryHyperpipeBestAttribSGIX = (GLEEPFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC) __GLeeGetProcAddress("glXQueryHyperpipeBestAttribSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glXHyperpipeAttribSGIX = (GLEEPFNGLXHYPERPIPEATTRIBSGIXPROC) __GLeeGetProcAddress("glXHyperpipeAttribSGIX"))!=0) nLinked++;
if ((GLeeFuncPtr_glXQueryHyperpipeAttribSGIX = (GLEEPFNGLXQUERYHYPERPIPEATTRIBSGIXPROC) __GLeeGetProcAddress("glXQueryHyperpipeAttribSGIX"))!=0) nLinked++;
#endif
if (nLinked==8) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GLX_MESA_agp_offset(void)
{
GLint nLinked=0;
#ifdef __GLEE_GLX_MESA_agp_offset
if ((GLeeFuncPtr_glXGetAGPOffsetMESA = (GLEEPFNGLXGETAGPOFFSETMESAPROC) __GLeeGetProcAddress("glXGetAGPOffsetMESA"))!=0) nLinked++;
#endif
if (nLinked==1) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GLX_EXT_fbconfig_packed_float(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GLX_EXT_framebuffer_sRGB(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GLX_EXT_texture_from_pixmap(void)
{
GLint nLinked=0;
#ifdef __GLEE_GLX_EXT_texture_from_pixmap
if ((GLeeFuncPtr_glXBindTexImageEXT = (GLEEPFNGLXBINDTEXIMAGEEXTPROC) __GLeeGetProcAddress("glXBindTexImageEXT"))!=0) nLinked++;
if ((GLeeFuncPtr_glXReleaseTexImageEXT = (GLEEPFNGLXRELEASETEXIMAGEEXTPROC) __GLeeGetProcAddress("glXReleaseTexImageEXT"))!=0) nLinked++;
#endif
if (nLinked==2) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLuint __GLeeLink_GLX_NV_present_video(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GLX_NV_video_out(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GLX_NV_swap_group(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GLX_EXT_scene_marker(void) {return GLEE_LINK_COMPLETE;}
GLuint __GLeeLink_GLX_NV_video_output(void)
{
GLint nLinked=0;
#ifdef __GLEE_GLX_NV_video_output
if ((GLeeFuncPtr_glXGetVideoDeviceNV = (GLEEPFNGLXGETVIDEODEVICENVPROC) __GLeeGetProcAddress("glXGetVideoDeviceNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glXReleaseVideoDeviceNV = (GLEEPFNGLXRELEASEVIDEODEVICENVPROC) __GLeeGetProcAddress("glXReleaseVideoDeviceNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glXBindVideoImageNV = (GLEEPFNGLXBINDVIDEOIMAGENVPROC) __GLeeGetProcAddress("glXBindVideoImageNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glXReleaseVideoImageNV = (GLEEPFNGLXRELEASEVIDEOIMAGENVPROC) __GLeeGetProcAddress("glXReleaseVideoImageNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glXSendPbufferToVideoNV = (GLEEPFNGLXSENDPBUFFERTOVIDEONVPROC) __GLeeGetProcAddress("glXSendPbufferToVideoNV"))!=0) nLinked++;
if ((GLeeFuncPtr_glXGetVideoInfoNV = (GLEEPFNGLXGETVIDEOINFONVPROC) __GLeeGetProcAddress("glXGetVideoInfoNV"))!=0) nLinked++;
#endif
if (nLinked==6) return GLEE_LINK_COMPLETE;
if (nLinked==0) return GLEE_LINK_FAIL;
return GLEE_LINK_PARTIAL;
}
GLEE_LINK_FUNCTION __GLeeGLXLoadFunction[40];
void initGLXLoadFunctions(void)
{
__GLeeGLXLoadFunction[0]=__GLeeLink_GLX_VERSION_1_3;
__GLeeGLXLoadFunction[1]=__GLeeLink_GLX_VERSION_1_4;
__GLeeGLXLoadFunction[2]=__GLeeLink_GLX_ARB_multisample;
__GLeeGLXLoadFunction[3]=__GLeeLink_GLX_ARB_fbconfig_float;
__GLeeGLXLoadFunction[4]=__GLeeLink_GLX_ARB_create_context;
__GLeeGLXLoadFunction[5]=__GLeeLink_GLX_SGIS_multisample;
__GLeeGLXLoadFunction[6]=__GLeeLink_GLX_EXT_visual_info;
__GLeeGLXLoadFunction[7]=__GLeeLink_GLX_SGI_swap_control;
__GLeeGLXLoadFunction[8]=__GLeeLink_GLX_SGI_video_sync;
__GLeeGLXLoadFunction[9]=__GLeeLink_GLX_SGI_make_current_read;
__GLeeGLXLoadFunction[10]=__GLeeLink_GLX_EXT_visual_rating;
__GLeeGLXLoadFunction[11]=__GLeeLink_GLX_EXT_import_context;
__GLeeGLXLoadFunction[12]=__GLeeLink_GLX_SGIX_fbconfig;
__GLeeGLXLoadFunction[13]=__GLeeLink_GLX_SGIX_pbuffer;
__GLeeGLXLoadFunction[14]=__GLeeLink_GLX_SGI_cushion;
__GLeeGLXLoadFunction[15]=__GLeeLink_GLX_SGIX_video_resize;
__GLeeGLXLoadFunction[16]=__GLeeLink_GLX_SGIX_swap_group;
__GLeeGLXLoadFunction[17]=__GLeeLink_GLX_SGIX_swap_barrier;
__GLeeGLXLoadFunction[18]=__GLeeLink_GLX_SGIS_blended_overlay;
__GLeeGLXLoadFunction[19]=__GLeeLink_GLX_SGIS_shared_multisample;
__GLeeGLXLoadFunction[20]=__GLeeLink_GLX_SUN_get_transparent_index;
__GLeeGLXLoadFunction[21]=__GLeeLink_GLX_3DFX_multisample;
__GLeeGLXLoadFunction[22]=__GLeeLink_GLX_MESA_copy_sub_buffer;
__GLeeGLXLoadFunction[23]=__GLeeLink_GLX_MESA_pixmap_colormap;
__GLeeGLXLoadFunction[24]=__GLeeLink_GLX_MESA_release_buffers;
__GLeeGLXLoadFunction[25]=__GLeeLink_GLX_MESA_set_3dfx_mode;
__GLeeGLXLoadFunction[26]=__GLeeLink_GLX_SGIX_visual_select_group;
__GLeeGLXLoadFunction[27]=__GLeeLink_GLX_OML_swap_method;
__GLeeGLXLoadFunction[28]=__GLeeLink_GLX_OML_sync_control;
__GLeeGLXLoadFunction[29]=__GLeeLink_GLX_NV_float_buffer;
__GLeeGLXLoadFunction[30]=__GLeeLink_GLX_SGIX_hyperpipe;
__GLeeGLXLoadFunction[31]=__GLeeLink_GLX_MESA_agp_offset;
__GLeeGLXLoadFunction[32]=__GLeeLink_GLX_EXT_fbconfig_packed_float;
__GLeeGLXLoadFunction[33]=__GLeeLink_GLX_EXT_framebuffer_sRGB;
__GLeeGLXLoadFunction[34]=__GLeeLink_GLX_EXT_texture_from_pixmap;
__GLeeGLXLoadFunction[35]=__GLeeLink_GLX_NV_present_video;
__GLeeGLXLoadFunction[36]=__GLeeLink_GLX_NV_video_out;
__GLeeGLXLoadFunction[37]=__GLeeLink_GLX_NV_swap_group;
__GLeeGLXLoadFunction[38]=__GLeeLink_GLX_EXT_scene_marker;
__GLeeGLXLoadFunction[39]=__GLeeLink_GLX_NV_video_output;
}
#endif /* end Linux */
/*****************************************************************
* GLee internal types
*****************************************************************/
typedef struct
{
char ** names;
int * lengths;
int numNames;
}ExtensionList;
/*****************************************************************
* GLee internal variables
*****************************************************************/
char GLeeErrorString[256]="";
/*****************************************************************
* GLee internal functions
*****************************************************************/
void __GLeeExtList_init(ExtensionList *extList)
{
extList->names=0;
extList->lengths=0;
extList->numNames=0;
}
void __GLeeExtList_clean(ExtensionList *extList)
{
int a;
for (a=0;a<extList->numNames;a++)
{
if (extList->names[a]!=0) free((void *)extList->names[a]);
}
if (extList->names!=0) free((void *)extList->names);
if (extList->lengths!=0) free((void *)extList->lengths);
extList->names=0;
extList->lengths=0;
extList->numNames=0;
}
void __GLeeExtList_add(ExtensionList *extList, const char * extName)
{
int length=strlen(extName)+1;
int i=extList->numNames;
int n=i+1;
if (i==0)
{
extList->lengths=(int *)malloc(sizeof(int));
extList->names=(char **)malloc(sizeof(char *));
}else
{
extList->lengths=(int *)realloc((void *)extList->lengths, n*sizeof(int));
extList->names=(char **)realloc((void *)extList->names, n*sizeof(char *));
}
extList->names[i]=(char *)malloc(length*sizeof(char));
strcpy(extList->names[i],extName);
extList->lengths[i]=length;
extList->numNames++;
}
const char *__GLeeGetExtStrPlat( void )
{
#ifdef WIN32
if (!_GLEE_WGL_ARB_extensions_string)
wglGetExtensionsStringARB = (GLEEPFNWGLGETEXTENSIONSSTRINGARBPROC) wglGetProcAddress("wglGetExtensionsStringARB");
if (wglGetExtensionsStringARB)
return (const char *)wglGetExtensionsStringARB(wglGetCurrentDC());
#elif defined(__APPLE__) || defined(__APPLE_CC__)
#else
Display *dpy=glXGetCurrentDisplay();
if(dpy)
{
int dpynr=DefaultScreen(dpy);
return (const char*)glXQueryExtensionsString(dpy,dpynr);
}
#endif
return 0;
}
void __GLeeWriteError(const char * errorStr)
{
int a=0;
for (a=0;a<256;a++)
{
GLeeErrorString[a]=errorStr[a];
}
GLeeErrorString[255]='\0';
}
int __GLeeGetVersionNumber(char *versionStr)
{
int major=(int)versionStr[0]-(int)'0';
int minor=(int)versionStr[2]-(int)'0';
return major<<8 | minor;
}
GLboolean __GLeeGetExtensions(ExtensionList* extList)
{
const char * platExtStr;
const char * glExtStr;
char * extStr;
char emptyString[1] = "";
char extensionName[1024];
int a,b;
int totalExtStrLen;
int platExtStrLen;
int addASpace;
/* read the platform specific extension string */
platExtStr=__GLeeGetExtStrPlat();
if (!platExtStr) platExtStr=emptyString;
glExtStr=(const char *)glGetString(GL_EXTENSIONS);
if (glExtStr==0)
{
__GLeeWriteError("glGetString(GL_EXTENSIONS) failed.");
return GL_FALSE;
}
/* allocate the extension string */
platExtStrLen = strlen(platExtStr);
totalExtStrLen = platExtStrLen + strlen(glExtStr);
extStr=(char *)malloc( (totalExtStrLen+2) * sizeof(char) ); /* we add 2 to allow for an extra space and a null terminator */
/* If the last character of platExtStr is not a space, we need to add one when we concatenate the extension strings*/
addASpace = 0;
if ( platExtStrLen > 2 )
{
if ( platExtStr[ platExtStrLen-1 ] != ' ')
{
addASpace = 1;
}
}
/* concatenate the two extension strings */
if ( addASpace )
{
sprintf(extStr,"%s %s",platExtStr,glExtStr);
}
else
{
sprintf(extStr,"%s%s",platExtStr,glExtStr);
}
/* extract the extensions */
for ( a=0;a<totalExtStrLen;a++ )
{
b=0;
while (extStr[a]!=' ' && a<totalExtStrLen && b<1022)
{
extensionName[b]=extStr[a];
b++; a++;
}
if (b==1023)
{
__GLeeWriteError("Extension name exceeds 1023 characters.");
free((void *)extStr);
return GL_FALSE;
}
extensionName[b]='\0';
/* add the extension */
__GLeeExtList_add(extList,extensionName);
}
free((void *)extStr);
return GL_TRUE;
}
GLboolean __GLeeCheckExtension(const char * name, ExtensionList *extensionNames)
{
int n=extensionNames->numNames;
int a;
for (a=0;a<n;a++)
{
if (strcmp(extensionNames->names[a],name)==0)
return GL_TRUE;
}
return GL_FALSE;
}
GLEE_EXTERN GLint __GLeeGetExtensionNumber(const char *extensionName, int type)
{
int a;
switch (type)
{
case 0:
for (a=0;a<__GLeeGLNumExtensions;a++)
if (strcmp(extensionName,__GLeeGLExtensionNames[a])==0) return a;
return -1;
#ifdef WIN32
case 1:
for (a=0;a<__GLeeWGLNumExtensions;a++)
if (strcmp(extensionName,__GLeeWGLExtensionNames[a])==0) return a;
return -1;
#elif defined(__APPLE__) || defined(__APPLE_CC__)
#else
case 2:
for (a=0;a<__GLeeGLXNumExtensions;a++)
if (strcmp(extensionName,__GLeeGLXExtensionNames[a])==0) return a;
return -1;
#endif
}
return -1;
}
/*****************************************************************
* GLee external functions
*****************************************************************/
#ifdef WIN32
GLEE_EXTERN const char * GLeeGetExtStrWGL( void )
{
return __GLeeGetExtStrPlat();
}
#elif defined(__APPLE__) || defined(__APPLE_CC__)
#else
GLEE_EXTERN const char * GLeeGetExtStrGLX( void )
{
return __GLeeGetExtStrPlat();
}
#endif
GLEE_EXTERN const char * GLeeGetExtStrGL( void )
{
return (const char *)glGetString(GL_EXTENSIONS);
}
GLEE_EXTERN const char * GLeeGetErrorString( void )
{
return GLeeErrorString;
}
GLboolean __GLeeInitedLoadFunctions=GL_FALSE;
GLEE_EXTERN GLint GLeeForceLink(const char * extensionName)
{
int type=0;
int extNum;
int len=strlen(extensionName);
if (len<5) return GLEE_LINK_FAIL;
if (!__GLeeInitedLoadFunctions)
{
if (!__GLeeInited) GLeeInit();
initGLLoadFunctions();
#ifdef WIN32
initWGLLoadFunctions();
#elif defined(__APPLE__) || defined(__APPLE_CC__)
#else
initGLXLoadFunctions();
#endif
__GLeeInitedLoadFunctions=GL_TRUE;
}
if (extensionName[0]=='W') type=1;
else if (extensionName[2]=='X') type=2;
extNum=__GLeeGetExtensionNumber(extensionName,type);
if (extNum==-1) return GLEE_LINK_FAIL;
if (type==0) return __GLeeGLLoadFunction[extNum]();
#ifdef WIN32
if (type==1) return __GLeeWGLLoadFunction[extNum]();
#elif defined(__APPLE__) || defined(__APPLE_CC__)
#else
if (type==2) return __GLeeGLXLoadFunction[extNum]();
#endif
return GLEE_LINK_FAIL;
}
GLEE_EXTERN GLboolean GLeeEnabled(GLboolean * extensionQueryingVariable)
{
if (!__GLeeInited) GLeeInit();
return *extensionQueryingVariable;
}
GLEE_EXTERN GLboolean GLeeInit( void )
{
int version;
ExtensionList extensionNames;
if (__GLeeInited)
{
return GL_FALSE;
}
__GLeeExtList_init(&extensionNames);
if (!__GLeeGetExtensions(&extensionNames))
{
__GLeeWriteError("GL extension querying failed.");
__GLeeExtList_clean(&extensionNames);
return GL_FALSE;
}
version=__GLeeGetVersionNumber((char *)glGetString(GL_VERSION));
__GLeeInited = GL_TRUE;
/*****************************************************************
* Autogenerated linking functions
*****************************************************************/
if (version>=258)
{
_GLEE_VERSION_1_2 = GL_TRUE;
__GLeeLink_GL_VERSION_1_2();
}
if (__GLeeCheckExtension("GL_ARB_imaging", &extensionNames) )
{
_GLEE_ARB_imaging = GL_TRUE;
__GLeeLink_GL_ARB_imaging();
}
if (version>=259)
{
_GLEE_VERSION_1_3 = GL_TRUE;
__GLeeLink_GL_VERSION_1_3();
}
if (version>=260)
{
_GLEE_VERSION_1_4 = GL_TRUE;
__GLeeLink_GL_VERSION_1_4();
}
if (version>=261)
{
_GLEE_VERSION_1_5 = GL_TRUE;
__GLeeLink_GL_VERSION_1_5();
}
if (version>=512)
{
_GLEE_VERSION_2_0 = GL_TRUE;
__GLeeLink_GL_VERSION_2_0();
}
if (version>=513)
{
_GLEE_VERSION_2_1 = GL_TRUE;
__GLeeLink_GL_VERSION_2_1();
}
if (version>=768)
{
_GLEE_VERSION_3_0 = GL_TRUE;
__GLeeLink_GL_VERSION_3_0();
}
if (__GLeeCheckExtension("GL_ARB_multitexture", &extensionNames) )
{
_GLEE_ARB_multitexture = GL_TRUE;
__GLeeLink_GL_ARB_multitexture();
}
if (__GLeeCheckExtension("GL_ARB_transpose_matrix", &extensionNames) )
{
_GLEE_ARB_transpose_matrix = GL_TRUE;
__GLeeLink_GL_ARB_transpose_matrix();
}
if (__GLeeCheckExtension("GL_ARB_multisample", &extensionNames) )
{
_GLEE_ARB_multisample = GL_TRUE;
__GLeeLink_GL_ARB_multisample();
}
if (__GLeeCheckExtension("GL_ARB_texture_env_add", &extensionNames) )
{
_GLEE_ARB_texture_env_add = GL_TRUE;
__GLeeLink_GL_ARB_texture_env_add();
}
if (__GLeeCheckExtension("GL_ARB_texture_cube_map", &extensionNames) )
{
_GLEE_ARB_texture_cube_map = GL_TRUE;
__GLeeLink_GL_ARB_texture_cube_map();
}
if (__GLeeCheckExtension("GL_ARB_texture_compression", &extensionNames) )
{
_GLEE_ARB_texture_compression = GL_TRUE;
__GLeeLink_GL_ARB_texture_compression();
}
if (__GLeeCheckExtension("GL_ARB_texture_border_clamp", &extensionNames) )
{
_GLEE_ARB_texture_border_clamp = GL_TRUE;
__GLeeLink_GL_ARB_texture_border_clamp();
}
if (__GLeeCheckExtension("GL_ARB_point_parameters", &extensionNames) )
{
_GLEE_ARB_point_parameters = GL_TRUE;
__GLeeLink_GL_ARB_point_parameters();
}
if (__GLeeCheckExtension("GL_ARB_vertex_blend", &extensionNames) )
{
_GLEE_ARB_vertex_blend = GL_TRUE;
__GLeeLink_GL_ARB_vertex_blend();
}
if (__GLeeCheckExtension("GL_ARB_matrix_palette", &extensionNames) )
{
_GLEE_ARB_matrix_palette = GL_TRUE;
__GLeeLink_GL_ARB_matrix_palette();
}
if (__GLeeCheckExtension("GL_ARB_texture_env_combine", &extensionNames) )
{
_GLEE_ARB_texture_env_combine = GL_TRUE;
__GLeeLink_GL_ARB_texture_env_combine();
}
if (__GLeeCheckExtension("GL_ARB_texture_env_crossbar", &extensionNames) )
{
_GLEE_ARB_texture_env_crossbar = GL_TRUE;
__GLeeLink_GL_ARB_texture_env_crossbar();
}
if (__GLeeCheckExtension("GL_ARB_texture_env_dot3", &extensionNames) )
{
_GLEE_ARB_texture_env_dot3 = GL_TRUE;
__GLeeLink_GL_ARB_texture_env_dot3();
}
if (__GLeeCheckExtension("GL_ARB_texture_mirrored_repeat", &extensionNames) )
{
_GLEE_ARB_texture_mirrored_repeat = GL_TRUE;
__GLeeLink_GL_ARB_texture_mirrored_repeat();
}
if (__GLeeCheckExtension("GL_ARB_depth_texture", &extensionNames) )
{
_GLEE_ARB_depth_texture = GL_TRUE;
__GLeeLink_GL_ARB_depth_texture();
}
if (__GLeeCheckExtension("GL_ARB_shadow", &extensionNames) )
{
_GLEE_ARB_shadow = GL_TRUE;
__GLeeLink_GL_ARB_shadow();
}
if (__GLeeCheckExtension("GL_ARB_shadow_ambient", &extensionNames) )
{
_GLEE_ARB_shadow_ambient = GL_TRUE;
__GLeeLink_GL_ARB_shadow_ambient();
}
if (__GLeeCheckExtension("GL_ARB_window_pos", &extensionNames) )
{
_GLEE_ARB_window_pos = GL_TRUE;
__GLeeLink_GL_ARB_window_pos();
}
if (__GLeeCheckExtension("GL_ARB_vertex_program", &extensionNames) )
{
_GLEE_ARB_vertex_program = GL_TRUE;
__GLeeLink_GL_ARB_vertex_program();
}
if (__GLeeCheckExtension("GL_ARB_fragment_program", &extensionNames) )
{
_GLEE_ARB_fragment_program = GL_TRUE;
__GLeeLink_GL_ARB_fragment_program();
}
if (__GLeeCheckExtension("GL_ARB_vertex_buffer_object", &extensionNames) )
{
_GLEE_ARB_vertex_buffer_object = GL_TRUE;
__GLeeLink_GL_ARB_vertex_buffer_object();
}
if (__GLeeCheckExtension("GL_ARB_occlusion_query", &extensionNames) )
{
_GLEE_ARB_occlusion_query = GL_TRUE;
__GLeeLink_GL_ARB_occlusion_query();
}
if (__GLeeCheckExtension("GL_ARB_shader_objects", &extensionNames) )
{
_GLEE_ARB_shader_objects = GL_TRUE;
__GLeeLink_GL_ARB_shader_objects();
}
if (__GLeeCheckExtension("GL_ARB_vertex_shader", &extensionNames) )
{
_GLEE_ARB_vertex_shader = GL_TRUE;
__GLeeLink_GL_ARB_vertex_shader();
}
if (__GLeeCheckExtension("GL_ARB_fragment_shader", &extensionNames) )
{
_GLEE_ARB_fragment_shader = GL_TRUE;
__GLeeLink_GL_ARB_fragment_shader();
}
if (__GLeeCheckExtension("GL_ARB_shading_language_100", &extensionNames) )
{
_GLEE_ARB_shading_language_100 = GL_TRUE;
__GLeeLink_GL_ARB_shading_language_100();
}
if (__GLeeCheckExtension("GL_ARB_texture_non_power_of_two", &extensionNames) )
{
_GLEE_ARB_texture_non_power_of_two = GL_TRUE;
__GLeeLink_GL_ARB_texture_non_power_of_two();
}
if (__GLeeCheckExtension("GL_ARB_point_sprite", &extensionNames) )
{
_GLEE_ARB_point_sprite = GL_TRUE;
__GLeeLink_GL_ARB_point_sprite();
}
if (__GLeeCheckExtension("GL_ARB_fragment_program_shadow", &extensionNames) )
{
_GLEE_ARB_fragment_program_shadow = GL_TRUE;
__GLeeLink_GL_ARB_fragment_program_shadow();
}
if (__GLeeCheckExtension("GL_ARB_draw_buffers", &extensionNames) )
{
_GLEE_ARB_draw_buffers = GL_TRUE;
__GLeeLink_GL_ARB_draw_buffers();
}
if (__GLeeCheckExtension("GL_ARB_texture_rectangle", &extensionNames) )
{
_GLEE_ARB_texture_rectangle = GL_TRUE;
__GLeeLink_GL_ARB_texture_rectangle();
}
if (__GLeeCheckExtension("GL_ARB_color_buffer_float", &extensionNames) )
{
_GLEE_ARB_color_buffer_float = GL_TRUE;
__GLeeLink_GL_ARB_color_buffer_float();
}
if (__GLeeCheckExtension("GL_ARB_half_float_pixel", &extensionNames) )
{
_GLEE_ARB_half_float_pixel = GL_TRUE;
__GLeeLink_GL_ARB_half_float_pixel();
}
if (__GLeeCheckExtension("GL_ARB_texture_float", &extensionNames) )
{
_GLEE_ARB_texture_float = GL_TRUE;
__GLeeLink_GL_ARB_texture_float();
}
if (__GLeeCheckExtension("GL_ARB_pixel_buffer_object", &extensionNames) )
{
_GLEE_ARB_pixel_buffer_object = GL_TRUE;
__GLeeLink_GL_ARB_pixel_buffer_object();
}
if (__GLeeCheckExtension("GL_ARB_depth_buffer_float", &extensionNames) )
{
_GLEE_ARB_depth_buffer_float = GL_TRUE;
__GLeeLink_GL_ARB_depth_buffer_float();
}
if (__GLeeCheckExtension("GL_ARB_draw_instanced", &extensionNames) )
{
_GLEE_ARB_draw_instanced = GL_TRUE;
__GLeeLink_GL_ARB_draw_instanced();
}
if (__GLeeCheckExtension("GL_ARB_framebuffer_object", &extensionNames) )
{
_GLEE_ARB_framebuffer_object = GL_TRUE;
__GLeeLink_GL_ARB_framebuffer_object();
}
if (__GLeeCheckExtension("GL_ARB_framebuffer_sRGB", &extensionNames) )
{
_GLEE_ARB_framebuffer_sRGB = GL_TRUE;
__GLeeLink_GL_ARB_framebuffer_sRGB();
}
if (__GLeeCheckExtension("GL_ARB_geometry_shader4", &extensionNames) )
{
_GLEE_ARB_geometry_shader4 = GL_TRUE;
__GLeeLink_GL_ARB_geometry_shader4();
}
if (__GLeeCheckExtension("GL_ARB_half_float_vertex", &extensionNames) )
{
_GLEE_ARB_half_float_vertex = GL_TRUE;
__GLeeLink_GL_ARB_half_float_vertex();
}
if (__GLeeCheckExtension("GL_ARB_instanced_arrays", &extensionNames) )
{
_GLEE_ARB_instanced_arrays = GL_TRUE;
__GLeeLink_GL_ARB_instanced_arrays();
}
if (__GLeeCheckExtension("GL_ARB_map_buffer_range", &extensionNames) )
{
_GLEE_ARB_map_buffer_range = GL_TRUE;
__GLeeLink_GL_ARB_map_buffer_range();
}
if (__GLeeCheckExtension("GL_ARB_texture_buffer_object", &extensionNames) )
{
_GLEE_ARB_texture_buffer_object = GL_TRUE;
__GLeeLink_GL_ARB_texture_buffer_object();
}
if (__GLeeCheckExtension("GL_ARB_texture_compression_rgtc", &extensionNames) )
{
_GLEE_ARB_texture_compression_rgtc = GL_TRUE;
__GLeeLink_GL_ARB_texture_compression_rgtc();
}
if (__GLeeCheckExtension("GL_ARB_texture_rg", &extensionNames) )
{
_GLEE_ARB_texture_rg = GL_TRUE;
__GLeeLink_GL_ARB_texture_rg();
}
if (__GLeeCheckExtension("GL_ARB_vertex_array_object", &extensionNames) )
{
_GLEE_ARB_vertex_array_object = GL_TRUE;
__GLeeLink_GL_ARB_vertex_array_object();
}
if (__GLeeCheckExtension("GL_EXT_abgr", &extensionNames) )
{
_GLEE_EXT_abgr = GL_TRUE;
__GLeeLink_GL_EXT_abgr();
}
if (__GLeeCheckExtension("GL_EXT_blend_color", &extensionNames) )
{
_GLEE_EXT_blend_color = GL_TRUE;
__GLeeLink_GL_EXT_blend_color();
}
if (__GLeeCheckExtension("GL_EXT_polygon_offset", &extensionNames) )
{
_GLEE_EXT_polygon_offset = GL_TRUE;
__GLeeLink_GL_EXT_polygon_offset();
}
if (__GLeeCheckExtension("GL_EXT_texture", &extensionNames) )
{
_GLEE_EXT_texture = GL_TRUE;
__GLeeLink_GL_EXT_texture();
}
if (__GLeeCheckExtension("GL_EXT_texture3D", &extensionNames) )
{
_GLEE_EXT_texture3D = GL_TRUE;
__GLeeLink_GL_EXT_texture3D();
}
if (__GLeeCheckExtension("GL_SGIS_texture_filter4", &extensionNames) )
{
_GLEE_SGIS_texture_filter4 = GL_TRUE;
__GLeeLink_GL_SGIS_texture_filter4();
}
if (__GLeeCheckExtension("GL_EXT_subtexture", &extensionNames) )
{
_GLEE_EXT_subtexture = GL_TRUE;
__GLeeLink_GL_EXT_subtexture();
}
if (__GLeeCheckExtension("GL_EXT_copy_texture", &extensionNames) )
{
_GLEE_EXT_copy_texture = GL_TRUE;
__GLeeLink_GL_EXT_copy_texture();
}
if (__GLeeCheckExtension("GL_EXT_histogram", &extensionNames) )
{
_GLEE_EXT_histogram = GL_TRUE;
__GLeeLink_GL_EXT_histogram();
}
if (__GLeeCheckExtension("GL_EXT_convolution", &extensionNames) )
{
_GLEE_EXT_convolution = GL_TRUE;
__GLeeLink_GL_EXT_convolution();
}
if (__GLeeCheckExtension("GL_SGI_color_matrix", &extensionNames) )
{
_GLEE_SGI_color_matrix = GL_TRUE;
__GLeeLink_GL_SGI_color_matrix();
}
if (__GLeeCheckExtension("GL_SGI_color_table", &extensionNames) )
{
_GLEE_SGI_color_table = GL_TRUE;
__GLeeLink_GL_SGI_color_table();
}
if (__GLeeCheckExtension("GL_SGIS_pixel_texture", &extensionNames) )
{
_GLEE_SGIS_pixel_texture = GL_TRUE;
__GLeeLink_GL_SGIS_pixel_texture();
}
if (__GLeeCheckExtension("GL_SGIX_pixel_texture", &extensionNames) )
{
_GLEE_SGIX_pixel_texture = GL_TRUE;
__GLeeLink_GL_SGIX_pixel_texture();
}
if (__GLeeCheckExtension("GL_SGIS_texture4D", &extensionNames) )
{
_GLEE_SGIS_texture4D = GL_TRUE;
__GLeeLink_GL_SGIS_texture4D();
}
if (__GLeeCheckExtension("GL_SGI_texture_color_table", &extensionNames) )
{
_GLEE_SGI_texture_color_table = GL_TRUE;
__GLeeLink_GL_SGI_texture_color_table();
}
if (__GLeeCheckExtension("GL_EXT_cmyka", &extensionNames) )
{
_GLEE_EXT_cmyka = GL_TRUE;
__GLeeLink_GL_EXT_cmyka();
}
if (__GLeeCheckExtension("GL_EXT_texture_object", &extensionNames) )
{
_GLEE_EXT_texture_object = GL_TRUE;
__GLeeLink_GL_EXT_texture_object();
}
if (__GLeeCheckExtension("GL_SGIS_detail_texture", &extensionNames) )
{
_GLEE_SGIS_detail_texture = GL_TRUE;
__GLeeLink_GL_SGIS_detail_texture();
}
if (__GLeeCheckExtension("GL_SGIS_sharpen_texture", &extensionNames) )
{
_GLEE_SGIS_sharpen_texture = GL_TRUE;
__GLeeLink_GL_SGIS_sharpen_texture();
}
if (__GLeeCheckExtension("GL_EXT_packed_pixels", &extensionNames) )
{
_GLEE_EXT_packed_pixels = GL_TRUE;
__GLeeLink_GL_EXT_packed_pixels();
}
if (__GLeeCheckExtension("GL_SGIS_texture_lod", &extensionNames) )
{
_GLEE_SGIS_texture_lod = GL_TRUE;
__GLeeLink_GL_SGIS_texture_lod();
}
if (__GLeeCheckExtension("GL_SGIS_multisample", &extensionNames) )
{
_GLEE_SGIS_multisample = GL_TRUE;
__GLeeLink_GL_SGIS_multisample();
}
if (__GLeeCheckExtension("GL_EXT_rescale_normal", &extensionNames) )
{
_GLEE_EXT_rescale_normal = GL_TRUE;
__GLeeLink_GL_EXT_rescale_normal();
}
if (__GLeeCheckExtension("GL_EXT_vertex_array", &extensionNames) )
{
_GLEE_EXT_vertex_array = GL_TRUE;
__GLeeLink_GL_EXT_vertex_array();
}
if (__GLeeCheckExtension("GL_EXT_misc_attribute", &extensionNames) )
{
_GLEE_EXT_misc_attribute = GL_TRUE;
__GLeeLink_GL_EXT_misc_attribute();
}
if (__GLeeCheckExtension("GL_SGIS_generate_mipmap", &extensionNames) )
{
_GLEE_SGIS_generate_mipmap = GL_TRUE;
__GLeeLink_GL_SGIS_generate_mipmap();
}
if (__GLeeCheckExtension("GL_SGIX_clipmap", &extensionNames) )
{
_GLEE_SGIX_clipmap = GL_TRUE;
__GLeeLink_GL_SGIX_clipmap();
}
if (__GLeeCheckExtension("GL_SGIX_shadow", &extensionNames) )
{
_GLEE_SGIX_shadow = GL_TRUE;
__GLeeLink_GL_SGIX_shadow();
}
if (__GLeeCheckExtension("GL_SGIS_texture_edge_clamp", &extensionNames) )
{
_GLEE_SGIS_texture_edge_clamp = GL_TRUE;
__GLeeLink_GL_SGIS_texture_edge_clamp();
}
if (__GLeeCheckExtension("GL_SGIS_texture_border_clamp", &extensionNames) )
{
_GLEE_SGIS_texture_border_clamp = GL_TRUE;
__GLeeLink_GL_SGIS_texture_border_clamp();
}
if (__GLeeCheckExtension("GL_EXT_blend_minmax", &extensionNames) )
{
_GLEE_EXT_blend_minmax = GL_TRUE;
__GLeeLink_GL_EXT_blend_minmax();
}
if (__GLeeCheckExtension("GL_EXT_blend_subtract", &extensionNames) )
{
_GLEE_EXT_blend_subtract = GL_TRUE;
__GLeeLink_GL_EXT_blend_subtract();
}
if (__GLeeCheckExtension("GL_EXT_blend_logic_op", &extensionNames) )
{
_GLEE_EXT_blend_logic_op = GL_TRUE;
__GLeeLink_GL_EXT_blend_logic_op();
}
if (__GLeeCheckExtension("GL_SGIX_interlace", &extensionNames) )
{
_GLEE_SGIX_interlace = GL_TRUE;
__GLeeLink_GL_SGIX_interlace();
}
if (__GLeeCheckExtension("GL_SGIX_pixel_tiles", &extensionNames) )
{
_GLEE_SGIX_pixel_tiles = GL_TRUE;
__GLeeLink_GL_SGIX_pixel_tiles();
}
if (__GLeeCheckExtension("GL_SGIS_texture_select", &extensionNames) )
{
_GLEE_SGIS_texture_select = GL_TRUE;
__GLeeLink_GL_SGIS_texture_select();
}
if (__GLeeCheckExtension("GL_SGIX_sprite", &extensionNames) )
{
_GLEE_SGIX_sprite = GL_TRUE;
__GLeeLink_GL_SGIX_sprite();
}
if (__GLeeCheckExtension("GL_SGIX_texture_multi_buffer", &extensionNames) )
{
_GLEE_SGIX_texture_multi_buffer = GL_TRUE;
__GLeeLink_GL_SGIX_texture_multi_buffer();
}
if (__GLeeCheckExtension("GL_EXT_point_parameters", &extensionNames) )
{
_GLEE_EXT_point_parameters = GL_TRUE;
__GLeeLink_GL_EXT_point_parameters();
}
if (__GLeeCheckExtension("GL_SGIS_point_parameters", &extensionNames) )
{
_GLEE_SGIS_point_parameters = GL_TRUE;
__GLeeLink_GL_SGIS_point_parameters();
}
if (__GLeeCheckExtension("GL_SGIX_instruments", &extensionNames) )
{
_GLEE_SGIX_instruments = GL_TRUE;
__GLeeLink_GL_SGIX_instruments();
}
if (__GLeeCheckExtension("GL_SGIX_texture_scale_bias", &extensionNames) )
{
_GLEE_SGIX_texture_scale_bias = GL_TRUE;
__GLeeLink_GL_SGIX_texture_scale_bias();
}
if (__GLeeCheckExtension("GL_SGIX_framezoom", &extensionNames) )
{
_GLEE_SGIX_framezoom = GL_TRUE;
__GLeeLink_GL_SGIX_framezoom();
}
if (__GLeeCheckExtension("GL_SGIX_tag_sample_buffer", &extensionNames) )
{
_GLEE_SGIX_tag_sample_buffer = GL_TRUE;
__GLeeLink_GL_SGIX_tag_sample_buffer();
}
if (__GLeeCheckExtension("GL_FfdMaskSGIX", &extensionNames) )
{
_GLEE_FfdMaskSGIX = GL_TRUE;
__GLeeLink_GL_FfdMaskSGIX();
}
if (__GLeeCheckExtension("GL_SGIX_polynomial_ffd", &extensionNames) )
{
_GLEE_SGIX_polynomial_ffd = GL_TRUE;
__GLeeLink_GL_SGIX_polynomial_ffd();
}
if (__GLeeCheckExtension("GL_SGIX_reference_plane", &extensionNames) )
{
_GLEE_SGIX_reference_plane = GL_TRUE;
__GLeeLink_GL_SGIX_reference_plane();
}
if (__GLeeCheckExtension("GL_SGIX_flush_raster", &extensionNames) )
{
_GLEE_SGIX_flush_raster = GL_TRUE;
__GLeeLink_GL_SGIX_flush_raster();
}
if (__GLeeCheckExtension("GL_SGIX_depth_texture", &extensionNames) )
{
_GLEE_SGIX_depth_texture = GL_TRUE;
__GLeeLink_GL_SGIX_depth_texture();
}
if (__GLeeCheckExtension("GL_SGIS_fog_function", &extensionNames) )
{
_GLEE_SGIS_fog_function = GL_TRUE;
__GLeeLink_GL_SGIS_fog_function();
}
if (__GLeeCheckExtension("GL_SGIX_fog_offset", &extensionNames) )
{
_GLEE_SGIX_fog_offset = GL_TRUE;
__GLeeLink_GL_SGIX_fog_offset();
}
if (__GLeeCheckExtension("GL_HP_image_transform", &extensionNames) )
{
_GLEE_HP_image_transform = GL_TRUE;
__GLeeLink_GL_HP_image_transform();
}
if (__GLeeCheckExtension("GL_HP_convolution_border_modes", &extensionNames) )
{
_GLEE_HP_convolution_border_modes = GL_TRUE;
__GLeeLink_GL_HP_convolution_border_modes();
}
if (__GLeeCheckExtension("GL_INGR_palette_buffer", &extensionNames) )
{
_GLEE_INGR_palette_buffer = GL_TRUE;
__GLeeLink_GL_INGR_palette_buffer();
}
if (__GLeeCheckExtension("GL_SGIX_texture_add_env", &extensionNames) )
{
_GLEE_SGIX_texture_add_env = GL_TRUE;
__GLeeLink_GL_SGIX_texture_add_env();
}
if (__GLeeCheckExtension("GL_EXT_color_subtable", &extensionNames) )
{
_GLEE_EXT_color_subtable = GL_TRUE;
__GLeeLink_GL_EXT_color_subtable();
}
if (__GLeeCheckExtension("GL_PGI_vertex_hints", &extensionNames) )
{
_GLEE_PGI_vertex_hints = GL_TRUE;
__GLeeLink_GL_PGI_vertex_hints();
}
if (__GLeeCheckExtension("GL_PGI_misc_hints", &extensionNames) )
{
_GLEE_PGI_misc_hints = GL_TRUE;
__GLeeLink_GL_PGI_misc_hints();
}
if (__GLeeCheckExtension("GL_EXT_paletted_texture", &extensionNames) )
{
_GLEE_EXT_paletted_texture = GL_TRUE;
__GLeeLink_GL_EXT_paletted_texture();
}
if (__GLeeCheckExtension("GL_EXT_clip_volume_hint", &extensionNames) )
{
_GLEE_EXT_clip_volume_hint = GL_TRUE;
__GLeeLink_GL_EXT_clip_volume_hint();
}
if (__GLeeCheckExtension("GL_SGIX_list_priority", &extensionNames) )
{
_GLEE_SGIX_list_priority = GL_TRUE;
__GLeeLink_GL_SGIX_list_priority();
}
if (__GLeeCheckExtension("GL_SGIX_ir_instrument1", &extensionNames) )
{
_GLEE_SGIX_ir_instrument1 = GL_TRUE;
__GLeeLink_GL_SGIX_ir_instrument1();
}
if (__GLeeCheckExtension("GL_SGIX_calligraphic_fragment", &extensionNames) )
{
_GLEE_SGIX_calligraphic_fragment = GL_TRUE;
__GLeeLink_GL_SGIX_calligraphic_fragment();
}
if (__GLeeCheckExtension("GL_SGIX_texture_lod_bias", &extensionNames) )
{
_GLEE_SGIX_texture_lod_bias = GL_TRUE;
__GLeeLink_GL_SGIX_texture_lod_bias();
}
if (__GLeeCheckExtension("GL_SGIX_shadow_ambient", &extensionNames) )
{
_GLEE_SGIX_shadow_ambient = GL_TRUE;
__GLeeLink_GL_SGIX_shadow_ambient();
}
if (__GLeeCheckExtension("GL_EXT_index_texture", &extensionNames) )
{
_GLEE_EXT_index_texture = GL_TRUE;
__GLeeLink_GL_EXT_index_texture();
}
if (__GLeeCheckExtension("GL_EXT_index_material", &extensionNames) )
{
_GLEE_EXT_index_material = GL_TRUE;
__GLeeLink_GL_EXT_index_material();
}
if (__GLeeCheckExtension("GL_EXT_index_func", &extensionNames) )
{
_GLEE_EXT_index_func = GL_TRUE;
__GLeeLink_GL_EXT_index_func();
}
if (__GLeeCheckExtension("GL_EXT_index_array_formats", &extensionNames) )
{
_GLEE_EXT_index_array_formats = GL_TRUE;
__GLeeLink_GL_EXT_index_array_formats();
}
if (__GLeeCheckExtension("GL_EXT_compiled_vertex_array", &extensionNames) )
{
_GLEE_EXT_compiled_vertex_array = GL_TRUE;
__GLeeLink_GL_EXT_compiled_vertex_array();
}
if (__GLeeCheckExtension("GL_EXT_cull_vertex", &extensionNames) )
{
_GLEE_EXT_cull_vertex = GL_TRUE;
__GLeeLink_GL_EXT_cull_vertex();
}
if (__GLeeCheckExtension("GL_SGIX_ycrcb", &extensionNames) )
{
_GLEE_SGIX_ycrcb = GL_TRUE;
__GLeeLink_GL_SGIX_ycrcb();
}
if (__GLeeCheckExtension("GL_SGIX_fragment_lighting", &extensionNames) )
{
_GLEE_SGIX_fragment_lighting = GL_TRUE;
__GLeeLink_GL_SGIX_fragment_lighting();
}
if (__GLeeCheckExtension("GL_IBM_rasterpos_clip", &extensionNames) )
{
_GLEE_IBM_rasterpos_clip = GL_TRUE;
__GLeeLink_GL_IBM_rasterpos_clip();
}
if (__GLeeCheckExtension("GL_HP_texture_lighting", &extensionNames) )
{
_GLEE_HP_texture_lighting = GL_TRUE;
__GLeeLink_GL_HP_texture_lighting();
}
if (__GLeeCheckExtension("GL_EXT_draw_range_elements", &extensionNames) )
{
_GLEE_EXT_draw_range_elements = GL_TRUE;
__GLeeLink_GL_EXT_draw_range_elements();
}
if (__GLeeCheckExtension("GL_WIN_phong_shading", &extensionNames) )
{
_GLEE_WIN_phong_shading = GL_TRUE;
__GLeeLink_GL_WIN_phong_shading();
}
if (__GLeeCheckExtension("GL_WIN_specular_fog", &extensionNames) )
{
_GLEE_WIN_specular_fog = GL_TRUE;
__GLeeLink_GL_WIN_specular_fog();
}
if (__GLeeCheckExtension("GL_EXT_light_texture", &extensionNames) )
{
_GLEE_EXT_light_texture = GL_TRUE;
__GLeeLink_GL_EXT_light_texture();
}
if (__GLeeCheckExtension("GL_SGIX_blend_alpha_minmax", &extensionNames) )
{
_GLEE_SGIX_blend_alpha_minmax = GL_TRUE;
__GLeeLink_GL_SGIX_blend_alpha_minmax();
}
if (__GLeeCheckExtension("GL_SGIX_impact_pixel_texture", &extensionNames) )
{
_GLEE_SGIX_impact_pixel_texture = GL_TRUE;
__GLeeLink_GL_SGIX_impact_pixel_texture();
}
if (__GLeeCheckExtension("GL_EXT_bgra", &extensionNames) )
{
_GLEE_EXT_bgra = GL_TRUE;
__GLeeLink_GL_EXT_bgra();
}
if (__GLeeCheckExtension("GL_SGIX_async", &extensionNames) )
{
_GLEE_SGIX_async = GL_TRUE;
__GLeeLink_GL_SGIX_async();
}
if (__GLeeCheckExtension("GL_SGIX_async_pixel", &extensionNames) )
{
_GLEE_SGIX_async_pixel = GL_TRUE;
__GLeeLink_GL_SGIX_async_pixel();
}
if (__GLeeCheckExtension("GL_SGIX_async_histogram", &extensionNames) )
{
_GLEE_SGIX_async_histogram = GL_TRUE;
__GLeeLink_GL_SGIX_async_histogram();
}
if (__GLeeCheckExtension("GL_INTEL_texture_scissor", &extensionNames) )
{
_GLEE_INTEL_texture_scissor = GL_TRUE;
__GLeeLink_GL_INTEL_texture_scissor();
}
if (__GLeeCheckExtension("GL_INTEL_parallel_arrays", &extensionNames) )
{
_GLEE_INTEL_parallel_arrays = GL_TRUE;
__GLeeLink_GL_INTEL_parallel_arrays();
}
if (__GLeeCheckExtension("GL_HP_occlusion_test", &extensionNames) )
{
_GLEE_HP_occlusion_test = GL_TRUE;
__GLeeLink_GL_HP_occlusion_test();
}
if (__GLeeCheckExtension("GL_EXT_pixel_transform", &extensionNames) )
{
_GLEE_EXT_pixel_transform = GL_TRUE;
__GLeeLink_GL_EXT_pixel_transform();
}
if (__GLeeCheckExtension("GL_EXT_pixel_transform_color_table", &extensionNames) )
{
_GLEE_EXT_pixel_transform_color_table = GL_TRUE;
__GLeeLink_GL_EXT_pixel_transform_color_table();
}
if (__GLeeCheckExtension("GL_EXT_shared_texture_palette", &extensionNames) )
{
_GLEE_EXT_shared_texture_palette = GL_TRUE;
__GLeeLink_GL_EXT_shared_texture_palette();
}
if (__GLeeCheckExtension("GL_EXT_separate_specular_color", &extensionNames) )
{
_GLEE_EXT_separate_specular_color = GL_TRUE;
__GLeeLink_GL_EXT_separate_specular_color();
}
if (__GLeeCheckExtension("GL_EXT_secondary_color", &extensionNames) )
{
_GLEE_EXT_secondary_color = GL_TRUE;
__GLeeLink_GL_EXT_secondary_color();
}
if (__GLeeCheckExtension("GL_EXT_texture_perturb_normal", &extensionNames) )
{
_GLEE_EXT_texture_perturb_normal = GL_TRUE;
__GLeeLink_GL_EXT_texture_perturb_normal();
}
if (__GLeeCheckExtension("GL_EXT_multi_draw_arrays", &extensionNames) )
{
_GLEE_EXT_multi_draw_arrays = GL_TRUE;
__GLeeLink_GL_EXT_multi_draw_arrays();
}
if (__GLeeCheckExtension("GL_EXT_fog_coord", &extensionNames) )
{
_GLEE_EXT_fog_coord = GL_TRUE;
__GLeeLink_GL_EXT_fog_coord();
}
if (__GLeeCheckExtension("GL_REND_screen_coordinates", &extensionNames) )
{
_GLEE_REND_screen_coordinates = GL_TRUE;
__GLeeLink_GL_REND_screen_coordinates();
}
if (__GLeeCheckExtension("GL_EXT_coordinate_frame", &extensionNames) )
{
_GLEE_EXT_coordinate_frame = GL_TRUE;
__GLeeLink_GL_EXT_coordinate_frame();
}
if (__GLeeCheckExtension("GL_EXT_texture_env_combine", &extensionNames) )
{
_GLEE_EXT_texture_env_combine = GL_TRUE;
__GLeeLink_GL_EXT_texture_env_combine();
}
if (__GLeeCheckExtension("GL_APPLE_specular_vector", &extensionNames) )
{
_GLEE_APPLE_specular_vector = GL_TRUE;
__GLeeLink_GL_APPLE_specular_vector();
}
if (__GLeeCheckExtension("GL_APPLE_transform_hint", &extensionNames) )
{
_GLEE_APPLE_transform_hint = GL_TRUE;
__GLeeLink_GL_APPLE_transform_hint();
}
if (__GLeeCheckExtension("GL_SGIX_fog_scale", &extensionNames) )
{
_GLEE_SGIX_fog_scale = GL_TRUE;
__GLeeLink_GL_SGIX_fog_scale();
}
if (__GLeeCheckExtension("GL_SUNX_constant_data", &extensionNames) )
{
_GLEE_SUNX_constant_data = GL_TRUE;
__GLeeLink_GL_SUNX_constant_data();
}
if (__GLeeCheckExtension("GL_SUN_global_alpha", &extensionNames) )
{
_GLEE_SUN_global_alpha = GL_TRUE;
__GLeeLink_GL_SUN_global_alpha();
}
if (__GLeeCheckExtension("GL_SUN_triangle_list", &extensionNames) )
{
_GLEE_SUN_triangle_list = GL_TRUE;
__GLeeLink_GL_SUN_triangle_list();
}
if (__GLeeCheckExtension("GL_SUN_vertex", &extensionNames) )
{
_GLEE_SUN_vertex = GL_TRUE;
__GLeeLink_GL_SUN_vertex();
}
if (__GLeeCheckExtension("GL_EXT_blend_func_separate", &extensionNames) )
{
_GLEE_EXT_blend_func_separate = GL_TRUE;
__GLeeLink_GL_EXT_blend_func_separate();
}
if (__GLeeCheckExtension("GL_INGR_color_clamp", &extensionNames) )
{
_GLEE_INGR_color_clamp = GL_TRUE;
__GLeeLink_GL_INGR_color_clamp();
}
if (__GLeeCheckExtension("GL_INGR_interlace_read", &extensionNames) )
{
_GLEE_INGR_interlace_read = GL_TRUE;
__GLeeLink_GL_INGR_interlace_read();
}
if (__GLeeCheckExtension("GL_EXT_stencil_wrap", &extensionNames) )
{
_GLEE_EXT_stencil_wrap = GL_TRUE;
__GLeeLink_GL_EXT_stencil_wrap();
}
if (__GLeeCheckExtension("GL_EXT_422_pixels", &extensionNames) )
{
_GLEE_EXT_422_pixels = GL_TRUE;
__GLeeLink_GL_EXT_422_pixels();
}
if (__GLeeCheckExtension("GL_NV_texgen_reflection", &extensionNames) )
{
_GLEE_NV_texgen_reflection = GL_TRUE;
__GLeeLink_GL_NV_texgen_reflection();
}
if (__GLeeCheckExtension("GL_EXT_texture_cube_map", &extensionNames) )
{
_GLEE_EXT_texture_cube_map = GL_TRUE;
__GLeeLink_GL_EXT_texture_cube_map();
}
if (__GLeeCheckExtension("GL_SUN_convolution_border_modes", &extensionNames) )
{
_GLEE_SUN_convolution_border_modes = GL_TRUE;
__GLeeLink_GL_SUN_convolution_border_modes();
}
if (__GLeeCheckExtension("GL_EXT_texture_env_add", &extensionNames) )
{
_GLEE_EXT_texture_env_add = GL_TRUE;
__GLeeLink_GL_EXT_texture_env_add();
}
if (__GLeeCheckExtension("GL_EXT_texture_lod_bias", &extensionNames) )
{
_GLEE_EXT_texture_lod_bias = GL_TRUE;
__GLeeLink_GL_EXT_texture_lod_bias();
}
if (__GLeeCheckExtension("GL_EXT_texture_filter_anisotropic", &extensionNames) )
{
_GLEE_EXT_texture_filter_anisotropic = GL_TRUE;
__GLeeLink_GL_EXT_texture_filter_anisotropic();
}
if (__GLeeCheckExtension("GL_EXT_vertex_weighting", &extensionNames) )
{
_GLEE_EXT_vertex_weighting = GL_TRUE;
__GLeeLink_GL_EXT_vertex_weighting();
}
if (__GLeeCheckExtension("GL_NV_light_max_exponent", &extensionNames) )
{
_GLEE_NV_light_max_exponent = GL_TRUE;
__GLeeLink_GL_NV_light_max_exponent();
}
if (__GLeeCheckExtension("GL_NV_vertex_array_range", &extensionNames) )
{
_GLEE_NV_vertex_array_range = GL_TRUE;
__GLeeLink_GL_NV_vertex_array_range();
}
if (__GLeeCheckExtension("GL_NV_register_combiners", &extensionNames) )
{
_GLEE_NV_register_combiners = GL_TRUE;
__GLeeLink_GL_NV_register_combiners();
}
if (__GLeeCheckExtension("GL_NV_fog_distance", &extensionNames) )
{
_GLEE_NV_fog_distance = GL_TRUE;
__GLeeLink_GL_NV_fog_distance();
}
if (__GLeeCheckExtension("GL_NV_texgen_emboss", &extensionNames) )
{
_GLEE_NV_texgen_emboss = GL_TRUE;
__GLeeLink_GL_NV_texgen_emboss();
}
if (__GLeeCheckExtension("GL_NV_blend_square", &extensionNames) )
{
_GLEE_NV_blend_square = GL_TRUE;
__GLeeLink_GL_NV_blend_square();
}
if (__GLeeCheckExtension("GL_NV_texture_env_combine4", &extensionNames) )
{
_GLEE_NV_texture_env_combine4 = GL_TRUE;
__GLeeLink_GL_NV_texture_env_combine4();
}
if (__GLeeCheckExtension("GL_MESA_resize_buffers", &extensionNames) )
{
_GLEE_MESA_resize_buffers = GL_TRUE;
__GLeeLink_GL_MESA_resize_buffers();
}
if (__GLeeCheckExtension("GL_MESA_window_pos", &extensionNames) )
{
_GLEE_MESA_window_pos = GL_TRUE;
__GLeeLink_GL_MESA_window_pos();
}
if (__GLeeCheckExtension("GL_EXT_texture_compression_s3tc", &extensionNames) )
{
_GLEE_EXT_texture_compression_s3tc = GL_TRUE;
__GLeeLink_GL_EXT_texture_compression_s3tc();
}
if (__GLeeCheckExtension("GL_IBM_cull_vertex", &extensionNames) )
{
_GLEE_IBM_cull_vertex = GL_TRUE;
__GLeeLink_GL_IBM_cull_vertex();
}
if (__GLeeCheckExtension("GL_IBM_multimode_draw_arrays", &extensionNames) )
{
_GLEE_IBM_multimode_draw_arrays = GL_TRUE;
__GLeeLink_GL_IBM_multimode_draw_arrays();
}
if (__GLeeCheckExtension("GL_IBM_vertex_array_lists", &extensionNames) )
{
_GLEE_IBM_vertex_array_lists = GL_TRUE;
__GLeeLink_GL_IBM_vertex_array_lists();
}
if (__GLeeCheckExtension("GL_SGIX_subsample", &extensionNames) )
{
_GLEE_SGIX_subsample = GL_TRUE;
__GLeeLink_GL_SGIX_subsample();
}
if (__GLeeCheckExtension("GL_SGIX_ycrcb_subsample", &extensionNames) )
{
_GLEE_SGIX_ycrcb_subsample = GL_TRUE;
__GLeeLink_GL_SGIX_ycrcb_subsample();
}
if (__GLeeCheckExtension("GL_SGIX_ycrcba", &extensionNames) )
{
_GLEE_SGIX_ycrcba = GL_TRUE;
__GLeeLink_GL_SGIX_ycrcba();
}
if (__GLeeCheckExtension("GL_SGI_depth_pass_instrument", &extensionNames) )
{
_GLEE_SGI_depth_pass_instrument = GL_TRUE;
__GLeeLink_GL_SGI_depth_pass_instrument();
}
if (__GLeeCheckExtension("GL_3DFX_texture_compression_FXT1", &extensionNames) )
{
_GLEE_3DFX_texture_compression_FXT1 = GL_TRUE;
__GLeeLink_GL_3DFX_texture_compression_FXT1();
}
if (__GLeeCheckExtension("GL_3DFX_multisample", &extensionNames) )
{
_GLEE_3DFX_multisample = GL_TRUE;
__GLeeLink_GL_3DFX_multisample();
}
if (__GLeeCheckExtension("GL_3DFX_tbuffer", &extensionNames) )
{
_GLEE_3DFX_tbuffer = GL_TRUE;
__GLeeLink_GL_3DFX_tbuffer();
}
if (__GLeeCheckExtension("GL_EXT_multisample", &extensionNames) )
{
_GLEE_EXT_multisample = GL_TRUE;
__GLeeLink_GL_EXT_multisample();
}
if (__GLeeCheckExtension("GL_SGIX_vertex_preclip", &extensionNames) )
{
_GLEE_SGIX_vertex_preclip = GL_TRUE;
__GLeeLink_GL_SGIX_vertex_preclip();
}
if (__GLeeCheckExtension("GL_SGIX_convolution_accuracy", &extensionNames) )
{
_GLEE_SGIX_convolution_accuracy = GL_TRUE;
__GLeeLink_GL_SGIX_convolution_accuracy();
}
if (__GLeeCheckExtension("GL_SGIX_resample", &extensionNames) )
{
_GLEE_SGIX_resample = GL_TRUE;
__GLeeLink_GL_SGIX_resample();
}
if (__GLeeCheckExtension("GL_SGIS_point_line_texgen", &extensionNames) )
{
_GLEE_SGIS_point_line_texgen = GL_TRUE;
__GLeeLink_GL_SGIS_point_line_texgen();
}
if (__GLeeCheckExtension("GL_SGIS_texture_color_mask", &extensionNames) )
{
_GLEE_SGIS_texture_color_mask = GL_TRUE;
__GLeeLink_GL_SGIS_texture_color_mask();
}
if (__GLeeCheckExtension("GL_EXT_texture_env_dot3", &extensionNames) )
{
_GLEE_EXT_texture_env_dot3 = GL_TRUE;
__GLeeLink_GL_EXT_texture_env_dot3();
}
if (__GLeeCheckExtension("GL_ATI_texture_mirror_once", &extensionNames) )
{
_GLEE_ATI_texture_mirror_once = GL_TRUE;
__GLeeLink_GL_ATI_texture_mirror_once();
}
if (__GLeeCheckExtension("GL_NV_fence", &extensionNames) )
{
_GLEE_NV_fence = GL_TRUE;
__GLeeLink_GL_NV_fence();
}
if (__GLeeCheckExtension("GL_IBM_texture_mirrored_repeat", &extensionNames) )
{
_GLEE_IBM_texture_mirrored_repeat = GL_TRUE;
__GLeeLink_GL_IBM_texture_mirrored_repeat();
}
if (__GLeeCheckExtension("GL_NV_evaluators", &extensionNames) )
{
_GLEE_NV_evaluators = GL_TRUE;
__GLeeLink_GL_NV_evaluators();
}
if (__GLeeCheckExtension("GL_NV_packed_depth_stencil", &extensionNames) )
{
_GLEE_NV_packed_depth_stencil = GL_TRUE;
__GLeeLink_GL_NV_packed_depth_stencil();
}
if (__GLeeCheckExtension("GL_NV_register_combiners2", &extensionNames) )
{
_GLEE_NV_register_combiners2 = GL_TRUE;
__GLeeLink_GL_NV_register_combiners2();
}
if (__GLeeCheckExtension("GL_NV_texture_compression_vtc", &extensionNames) )
{
_GLEE_NV_texture_compression_vtc = GL_TRUE;
__GLeeLink_GL_NV_texture_compression_vtc();
}
if (__GLeeCheckExtension("GL_NV_texture_rectangle", &extensionNames) )
{
_GLEE_NV_texture_rectangle = GL_TRUE;
__GLeeLink_GL_NV_texture_rectangle();
}
if (__GLeeCheckExtension("GL_NV_texture_shader", &extensionNames) )
{
_GLEE_NV_texture_shader = GL_TRUE;
__GLeeLink_GL_NV_texture_shader();
}
if (__GLeeCheckExtension("GL_NV_texture_shader2", &extensionNames) )
{
_GLEE_NV_texture_shader2 = GL_TRUE;
__GLeeLink_GL_NV_texture_shader2();
}
if (__GLeeCheckExtension("GL_NV_vertex_array_range2", &extensionNames) )
{
_GLEE_NV_vertex_array_range2 = GL_TRUE;
__GLeeLink_GL_NV_vertex_array_range2();
}
if (__GLeeCheckExtension("GL_NV_vertex_program", &extensionNames) )
{
_GLEE_NV_vertex_program = GL_TRUE;
__GLeeLink_GL_NV_vertex_program();
}
if (__GLeeCheckExtension("GL_SGIX_texture_coordinate_clamp", &extensionNames) )
{
_GLEE_SGIX_texture_coordinate_clamp = GL_TRUE;
__GLeeLink_GL_SGIX_texture_coordinate_clamp();
}
if (__GLeeCheckExtension("GL_SGIX_scalebias_hint", &extensionNames) )
{
_GLEE_SGIX_scalebias_hint = GL_TRUE;
__GLeeLink_GL_SGIX_scalebias_hint();
}
if (__GLeeCheckExtension("GL_OML_interlace", &extensionNames) )
{
_GLEE_OML_interlace = GL_TRUE;
__GLeeLink_GL_OML_interlace();
}
if (__GLeeCheckExtension("GL_OML_subsample", &extensionNames) )
{
_GLEE_OML_subsample = GL_TRUE;
__GLeeLink_GL_OML_subsample();
}
if (__GLeeCheckExtension("GL_OML_resample", &extensionNames) )
{
_GLEE_OML_resample = GL_TRUE;
__GLeeLink_GL_OML_resample();
}
if (__GLeeCheckExtension("GL_NV_copy_depth_to_color", &extensionNames) )
{
_GLEE_NV_copy_depth_to_color = GL_TRUE;
__GLeeLink_GL_NV_copy_depth_to_color();
}
if (__GLeeCheckExtension("GL_ATI_envmap_bumpmap", &extensionNames) )
{
_GLEE_ATI_envmap_bumpmap = GL_TRUE;
__GLeeLink_GL_ATI_envmap_bumpmap();
}
if (__GLeeCheckExtension("GL_ATI_fragment_shader", &extensionNames) )
{
_GLEE_ATI_fragment_shader = GL_TRUE;
__GLeeLink_GL_ATI_fragment_shader();
}
if (__GLeeCheckExtension("GL_ATI_pn_triangles", &extensionNames) )
{
_GLEE_ATI_pn_triangles = GL_TRUE;
__GLeeLink_GL_ATI_pn_triangles();
}
if (__GLeeCheckExtension("GL_ATI_vertex_array_object", &extensionNames) )
{
_GLEE_ATI_vertex_array_object = GL_TRUE;
__GLeeLink_GL_ATI_vertex_array_object();
}
if (__GLeeCheckExtension("GL_EXT_vertex_shader", &extensionNames) )
{
_GLEE_EXT_vertex_shader = GL_TRUE;
__GLeeLink_GL_EXT_vertex_shader();
}
if (__GLeeCheckExtension("GL_ATI_vertex_streams", &extensionNames) )
{
_GLEE_ATI_vertex_streams = GL_TRUE;
__GLeeLink_GL_ATI_vertex_streams();
}
if (__GLeeCheckExtension("GL_ATI_element_array", &extensionNames) )
{
_GLEE_ATI_element_array = GL_TRUE;
__GLeeLink_GL_ATI_element_array();
}
if (__GLeeCheckExtension("GL_SUN_mesh_array", &extensionNames) )
{
_GLEE_SUN_mesh_array = GL_TRUE;
__GLeeLink_GL_SUN_mesh_array();
}
if (__GLeeCheckExtension("GL_SUN_slice_accum", &extensionNames) )
{
_GLEE_SUN_slice_accum = GL_TRUE;
__GLeeLink_GL_SUN_slice_accum();
}
if (__GLeeCheckExtension("GL_NV_multisample_filter_hint", &extensionNames) )
{
_GLEE_NV_multisample_filter_hint = GL_TRUE;
__GLeeLink_GL_NV_multisample_filter_hint();
}
if (__GLeeCheckExtension("GL_NV_depth_clamp", &extensionNames) )
{
_GLEE_NV_depth_clamp = GL_TRUE;
__GLeeLink_GL_NV_depth_clamp();
}
if (__GLeeCheckExtension("GL_NV_occlusion_query", &extensionNames) )
{
_GLEE_NV_occlusion_query = GL_TRUE;
__GLeeLink_GL_NV_occlusion_query();
}
if (__GLeeCheckExtension("GL_NV_point_sprite", &extensionNames) )
{
_GLEE_NV_point_sprite = GL_TRUE;
__GLeeLink_GL_NV_point_sprite();
}
if (__GLeeCheckExtension("GL_NV_texture_shader3", &extensionNames) )
{
_GLEE_NV_texture_shader3 = GL_TRUE;
__GLeeLink_GL_NV_texture_shader3();
}
if (__GLeeCheckExtension("GL_NV_vertex_program1_1", &extensionNames) )
{
_GLEE_NV_vertex_program1_1 = GL_TRUE;
__GLeeLink_GL_NV_vertex_program1_1();
}
if (__GLeeCheckExtension("GL_EXT_shadow_funcs", &extensionNames) )
{
_GLEE_EXT_shadow_funcs = GL_TRUE;
__GLeeLink_GL_EXT_shadow_funcs();
}
if (__GLeeCheckExtension("GL_EXT_stencil_two_side", &extensionNames) )
{
_GLEE_EXT_stencil_two_side = GL_TRUE;
__GLeeLink_GL_EXT_stencil_two_side();
}
if (__GLeeCheckExtension("GL_ATI_text_fragment_shader", &extensionNames) )
{
_GLEE_ATI_text_fragment_shader = GL_TRUE;
__GLeeLink_GL_ATI_text_fragment_shader();
}
if (__GLeeCheckExtension("GL_APPLE_client_storage", &extensionNames) )
{
_GLEE_APPLE_client_storage = GL_TRUE;
__GLeeLink_GL_APPLE_client_storage();
}
if (__GLeeCheckExtension("GL_APPLE_element_array", &extensionNames) )
{
_GLEE_APPLE_element_array = GL_TRUE;
__GLeeLink_GL_APPLE_element_array();
}
if (__GLeeCheckExtension("GL_APPLE_fence", &extensionNames) )
{
_GLEE_APPLE_fence = GL_TRUE;
__GLeeLink_GL_APPLE_fence();
}
if (__GLeeCheckExtension("GL_APPLE_vertex_array_object", &extensionNames) )
{
_GLEE_APPLE_vertex_array_object = GL_TRUE;
__GLeeLink_GL_APPLE_vertex_array_object();
}
if (__GLeeCheckExtension("GL_APPLE_vertex_array_range", &extensionNames) )
{
_GLEE_APPLE_vertex_array_range = GL_TRUE;
__GLeeLink_GL_APPLE_vertex_array_range();
}
if (__GLeeCheckExtension("GL_APPLE_ycbcr_422", &extensionNames) )
{
_GLEE_APPLE_ycbcr_422 = GL_TRUE;
__GLeeLink_GL_APPLE_ycbcr_422();
}
if (__GLeeCheckExtension("GL_S3_s3tc", &extensionNames) )
{
_GLEE_S3_s3tc = GL_TRUE;
__GLeeLink_GL_S3_s3tc();
}
if (__GLeeCheckExtension("GL_ATI_draw_buffers", &extensionNames) )
{
_GLEE_ATI_draw_buffers = GL_TRUE;
__GLeeLink_GL_ATI_draw_buffers();
}
if (__GLeeCheckExtension("GL_ATI_pixel_format_float", &extensionNames) )
{
_GLEE_ATI_pixel_format_float = GL_TRUE;
__GLeeLink_GL_ATI_pixel_format_float();
}
if (__GLeeCheckExtension("GL_ATI_texture_env_combine3", &extensionNames) )
{
_GLEE_ATI_texture_env_combine3 = GL_TRUE;
__GLeeLink_GL_ATI_texture_env_combine3();
}
if (__GLeeCheckExtension("GL_ATI_texture_float", &extensionNames) )
{
_GLEE_ATI_texture_float = GL_TRUE;
__GLeeLink_GL_ATI_texture_float();
}
if (__GLeeCheckExtension("GL_NV_float_buffer", &extensionNames) )
{
_GLEE_NV_float_buffer = GL_TRUE;
__GLeeLink_GL_NV_float_buffer();
}
if (__GLeeCheckExtension("GL_NV_fragment_program", &extensionNames) )
{
_GLEE_NV_fragment_program = GL_TRUE;
__GLeeLink_GL_NV_fragment_program();
}
if (__GLeeCheckExtension("GL_NV_half_float", &extensionNames) )
{
_GLEE_NV_half_float = GL_TRUE;
__GLeeLink_GL_NV_half_float();
}
if (__GLeeCheckExtension("GL_NV_pixel_data_range", &extensionNames) )
{
_GLEE_NV_pixel_data_range = GL_TRUE;
__GLeeLink_GL_NV_pixel_data_range();
}
if (__GLeeCheckExtension("GL_NV_primitive_restart", &extensionNames) )
{
_GLEE_NV_primitive_restart = GL_TRUE;
__GLeeLink_GL_NV_primitive_restart();
}
if (__GLeeCheckExtension("GL_NV_texture_expand_normal", &extensionNames) )
{
_GLEE_NV_texture_expand_normal = GL_TRUE;
__GLeeLink_GL_NV_texture_expand_normal();
}
if (__GLeeCheckExtension("GL_NV_vertex_program2", &extensionNames) )
{
_GLEE_NV_vertex_program2 = GL_TRUE;
__GLeeLink_GL_NV_vertex_program2();
}
if (__GLeeCheckExtension("GL_ATI_map_object_buffer", &extensionNames) )
{
_GLEE_ATI_map_object_buffer = GL_TRUE;
__GLeeLink_GL_ATI_map_object_buffer();
}
if (__GLeeCheckExtension("GL_ATI_separate_stencil", &extensionNames) )
{
_GLEE_ATI_separate_stencil = GL_TRUE;
__GLeeLink_GL_ATI_separate_stencil();
}
if (__GLeeCheckExtension("GL_ATI_vertex_attrib_array_object", &extensionNames) )
{
_GLEE_ATI_vertex_attrib_array_object = GL_TRUE;
__GLeeLink_GL_ATI_vertex_attrib_array_object();
}
if (__GLeeCheckExtension("GL_OES_read_format", &extensionNames) )
{
_GLEE_OES_read_format = GL_TRUE;
__GLeeLink_GL_OES_read_format();
}
if (__GLeeCheckExtension("GL_EXT_depth_bounds_test", &extensionNames) )
{
_GLEE_EXT_depth_bounds_test = GL_TRUE;
__GLeeLink_GL_EXT_depth_bounds_test();
}
if (__GLeeCheckExtension("GL_EXT_texture_mirror_clamp", &extensionNames) )
{
_GLEE_EXT_texture_mirror_clamp = GL_TRUE;
__GLeeLink_GL_EXT_texture_mirror_clamp();
}
if (__GLeeCheckExtension("GL_EXT_blend_equation_separate", &extensionNames) )
{
_GLEE_EXT_blend_equation_separate = GL_TRUE;
__GLeeLink_GL_EXT_blend_equation_separate();
}
if (__GLeeCheckExtension("GL_MESA_pack_invert", &extensionNames) )
{
_GLEE_MESA_pack_invert = GL_TRUE;
__GLeeLink_GL_MESA_pack_invert();
}
if (__GLeeCheckExtension("GL_MESA_ycbcr_texture", &extensionNames) )
{
_GLEE_MESA_ycbcr_texture = GL_TRUE;
__GLeeLink_GL_MESA_ycbcr_texture();
}
if (__GLeeCheckExtension("GL_EXT_pixel_buffer_object", &extensionNames) )
{
_GLEE_EXT_pixel_buffer_object = GL_TRUE;
__GLeeLink_GL_EXT_pixel_buffer_object();
}
if (__GLeeCheckExtension("GL_NV_fragment_program_option", &extensionNames) )
{
_GLEE_NV_fragment_program_option = GL_TRUE;
__GLeeLink_GL_NV_fragment_program_option();
}
if (__GLeeCheckExtension("GL_NV_fragment_program2", &extensionNames) )
{
_GLEE_NV_fragment_program2 = GL_TRUE;
__GLeeLink_GL_NV_fragment_program2();
}
if (__GLeeCheckExtension("GL_NV_vertex_program2_option", &extensionNames) )
{
_GLEE_NV_vertex_program2_option = GL_TRUE;
__GLeeLink_GL_NV_vertex_program2_option();
}
if (__GLeeCheckExtension("GL_NV_vertex_program3", &extensionNames) )
{
_GLEE_NV_vertex_program3 = GL_TRUE;
__GLeeLink_GL_NV_vertex_program3();
}
if (__GLeeCheckExtension("GL_EXT_framebuffer_object", &extensionNames) )
{
_GLEE_EXT_framebuffer_object = GL_TRUE;
__GLeeLink_GL_EXT_framebuffer_object();
}
if (__GLeeCheckExtension("GL_GREMEDY_string_marker", &extensionNames) )
{
_GLEE_GREMEDY_string_marker = GL_TRUE;
__GLeeLink_GL_GREMEDY_string_marker();
}
if (__GLeeCheckExtension("GL_EXT_packed_depth_stencil", &extensionNames) )
{
_GLEE_EXT_packed_depth_stencil = GL_TRUE;
__GLeeLink_GL_EXT_packed_depth_stencil();
}
if (__GLeeCheckExtension("GL_EXT_stencil_clear_tag", &extensionNames) )
{
_GLEE_EXT_stencil_clear_tag = GL_TRUE;
__GLeeLink_GL_EXT_stencil_clear_tag();
}
if (__GLeeCheckExtension("GL_EXT_texture_sRGB", &extensionNames) )
{
_GLEE_EXT_texture_sRGB = GL_TRUE;
__GLeeLink_GL_EXT_texture_sRGB();
}
if (__GLeeCheckExtension("GL_EXT_framebuffer_blit", &extensionNames) )
{
_GLEE_EXT_framebuffer_blit = GL_TRUE;
__GLeeLink_GL_EXT_framebuffer_blit();
}
if (__GLeeCheckExtension("GL_EXT_framebuffer_multisample", &extensionNames) )
{
_GLEE_EXT_framebuffer_multisample = GL_TRUE;
__GLeeLink_GL_EXT_framebuffer_multisample();
}
if (__GLeeCheckExtension("GL_MESAX_texture_stack", &extensionNames) )
{
_GLEE_MESAX_texture_stack = GL_TRUE;
__GLeeLink_GL_MESAX_texture_stack();
}
if (__GLeeCheckExtension("GL_EXT_timer_query", &extensionNames) )
{
_GLEE_EXT_timer_query = GL_TRUE;
__GLeeLink_GL_EXT_timer_query();
}
if (__GLeeCheckExtension("GL_EXT_gpu_program_parameters", &extensionNames) )
{
_GLEE_EXT_gpu_program_parameters = GL_TRUE;
__GLeeLink_GL_EXT_gpu_program_parameters();
}
if (__GLeeCheckExtension("GL_APPLE_flush_buffer_range", &extensionNames) )
{
_GLEE_APPLE_flush_buffer_range = GL_TRUE;
__GLeeLink_GL_APPLE_flush_buffer_range();
}
if (__GLeeCheckExtension("GL_EXT_gpu_shader4", &extensionNames) )
{
_GLEE_EXT_gpu_shader4 = GL_TRUE;
__GLeeLink_GL_EXT_gpu_shader4();
}
if (__GLeeCheckExtension("GL_EXT_draw_instanced", &extensionNames) )
{
_GLEE_EXT_draw_instanced = GL_TRUE;
__GLeeLink_GL_EXT_draw_instanced();
}
if (__GLeeCheckExtension("GL_EXT_packed_float", &extensionNames) )
{
_GLEE_EXT_packed_float = GL_TRUE;
__GLeeLink_GL_EXT_packed_float();
}
if (__GLeeCheckExtension("GL_EXT_texture_array", &extensionNames) )
{
_GLEE_EXT_texture_array = GL_TRUE;
__GLeeLink_GL_EXT_texture_array();
}
if (__GLeeCheckExtension("GL_EXT_texture_buffer_object", &extensionNames) )
{
_GLEE_EXT_texture_buffer_object = GL_TRUE;
__GLeeLink_GL_EXT_texture_buffer_object();
}
if (__GLeeCheckExtension("GL_EXT_texture_compression_latc", &extensionNames) )
{
_GLEE_EXT_texture_compression_latc = GL_TRUE;
__GLeeLink_GL_EXT_texture_compression_latc();
}
if (__GLeeCheckExtension("GL_EXT_texture_compression_rgtc", &extensionNames) )
{
_GLEE_EXT_texture_compression_rgtc = GL_TRUE;
__GLeeLink_GL_EXT_texture_compression_rgtc();
}
if (__GLeeCheckExtension("GL_EXT_texture_shared_exponent", &extensionNames) )
{
_GLEE_EXT_texture_shared_exponent = GL_TRUE;
__GLeeLink_GL_EXT_texture_shared_exponent();
}
if (__GLeeCheckExtension("GL_NV_depth_buffer_float", &extensionNames) )
{
_GLEE_NV_depth_buffer_float = GL_TRUE;
__GLeeLink_GL_NV_depth_buffer_float();
}
if (__GLeeCheckExtension("GL_NV_framebuffer_multisample_coverage", &extensionNames) )
{
_GLEE_NV_framebuffer_multisample_coverage = GL_TRUE;
__GLeeLink_GL_NV_framebuffer_multisample_coverage();
}
if (__GLeeCheckExtension("GL_EXT_framebuffer_sRGB", &extensionNames) )
{
_GLEE_EXT_framebuffer_sRGB = GL_TRUE;
__GLeeLink_GL_EXT_framebuffer_sRGB();
}
if (__GLeeCheckExtension("GL_NV_geometry_shader4", &extensionNames) )
{
_GLEE_NV_geometry_shader4 = GL_TRUE;
__GLeeLink_GL_NV_geometry_shader4();
}
if (__GLeeCheckExtension("GL_NV_parameter_buffer_object", &extensionNames) )
{
_GLEE_NV_parameter_buffer_object = GL_TRUE;
__GLeeLink_GL_NV_parameter_buffer_object();
}
if (__GLeeCheckExtension("GL_EXT_draw_buffers2", &extensionNames) )
{
_GLEE_EXT_draw_buffers2 = GL_TRUE;
__GLeeLink_GL_EXT_draw_buffers2();
}
if (__GLeeCheckExtension("GL_NV_transform_feedback", &extensionNames) )
{
_GLEE_NV_transform_feedback = GL_TRUE;
__GLeeLink_GL_NV_transform_feedback();
}
if (__GLeeCheckExtension("GL_EXT_bindable_uniform", &extensionNames) )
{
_GLEE_EXT_bindable_uniform = GL_TRUE;
__GLeeLink_GL_EXT_bindable_uniform();
}
if (__GLeeCheckExtension("GL_EXT_texture_integer", &extensionNames) )
{
_GLEE_EXT_texture_integer = GL_TRUE;
__GLeeLink_GL_EXT_texture_integer();
}
if (__GLeeCheckExtension("GL_GREMEDY_frame_terminator", &extensionNames) )
{
_GLEE_GREMEDY_frame_terminator = GL_TRUE;
__GLeeLink_GL_GREMEDY_frame_terminator();
}
if (__GLeeCheckExtension("GL_NV_conditional_render", &extensionNames) )
{
_GLEE_NV_conditional_render = GL_TRUE;
__GLeeLink_GL_NV_conditional_render();
}
if (__GLeeCheckExtension("GL_NV_present_video", &extensionNames) )
{
_GLEE_NV_present_video = GL_TRUE;
__GLeeLink_GL_NV_present_video();
}
if (__GLeeCheckExtension("GL_EXT_transform_feedback", &extensionNames) )
{
_GLEE_EXT_transform_feedback = GL_TRUE;
__GLeeLink_GL_EXT_transform_feedback();
}
if (__GLeeCheckExtension("GL_EXT_direct_state_access", &extensionNames) )
{
_GLEE_EXT_direct_state_access = GL_TRUE;
__GLeeLink_GL_EXT_direct_state_access();
}
if (__GLeeCheckExtension("GL_EXT_vertex_array_bgra", &extensionNames) )
{
_GLEE_EXT_vertex_array_bgra = GL_TRUE;
__GLeeLink_GL_EXT_vertex_array_bgra();
}
if (__GLeeCheckExtension("GL_EXT_texture_swizzle", &extensionNames) )
{
_GLEE_EXT_texture_swizzle = GL_TRUE;
__GLeeLink_GL_EXT_texture_swizzle();
}
if (__GLeeCheckExtension("GL_NV_explicit_multisample", &extensionNames) )
{
_GLEE_NV_explicit_multisample = GL_TRUE;
__GLeeLink_GL_NV_explicit_multisample();
}
if (__GLeeCheckExtension("GL_NV_transform_feedback2", &extensionNames) )
{
_GLEE_NV_transform_feedback2 = GL_TRUE;
__GLeeLink_GL_NV_transform_feedback2();
}
if (__GLeeCheckExtension("GL_SGIX_texture_select", &extensionNames) )
{
_GLEE_SGIX_texture_select = GL_TRUE;
__GLeeLink_GL_SGIX_texture_select();
}
if (__GLeeCheckExtension("GL_INGR_blend_func_separate", &extensionNames) )
{
_GLEE_INGR_blend_func_separate = GL_TRUE;
__GLeeLink_GL_INGR_blend_func_separate();
}
if (__GLeeCheckExtension("GL_SGIX_depth_pass_instrument", &extensionNames) )
{
_GLEE_SGIX_depth_pass_instrument = GL_TRUE;
__GLeeLink_GL_SGIX_depth_pass_instrument();
}
if (__GLeeCheckExtension("GL_SGIX_igloo_interface", &extensionNames) )
{
_GLEE_SGIX_igloo_interface = GL_TRUE;
__GLeeLink_GL_SGIX_igloo_interface();
}
if (__GLeeCheckExtension("GL_EXT_fragment_lighting", &extensionNames) )
{
_GLEE_EXT_fragment_lighting = GL_TRUE;
__GLeeLink_GL_EXT_fragment_lighting();
}
if (__GLeeCheckExtension("GL_EXT_geometry_shader4", &extensionNames) )
{
_GLEE_EXT_geometry_shader4 = GL_TRUE;
__GLeeLink_GL_EXT_geometry_shader4();
}
if (__GLeeCheckExtension("GL_EXT_scene_marker", &extensionNames) )
{
_GLEE_EXT_scene_marker = GL_TRUE;
__GLeeLink_GL_EXT_scene_marker();
}
if (__GLeeCheckExtension("GL_EXT_texture_compression_dxt1", &extensionNames) )
{
_GLEE_EXT_texture_compression_dxt1 = GL_TRUE;
__GLeeLink_GL_EXT_texture_compression_dxt1();
}
if (__GLeeCheckExtension("GL_EXT_texture_env", &extensionNames) )
{
_GLEE_EXT_texture_env = GL_TRUE;
__GLeeLink_GL_EXT_texture_env();
}
if (__GLeeCheckExtension("GL_IBM_static_data", &extensionNames) )
{
_GLEE_IBM_static_data = GL_TRUE;
__GLeeLink_GL_IBM_static_data();
}
if (__GLeeCheckExtension("GL_NV_gpu_program4", &extensionNames) )
{
_GLEE_NV_gpu_program4 = GL_TRUE;
__GLeeLink_GL_NV_gpu_program4();
}
if (__GLeeCheckExtension("GL_OES_byte_coordinates", &extensionNames) )
{
_GLEE_OES_byte_coordinates = GL_TRUE;
__GLeeLink_GL_OES_byte_coordinates();
}
if (__GLeeCheckExtension("GL_OES_compressed_paletted_texture", &extensionNames) )
{
_GLEE_OES_compressed_paletted_texture = GL_TRUE;
__GLeeLink_GL_OES_compressed_paletted_texture();
}
if (__GLeeCheckExtension("GL_OES_single_precision", &extensionNames) )
{
_GLEE_OES_single_precision = GL_TRUE;
__GLeeLink_GL_OES_single_precision();
}
if (__GLeeCheckExtension("GL_SGIX_pixel_texture_bits", &extensionNames) )
{
_GLEE_SGIX_pixel_texture_bits = GL_TRUE;
__GLeeLink_GL_SGIX_pixel_texture_bits();
}
if (__GLeeCheckExtension("GL_SGIX_texture_range", &extensionNames) )
{
_GLEE_SGIX_texture_range = GL_TRUE;
__GLeeLink_GL_SGIX_texture_range();
}
#ifdef WIN32
if (__GLeeCheckExtension("WGL_ARB_buffer_region", &extensionNames) )
{
_GLEE_WGL_ARB_buffer_region = GL_TRUE;
__GLeeLink_WGL_ARB_buffer_region();
}
if (__GLeeCheckExtension("WGL_ARB_multisample", &extensionNames) )
{
_GLEE_WGL_ARB_multisample = GL_TRUE;
__GLeeLink_WGL_ARB_multisample();
}
if (__GLeeCheckExtension("WGL_ARB_extensions_string", &extensionNames) )
{
_GLEE_WGL_ARB_extensions_string = GL_TRUE;
__GLeeLink_WGL_ARB_extensions_string();
}
if (__GLeeCheckExtension("WGL_ARB_pixel_format", &extensionNames) )
{
_GLEE_WGL_ARB_pixel_format = GL_TRUE;
__GLeeLink_WGL_ARB_pixel_format();
}
if (__GLeeCheckExtension("WGL_ARB_make_current_read", &extensionNames) )
{
_GLEE_WGL_ARB_make_current_read = GL_TRUE;
__GLeeLink_WGL_ARB_make_current_read();
}
if (__GLeeCheckExtension("WGL_ARB_pbuffer", &extensionNames) )
{
_GLEE_WGL_ARB_pbuffer = GL_TRUE;
__GLeeLink_WGL_ARB_pbuffer();
}
if (__GLeeCheckExtension("WGL_ARB_render_texture", &extensionNames) )
{
_GLEE_WGL_ARB_render_texture = GL_TRUE;
__GLeeLink_WGL_ARB_render_texture();
}
if (__GLeeCheckExtension("WGL_ARB_pixel_format_float", &extensionNames) )
{
_GLEE_WGL_ARB_pixel_format_float = GL_TRUE;
__GLeeLink_WGL_ARB_pixel_format_float();
}
if (__GLeeCheckExtension("WGL_ARB_create_context", &extensionNames) )
{
_GLEE_WGL_ARB_create_context = GL_TRUE;
__GLeeLink_WGL_ARB_create_context();
}
if (__GLeeCheckExtension("WGL_EXT_make_current_read", &extensionNames) )
{
_GLEE_WGL_EXT_make_current_read = GL_TRUE;
__GLeeLink_WGL_EXT_make_current_read();
}
if (__GLeeCheckExtension("WGL_EXT_pixel_format", &extensionNames) )
{
_GLEE_WGL_EXT_pixel_format = GL_TRUE;
__GLeeLink_WGL_EXT_pixel_format();
}
if (__GLeeCheckExtension("WGL_EXT_pbuffer", &extensionNames) )
{
_GLEE_WGL_EXT_pbuffer = GL_TRUE;
__GLeeLink_WGL_EXT_pbuffer();
}
if (__GLeeCheckExtension("WGL_EXT_depth_float", &extensionNames) )
{
_GLEE_WGL_EXT_depth_float = GL_TRUE;
__GLeeLink_WGL_EXT_depth_float();
}
if (__GLeeCheckExtension("WGL_3DFX_multisample", &extensionNames) )
{
_GLEE_WGL_3DFX_multisample = GL_TRUE;
__GLeeLink_WGL_3DFX_multisample();
}
if (__GLeeCheckExtension("WGL_EXT_multisample", &extensionNames) )
{
_GLEE_WGL_EXT_multisample = GL_TRUE;
__GLeeLink_WGL_EXT_multisample();
}
if (__GLeeCheckExtension("WGL_I3D_digital_video_control", &extensionNames) )
{
_GLEE_WGL_I3D_digital_video_control = GL_TRUE;
__GLeeLink_WGL_I3D_digital_video_control();
}
if (__GLeeCheckExtension("WGL_I3D_gamma", &extensionNames) )
{
_GLEE_WGL_I3D_gamma = GL_TRUE;
__GLeeLink_WGL_I3D_gamma();
}
if (__GLeeCheckExtension("WGL_I3D_genlock", &extensionNames) )
{
_GLEE_WGL_I3D_genlock = GL_TRUE;
__GLeeLink_WGL_I3D_genlock();
}
if (__GLeeCheckExtension("WGL_I3D_image_buffer", &extensionNames) )
{
_GLEE_WGL_I3D_image_buffer = GL_TRUE;
__GLeeLink_WGL_I3D_image_buffer();
}
if (__GLeeCheckExtension("WGL_I3D_swap_frame_lock", &extensionNames) )
{
_GLEE_WGL_I3D_swap_frame_lock = GL_TRUE;
__GLeeLink_WGL_I3D_swap_frame_lock();
}
if (__GLeeCheckExtension("WGL_NV_render_depth_texture", &extensionNames) )
{
_GLEE_WGL_NV_render_depth_texture = GL_TRUE;
__GLeeLink_WGL_NV_render_depth_texture();
}
if (__GLeeCheckExtension("WGL_NV_render_texture_rectangle", &extensionNames) )
{
_GLEE_WGL_NV_render_texture_rectangle = GL_TRUE;
__GLeeLink_WGL_NV_render_texture_rectangle();
}
if (__GLeeCheckExtension("WGL_ATI_pixel_format_float", &extensionNames) )
{
_GLEE_WGL_ATI_pixel_format_float = GL_TRUE;
__GLeeLink_WGL_ATI_pixel_format_float();
}
if (__GLeeCheckExtension("WGL_NV_float_buffer", &extensionNames) )
{
_GLEE_WGL_NV_float_buffer = GL_TRUE;
__GLeeLink_WGL_NV_float_buffer();
}
if (__GLeeCheckExtension("WGL_3DL_stereo_control", &extensionNames) )
{
_GLEE_WGL_3DL_stereo_control = GL_TRUE;
__GLeeLink_WGL_3DL_stereo_control();
}
if (__GLeeCheckExtension("WGL_EXT_pixel_format_packed_float", &extensionNames) )
{
_GLEE_WGL_EXT_pixel_format_packed_float = GL_TRUE;
__GLeeLink_WGL_EXT_pixel_format_packed_float();
}
if (__GLeeCheckExtension("WGL_EXT_framebuffer_sRGB", &extensionNames) )
{
_GLEE_WGL_EXT_framebuffer_sRGB = GL_TRUE;
__GLeeLink_WGL_EXT_framebuffer_sRGB();
}
if (__GLeeCheckExtension("WGL_NV_present_video", &extensionNames) )
{
_GLEE_WGL_NV_present_video = GL_TRUE;
__GLeeLink_WGL_NV_present_video();
}
if (__GLeeCheckExtension("WGL_NV_swap_group", &extensionNames) )
{
_GLEE_WGL_NV_swap_group = GL_TRUE;
__GLeeLink_WGL_NV_swap_group();
}
if (__GLeeCheckExtension("WGL_NV_gpu_affinity", &extensionNames) )
{
_GLEE_WGL_NV_gpu_affinity = GL_TRUE;
__GLeeLink_WGL_NV_gpu_affinity();
}
if (__GLeeCheckExtension("WGL_EXT_display_color_table", &extensionNames) )
{
_GLEE_WGL_EXT_display_color_table = GL_TRUE;
__GLeeLink_WGL_EXT_display_color_table();
}
if (__GLeeCheckExtension("WGL_EXT_extensions_string", &extensionNames) )
{
_GLEE_WGL_EXT_extensions_string = GL_TRUE;
__GLeeLink_WGL_EXT_extensions_string();
}
if (__GLeeCheckExtension("WGL_EXT_swap_control", &extensionNames) )
{
_GLEE_WGL_EXT_swap_control = GL_TRUE;
__GLeeLink_WGL_EXT_swap_control();
}
if (__GLeeCheckExtension("WGL_NV_vertex_array_range", &extensionNames) )
{
_GLEE_WGL_NV_vertex_array_range = GL_TRUE;
__GLeeLink_WGL_NV_vertex_array_range();
}
if (__GLeeCheckExtension("WGL_OML_sync_control", &extensionNames) )
{
_GLEE_WGL_OML_sync_control = GL_TRUE;
__GLeeLink_WGL_OML_sync_control();
}
if (__GLeeCheckExtension("WGL_I3D_swap_frame_usage", &extensionNames) )
{
_GLEE_WGL_I3D_swap_frame_usage = GL_TRUE;
__GLeeLink_WGL_I3D_swap_frame_usage();
}
if (__GLeeCheckExtension("WGL_NV_video_output", &extensionNames) )
{
_GLEE_WGL_NV_video_output = GL_TRUE;
__GLeeLink_WGL_NV_video_output();
}
#elif defined(__APPLE__) || defined(__APPLE_CC__)
#else /* GLX */
if (__GLeeCheckExtension("GLX_VERSION_1_3", &extensionNames) )
{
_GLEE_GLX_VERSION_1_3 = GL_TRUE;
__GLeeLink_GLX_VERSION_1_3();
}
if (__GLeeCheckExtension("GLX_VERSION_1_4", &extensionNames) )
{
_GLEE_GLX_VERSION_1_4 = GL_TRUE;
__GLeeLink_GLX_VERSION_1_4();
}
if (__GLeeCheckExtension("GLX_ARB_multisample", &extensionNames) )
{
_GLEE_GLX_ARB_multisample = GL_TRUE;
__GLeeLink_GLX_ARB_multisample();
}
if (__GLeeCheckExtension("GLX_ARB_fbconfig_float", &extensionNames) )
{
_GLEE_GLX_ARB_fbconfig_float = GL_TRUE;
__GLeeLink_GLX_ARB_fbconfig_float();
}
if (__GLeeCheckExtension("GLX_ARB_create_context", &extensionNames) )
{
_GLEE_GLX_ARB_create_context = GL_TRUE;
__GLeeLink_GLX_ARB_create_context();
}
if (__GLeeCheckExtension("GLX_SGIS_multisample", &extensionNames) )
{
_GLEE_GLX_SGIS_multisample = GL_TRUE;
__GLeeLink_GLX_SGIS_multisample();
}
if (__GLeeCheckExtension("GLX_EXT_visual_info", &extensionNames) )
{
_GLEE_GLX_EXT_visual_info = GL_TRUE;
__GLeeLink_GLX_EXT_visual_info();
}
if (__GLeeCheckExtension("GLX_SGI_swap_control", &extensionNames) )
{
_GLEE_GLX_SGI_swap_control = GL_TRUE;
__GLeeLink_GLX_SGI_swap_control();
}
if (__GLeeCheckExtension("GLX_SGI_video_sync", &extensionNames) )
{
_GLEE_GLX_SGI_video_sync = GL_TRUE;
__GLeeLink_GLX_SGI_video_sync();
}
if (__GLeeCheckExtension("GLX_SGI_make_current_read", &extensionNames) )
{
_GLEE_GLX_SGI_make_current_read = GL_TRUE;
__GLeeLink_GLX_SGI_make_current_read();
}
if (__GLeeCheckExtension("GLX_EXT_visual_rating", &extensionNames) )
{
_GLEE_GLX_EXT_visual_rating = GL_TRUE;
__GLeeLink_GLX_EXT_visual_rating();
}
if (__GLeeCheckExtension("GLX_EXT_import_context", &extensionNames) )
{
_GLEE_GLX_EXT_import_context = GL_TRUE;
__GLeeLink_GLX_EXT_import_context();
}
if (__GLeeCheckExtension("GLX_SGIX_fbconfig", &extensionNames) )
{
_GLEE_GLX_SGIX_fbconfig = GL_TRUE;
__GLeeLink_GLX_SGIX_fbconfig();
}
if (__GLeeCheckExtension("GLX_SGIX_pbuffer", &extensionNames) )
{
_GLEE_GLX_SGIX_pbuffer = GL_TRUE;
__GLeeLink_GLX_SGIX_pbuffer();
}
if (__GLeeCheckExtension("GLX_SGI_cushion", &extensionNames) )
{
_GLEE_GLX_SGI_cushion = GL_TRUE;
__GLeeLink_GLX_SGI_cushion();
}
if (__GLeeCheckExtension("GLX_SGIX_video_resize", &extensionNames) )
{
_GLEE_GLX_SGIX_video_resize = GL_TRUE;
__GLeeLink_GLX_SGIX_video_resize();
}
if (__GLeeCheckExtension("GLX_SGIX_swap_group", &extensionNames) )
{
_GLEE_GLX_SGIX_swap_group = GL_TRUE;
__GLeeLink_GLX_SGIX_swap_group();
}
if (__GLeeCheckExtension("GLX_SGIX_swap_barrier", &extensionNames) )
{
_GLEE_GLX_SGIX_swap_barrier = GL_TRUE;
__GLeeLink_GLX_SGIX_swap_barrier();
}
if (__GLeeCheckExtension("GLX_SGIS_blended_overlay", &extensionNames) )
{
_GLEE_GLX_SGIS_blended_overlay = GL_TRUE;
__GLeeLink_GLX_SGIS_blended_overlay();
}
if (__GLeeCheckExtension("GLX_SGIS_shared_multisample", &extensionNames) )
{
_GLEE_GLX_SGIS_shared_multisample = GL_TRUE;
__GLeeLink_GLX_SGIS_shared_multisample();
}
if (__GLeeCheckExtension("GLX_SUN_get_transparent_index", &extensionNames) )
{
_GLEE_GLX_SUN_get_transparent_index = GL_TRUE;
__GLeeLink_GLX_SUN_get_transparent_index();
}
if (__GLeeCheckExtension("GLX_3DFX_multisample", &extensionNames) )
{
_GLEE_GLX_3DFX_multisample = GL_TRUE;
__GLeeLink_GLX_3DFX_multisample();
}
if (__GLeeCheckExtension("GLX_MESA_copy_sub_buffer", &extensionNames) )
{
_GLEE_GLX_MESA_copy_sub_buffer = GL_TRUE;
__GLeeLink_GLX_MESA_copy_sub_buffer();
}
if (__GLeeCheckExtension("GLX_MESA_pixmap_colormap", &extensionNames) )
{
_GLEE_GLX_MESA_pixmap_colormap = GL_TRUE;
__GLeeLink_GLX_MESA_pixmap_colormap();
}
if (__GLeeCheckExtension("GLX_MESA_release_buffers", &extensionNames) )
{
_GLEE_GLX_MESA_release_buffers = GL_TRUE;
__GLeeLink_GLX_MESA_release_buffers();
}
if (__GLeeCheckExtension("GLX_MESA_set_3dfx_mode", &extensionNames) )
{
_GLEE_GLX_MESA_set_3dfx_mode = GL_TRUE;
__GLeeLink_GLX_MESA_set_3dfx_mode();
}
if (__GLeeCheckExtension("GLX_SGIX_visual_select_group", &extensionNames) )
{
_GLEE_GLX_SGIX_visual_select_group = GL_TRUE;
__GLeeLink_GLX_SGIX_visual_select_group();
}
if (__GLeeCheckExtension("GLX_OML_swap_method", &extensionNames) )
{
_GLEE_GLX_OML_swap_method = GL_TRUE;
__GLeeLink_GLX_OML_swap_method();
}
if (__GLeeCheckExtension("GLX_OML_sync_control", &extensionNames) )
{
_GLEE_GLX_OML_sync_control = GL_TRUE;
__GLeeLink_GLX_OML_sync_control();
}
if (__GLeeCheckExtension("GLX_NV_float_buffer", &extensionNames) )
{
_GLEE_GLX_NV_float_buffer = GL_TRUE;
__GLeeLink_GLX_NV_float_buffer();
}
if (__GLeeCheckExtension("GLX_SGIX_hyperpipe", &extensionNames) )
{
_GLEE_GLX_SGIX_hyperpipe = GL_TRUE;
__GLeeLink_GLX_SGIX_hyperpipe();
}
if (__GLeeCheckExtension("GLX_MESA_agp_offset", &extensionNames) )
{
_GLEE_GLX_MESA_agp_offset = GL_TRUE;
__GLeeLink_GLX_MESA_agp_offset();
}
if (__GLeeCheckExtension("GLX_EXT_fbconfig_packed_float", &extensionNames) )
{
_GLEE_GLX_EXT_fbconfig_packed_float = GL_TRUE;
__GLeeLink_GLX_EXT_fbconfig_packed_float();
}
if (__GLeeCheckExtension("GLX_EXT_framebuffer_sRGB", &extensionNames) )
{
_GLEE_GLX_EXT_framebuffer_sRGB = GL_TRUE;
__GLeeLink_GLX_EXT_framebuffer_sRGB();
}
if (__GLeeCheckExtension("GLX_EXT_texture_from_pixmap", &extensionNames) )
{
_GLEE_GLX_EXT_texture_from_pixmap = GL_TRUE;
__GLeeLink_GLX_EXT_texture_from_pixmap();
}
if (__GLeeCheckExtension("GLX_NV_present_video", &extensionNames) )
{
_GLEE_GLX_NV_present_video = GL_TRUE;
__GLeeLink_GLX_NV_present_video();
}
if (__GLeeCheckExtension("GLX_NV_video_out", &extensionNames) )
{
_GLEE_GLX_NV_video_out = GL_TRUE;
__GLeeLink_GLX_NV_video_out();
}
if (__GLeeCheckExtension("GLX_NV_swap_group", &extensionNames) )
{
_GLEE_GLX_NV_swap_group = GL_TRUE;
__GLeeLink_GLX_NV_swap_group();
}
if (__GLeeCheckExtension("GLX_EXT_scene_marker", &extensionNames) )
{
_GLEE_GLX_EXT_scene_marker = GL_TRUE;
__GLeeLink_GLX_EXT_scene_marker();
}
if (__GLeeCheckExtension("GLX_NV_video_output", &extensionNames) )
{
_GLEE_GLX_NV_video_output = GL_TRUE;
__GLeeLink_GLX_NV_video_output();
}
#endif /* end GLX */
__GLeeExtList_clean(&extensionNames);
return GL_TRUE;
}
| [
"[email protected]"
]
| [
[
[
1,
18171
]
]
]
|
2ac20693cb5784fcb652a52c7f829bcf11364f07 | 208475bcab65438eed5d8380f26eacd25eb58f70 | /ComuExe/IoSta.h | 9c5cb770435a48ef9f72c463f4fdc3e3c2ef9131 | []
| no_license | awzhang/MyWork | 83b3f0b9df5ff37330c0e976310d75593f806ec4 | 075ad5d0726c793a0c08f9158080a144e0bb5ea5 | refs/heads/master | 2021-01-18T07:57:03.219372 | 2011-07-05T02:41:55 | 2011-07-05T02:46:30 | 15,523,223 | 1 | 2 | null | null | null | null | GB18030 | C++ | false | false | 489 | h | #ifndef _IOSTA_H_
#define _IOSTA_H_
class CIoSta
{
public:
CIoSta();
~CIoSta();
int DealIOMsg(char *v_szbuf, DWORD v_dwlen, BYTE v_bytSrcSymb);
DWORD GetIoSta();
private:
int _Init();
int _Release();
void _SetIoSta( bool v_bSet, DWORD v_dwVal );
public:
private:
pthread_mutex_t m_MutexIoSta;
DWORD m_dwIoSta; // 仅用于一次性的IO信号,或者事后无法查询的IO信号或设备控制指令
};
#endif //#define _IOSTA_H_
| [
"[email protected]"
]
| [
[
[
1,
31
]
]
]
|
2fc59a60ec29cd92d62b406b5b33a1cb8360297e | 4031d76cff71165452918d1f42e920a50f255904 | /src/third_party/maart/utility/distance.h | 4f885d80278d333d8ca74f4e760f34dbf857d163 | []
| no_license | temporaer/seralign | c9ad6e66f941b71b55924f1436f447e443082a8d | fddea59c5d9ac3449a41184ddb2d20de8c71ec38 | refs/heads/master | 2016-08-04T07:42:00.631008 | 2009-02-04T17:26:27 | 2009-02-04T17:26:27 | 77,186 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,306 | h | /**
* @file utility/distance.h
*
* Defines distance functions.
*
* Copyright 2005 Steven Blackburn, http://www.beeka.org
*
* This file is part of the Music and Audio Retreival Tools (MaART).
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef maart_distanceH
#define maart_distanceH
#include <iostream>
#include <cmath>
#include <string>
#include <vector>
/**
* A function to make a vector from a standard C array of features.
* This is particularly useful for test data.
*/
template <class T>
const std::vector<T> to_vector(const T array[], size_t n)
{
std::vector<T> v(n);
for (unsigned int i=0; i<n; i++)
v[i] = array[i];
}
/**
* Function to stream a vector.
*/
template <class T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &v)
{
os << '(';
if (v.size() > 0)
{
os << v[0];
for (size_t n=1; n<v.size(); n++)
os << ',' << v[n];
}
os << ')';
return os;
}
//
// Comparison functions
//
/**
* Implements basic difference function.
* Returns a normalised difference (mean difference).
* Zero means that there is no difference. The more positive the number,
* the more difference there is between the two histograms.
*/
template <class T>
float basic_distance(const std::vector<T> &i, const std::vector<T> &j)
{
float diff = 0;
for (size_t n=0; n<i.size(); n++)
diff += fabs(i[n] - j[n]);
return diff / i.size();
}
/**
* Sum of Squares of the differences.
* This is has most of the benefits of the Euclidean distance but without
* the expense of calculating the square root. If comparing two distances,
* rather than iterpreting them then this is a good candidate. The square
* root of this function can be taken to arrive at the Euclidean distance,
* if you wish to maintain the same sort of 'scale' as the input vectors.
*
* Zero means that there is no difference. The more positive the number,
* the more difference there is between the two histograms.
*/
template <class T>
float sum_of_squares_distance(const std::vector<T> &i, const std::vector<T> &j)
{
float diff = 0;
for (size_t n=0; n<i.size(); n++)
diff += (i[n] - j[n]) * (i[n] - j[n]);
return diff;
}
/**
* Euclidean distance of the differences.
* In practice, the distinguishing ability of this is about the same as the
* basic average. It is a more expensive function to computate.
*
* Zero means that there is no difference. The more positive the number,
* the more difference there is between the two histograms.
*/
template <class T>
float euclidean_distance(const std::vector<T> &i, const std::vector<T> &j)
{
float diff = 0;
for (size_t n=0; n<i.size(); n++)
diff += (i[n] - j[n]) * (i[n] - j[n]);
return sqrt(diff);
}
// TODO: Make this function a template
float cosine_distance(const std::vector<float> &i, const std::vector<float> &j);
//
// Comparison functors
//
/**
* The first template parameter defines the type of feature.
*
* A second template parameter defines the type returned by the distance function (i.e. the score).
*/
template <class featureT, class scoreT = float>
class abstract_distance_functor
{
public:
typedef featureT feature_type; ///< The type being compared
typedef scoreT score_type; ///< The value returned by the comparison
virtual ~abstract_distance_functor() {};
virtual score_type operator() (const feature_type &i, const feature_type &j) const = 0;
/**
* @return True if the function is symmetric, i.e. fn(i, j) == fn(j, i).
*/
virtual bool is_symmetric() const = 0;
/**
* @return True if the result of the operator() is zero if the two
* histograms are the same. This implies that this is a
* distance measure.
*/
virtual bool zero_means_same() const = 0;
};
/**
* Defines a functor which compares vectors.
* This is currently intended purely to tidy the code - there might not
* be a need for this level of abstraction.
*/
template <class featureT, class scoreT = float>
class abstract_vector_distance_functor
: public abstract_distance_functor<std::vector<featureT>, scoreT>
{};
/// Define the signature of the histogram distance function
typedef float (*distance_fn_t)(const std::vector<float> &i, const std::vector<float> &j);
/**
* This class can be used to wrap a functor around a standard comparison
* function.
*/
template <distance_fn_t fn, bool symmetric, bool zero_is_same>
class concrete_distance_functor
: public abstract_vector_distance_functor<float, float>
{
public:
concrete_distance_functor() {}
virtual score_type operator() (const feature_type &i, const feature_type &j) const
{ return fn(i, j); }
virtual bool is_symmetric() const { return symmetric; }
virtual bool zero_means_same() const { return zero_is_same; }
};
const concrete_distance_functor<basic_distance, true, true> basic_distance_functor;
const concrete_distance_functor<sum_of_squares_distance, true, true> sum_of_squares_distance_functor;
const concrete_distance_functor<euclidean_distance, true, true> euclidean_distance_functor;
const concrete_distance_functor<cosine_distance, true, false> cosine_distance_functor;
// Utility function
const abstract_vector_distance_functor<float> * make_distance_functor(const std::string &fn);
#endif // End of sentry
| [
"[email protected]"
]
| [
[
[
1,
216
]
]
]
|
5ed72ba6ee2a1f781dbb2939168fa607787852c3 | eec70a1718c685c0dbabeee59eb7267bfaece58c | /Sense Management Irrlicht AI/Path.h | 9ce6bd0758a2b81580a35ce7d8fb448d6cd7eaa1 | []
| no_license | mohaider/sense-management-irrlicht-ai | 003939ee770ab32ff7ef3f5f5c1b77943a4c7489 | c5ef02f478d00a4957a294254fc4f3920037bd7a | refs/heads/master | 2020-12-24T14:44:38.254964 | 2011-05-19T14:29:53 | 2011-05-19T14:29:53 | 32,393,908 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,456 | h | #ifndef PATH_H
#define PATH_H
#include <list>
#include <math.h>
#include "IrrlichtObject.h"
class Path
{
public:
Path() : m_bLooped(false) {}
Path(int NumWayPoints, float MinX, float MinY, float MaxX, float MaxY, bool looped) : m_bLooped(looped)
{
CreateRandomPath(NumWayPoints, MinX, MinY, MaxX, MaxY);
currentWayPoint = m_wayPoints.begin();
}
vector2df CurrentWayPoint() const { return *currentWayPoint; }
bool Finished() { return !(currentWayPoint != m_wayPoints.end()); }
inline void SetNextWayPoint();
std::list<vector2df> CreateRandomPath(int NumWayPoints, float MinX, float MinY, float MaxX, float MaxY) {}
void LoopOn() {m_bLooped = true;}
void LoopOff() {m_bLooped = false;}
void AddWayPoint(vector2df newPoint) { m_wayPoints.push_back(newPoint); }
void Set(std::list<vector2df> newPath) {m_wayPoints = newPath; currentWayPoint = m_wayPoints.begin();}
void Set(const Path& path) { m_wayPoints = path.GetPath(); currentWayPoint = m_wayPoints.begin();}
void Clear() {m_wayPoints.clear();}
std::list<vector2df> GetPath() const { return m_wayPoints; }
void Render() const;
private:
std::list<vector2df> m_wayPoints;
std::list<vector2df>::iterator currentWayPoint;
bool m_bLooped;
};
inline void Path::SetNextWayPoint()
{
if(++currentWayPoint == m_wayPoints.end())
{
if(m_bLooped)
{
currentWayPoint = m_wayPoints.begin();
}
}
}
#endif | [
"[email protected]@2228f7ce-bb98-ac94-67a7-be962254a327"
]
| [
[
[
1,
63
]
]
]
|
b648f31206fed66ff6f23e90a80c2d39f7cc0f6a | 0f457762985248f4f6f06e29429955b3fd2c969a | /irrlicht/irrEdit/source/plugins/jz3dplugins/JZ3DSceneNodeFactory.cpp | 2688e74938e22aed4507309e5e942775cdfa1365 | []
| no_license | tk8812/ukgtut | f19e14449c7e75a0aca89d194caedb9a6769bb2e | 3146ac405794777e779c2bbb0b735b0acd9a3f1e | refs/heads/master | 2021-01-01T16:55:07.417628 | 2010-11-15T16:02:53 | 2010-11-15T16:02:53 | 37,515,002 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,506 | cpp |
#include "jz3d.h"
#include "Plan1x1SceneNode.h"
#include "TiledPlaneNode.h"
#include "FormatedAnimationNode.h"
#include "EmptyPluginNode.h"
#include "CollusionMngPluginNode.h"
#include "BulletPhysicsObjectNode.h"
#include "JZ3DSceneNodeFactory.h"
#include <string>
#include <map>
namespace irr {
namespace scene
{
namespace jz3d
{
struct S_SCENENODE_DESC
{
const int m_nID;
const char *m_strName;
};
static const S_SCENENODE_DESC g_SCN_desc[] =
{
{CPlan1x1SceneNode::TypeID,"Plane1x1"},
{CTiledPlaneNode::TypeID,CTiledPlaneNode::Name},
{CFormatedAnimationNode::TypeID,CFormatedAnimationNode::Name},
{CEmptyPluginNode::TypeID,CEmptyPluginNode::Name},
{CCollusionMngNode::TypeID,CCollusionMngNode::Name},
{CBulletPhysicsObjectNode::TypeID,CBulletPhysicsObjectNode::Name}
};
CJZ3DSceneNodeFactory::CJZ3DSceneNodeFactory(irr::scene::ISceneManager *pSmgr)
:Manager(pSmgr)
{
}
CJZ3DSceneNodeFactory::~CJZ3DSceneNodeFactory(void)
{
}
ISceneNode* CJZ3DSceneNodeFactory::addSceneNode(ESCENE_NODE_TYPE type, ISceneNode* parent)
{
if (!parent)
parent = Manager->getRootSceneNode();
switch(type)
{
case CPlan1x1SceneNode::TypeID:
{
CPlan1x1SceneNode *node = new CPlan1x1SceneNode(parent, Manager, -1);
node->drop();
return node;
}
break;
case CTiledPlaneNode::TypeID:
{
CTiledPlaneNode *node = new CTiledPlaneNode(parent, Manager, -1);
node->drop();
return node;
}
break;
case CFormatedAnimationNode::TypeID:
{
CFormatedAnimationNode *node = new CFormatedAnimationNode(parent, Manager, -1);
node->drop();
return node;
}
break;
case CCollusionMngNode::TypeID:
{
CCollusionMngNode *node = new CCollusionMngNode(parent, Manager, -1);
node->drop();
return node;
}
break;
case CEmptyPluginNode::TypeID:
{
CEmptyPluginNode *node = new CEmptyPluginNode(parent, Manager, -1);
node->drop();
return node;
}
break;
case CBulletPhysicsObjectNode::TypeID:
{
CBulletPhysicsObjectNode *node = new CBulletPhysicsObjectNode(parent, Manager, -1);
node->drop();
return node;
}
break;
}
return 0;
}
//! adds a scene node to the scene graph based on its type name
ISceneNode* CJZ3DSceneNodeFactory::addSceneNode(const c8* typeName, ISceneNode* parent)
{
return addSceneNode( getTypeFromName(typeName), parent );
}
//! returns amount of scene node types this factory is able to create
u32 CJZ3DSceneNodeFactory::getCreatableSceneNodeTypeCount() const
{
//return 1;
return sizeof(g_SCN_desc)/sizeof(S_SCENENODE_DESC);
}
//! returns type of a createable scene node type
ESCENE_NODE_TYPE CJZ3DSceneNodeFactory::getCreateableSceneNodeType(u32 idx) const
{
//if (idx==0)
//return (ESCENE_NODE_TYPE)EXAMPLE_SCENE_NODE_ID;
if(idx <= getCreatableSceneNodeTypeCount())
return (ESCENE_NODE_TYPE)g_SCN_desc[idx].m_nID;
return ESNT_UNKNOWN;
}
//! returns type name of a createable scene node type
const c8* CJZ3DSceneNodeFactory::getCreateableSceneNodeTypeName(u32 idx) const
{
if(idx <= getCreatableSceneNodeTypeCount())
return g_SCN_desc[idx].m_strName;
//if (idx==0)
// return exampleSceneNodeTypeName;
return 0;
}
//! returns type name of a createable scene node type
const c8* CJZ3DSceneNodeFactory::getCreateableSceneNodeTypeName(ESCENE_NODE_TYPE type) const
{
//if (type == EXAMPLE_SCENE_NODE_ID)
// return exampleSceneNodeTypeName;
u32 i;
for(i=0; i< getCreatableSceneNodeTypeCount();i++)
{
if(type == g_SCN_desc[i].m_nID)
return g_SCN_desc[i].m_strName;
}
return 0;
}
ESCENE_NODE_TYPE CJZ3DSceneNodeFactory::getTypeFromName(const c8* name)
{
//if (!strcmp(name, exampleSceneNodeTypeName))
// return (ESCENE_NODE_TYPE)EXAMPLE_SCENE_NODE_ID;
//return ESNT_UNKNOWN;
u32 i;
for(i=0; i< getCreatableSceneNodeTypeCount();i++)
{
//if(type == g_SCN_desc[i].m_nID)
if(!strcmp(g_SCN_desc[i].m_strName,name))
return (ESCENE_NODE_TYPE)g_SCN_desc[i].m_nID;
}
return ESNT_UNKNOWN;
}
}
}
} | [
"gbox3d@58f0f68e-7603-11de-abb5-1d1887d8974b"
]
| [
[
[
1,
180
]
]
]
|
91a189dca352533d24d4dcad4f8e6fa1d4cfcb4e | 2d212a074917aad8c57ed585e6ce8e2073aa06c6 | /cgworkshop/src/SegmentatorBase.h | 40b2fed3e53e14c78365c68696524462ef12c227 | []
| no_license | morsela/cgworkshop | b31c9ec39419edcedfaed81468c923436528e538 | cdf9ef2a9b2d9c389279fe0e38fb9c8bc1d86d89 | refs/heads/master | 2021-07-29T01:37:24.739450 | 2007-09-09T13:44:54 | 2007-09-09T13:44:54 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,273 | h | #ifndef _H_SEGMENTATOR_H_
#define _H_SEGMENTATOR_H_
#include <cv.h>
#include <highgui.h>
#include "fe/FeatureExtraction.h"
#include "GUI/TypeDefs.h"
#define MAX_ITER 10
#define TOLLERANCE 0.005
#define BACKGROUND -1
class SegmentatorBase
{
public:
SegmentatorBase(IplImage * Img, ScribbleVector &scribbles, int nScribbles);
virtual ~SegmentatorBase();
public:
void Colorize();
virtual IplImage * GetSegmentedImage(int scribble);
IplImage * GetSegmentedImage();
protected:
void getMask(CvMat * mask, int label);
void PrintStatus(CvMat ** masks);
void RecolorPixel(uchar * pData, int y, int x, CvScalar * pColor);
void RGB2YUV(CvScalar * pRGB, CvScalar * pYUV);
void SegmentOne(int scribble);
virtual void Segment();
void AssignColors();
virtual void AssignColor(int i, int j, CvScalar * color) = 0;
void CountSegments();
protected:
ScribbleVector m_scribbles;
int m_nScribbles;
CFeatureExtraction *m_pFe;
IplImage * m_pImg;
IplImage* m_pSegImg;
IplImage* m_pTempSegImg;
CvMat ** m_Segmentations;
CvMat * m_SegmentCount;
CvMat ** m_Probabilities;
CvMat ** m_BGProbabilities;
CvMat * m_pLabels;
CvMat * m_pScribbles;
};
#endif //_H_SEGMENTATOR_H_
| [
"morsela@60b542fb-872c-0410-bfbb-43802cb78f6e",
"erancho@60b542fb-872c-0410-bfbb-43802cb78f6e",
"ikirsh@60b542fb-872c-0410-bfbb-43802cb78f6e"
]
| [
[
[
1,
2
],
[
4,
5
],
[
7,
8
],
[
16,
16
],
[
22,
22
],
[
27,
27
],
[
49,
52
],
[
55,
55
],
[
66,
67
]
],
[
[
3,
3
],
[
6,
6
],
[
9,
9
],
[
12,
13
],
[
15,
15
],
[
17,
21
],
[
24,
26
],
[
28,
30
],
[
38,
39
],
[
41,
42
],
[
46,
46
],
[
48,
48
],
[
53,
54
],
[
61,
61
],
[
65,
65
]
],
[
[
10,
11
],
[
14,
14
],
[
23,
23
],
[
31,
37
],
[
40,
40
],
[
43,
45
],
[
47,
47
],
[
56,
60
],
[
62,
64
],
[
68,
68
]
]
]
|
23bd133dec0a17325aae5587e3a69ee29e81453d | 9c62af23e0a1faea5aaa8dd328ba1d82688823a5 | /rl/trunk/engine/ai/src/AgentSteeringState.cpp | e219d5ad12f38028fccd41a7c85143f7fa7710e3 | [
"ClArtistic",
"LicenseRef-scancode-unknown-license-reference",
"LicenseRef-scancode-public-domain"
]
| permissive | jacmoe/dsa-hl-svn | 55b05b6f28b0b8b216eac7b0f9eedf650d116f85 | 97798e1f54df9d5785fb206c7165cd011c611560 | refs/heads/master | 2021-04-22T12:07:43.389214 | 2009-11-27T22:01:03 | 2009-11-27T22:01:03 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,069 | cpp | /* This source file is part of Rastullahs Lockenpracht.
* Copyright (C) 2003-2008 Team Pantheon. http://www.team-pantheon.de
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the Clarified Artistic License.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* Clarified Artistic License for more details.
*
* You should have received a copy of the Clarified Artistic License
* along with this program; if not you can get it here
* http://www.jpaulmorrison.com/fbp/artistic2.htm.
*/
#include "stdinc.h"
#include "Agent.h"
#include "AgentSteeringState.h"
using namespace Ogre;
using namespace OpenSteer;
namespace rl {
AgentSteeringState::AgentSteeringState(Agent* agent)
: AgentState(agent),
mBehaviour(NULL)
{
mBehaviour = new SteeringMachine(NULL, mAgent);
LOG_MESSAGE(Logger::AI,
"created SteeringMachine for Agent");
}
AgentSteeringState::~AgentSteeringState(void)
{
delete mBehaviour;
}
void AgentSteeringState::addSteeringBehaviour(SteeringBehaviour* behaviour)
{
behaviour->setParent(mBehaviour);
behaviour->setController(mAgent);
mBehaviour->addState(behaviour);
LOG_MESSAGE(Logger::AI,
"added SteeringBehaviour for Agent");
}
void AgentSteeringState::clearSteeringBehaviours()
{
mBehaviour->clearStates();
LOG_MESSAGE(Logger::AI,
"Cleared all SteeringBehaviours for Agent");
}
void AgentSteeringState::update(const float elapsedTime)
{
mBehaviour->update(elapsedTime);
// currentTime not needed yet, only elapsedTime
mAgent->updateVehicle(0.0f, elapsedTime);
}
SteeringVehicle* AgentSteeringState::getVehicle()
{
return mAgent;
}
}
| [
"tanis@4c79e8ff-cfd4-0310-af45-a38c79f83013",
"blakharaz@4c79e8ff-cfd4-0310-af45-a38c79f83013"
]
| [
[
[
1,
1
],
[
3,
4
],
[
6,
9
],
[
11,
11
],
[
13,
13
],
[
15,
25
],
[
27,
28
],
[
30,
30
],
[
32,
43
],
[
45,
60
],
[
62,
65
],
[
67,
69
]
],
[
[
2,
2
],
[
5,
5
],
[
10,
10
],
[
12,
12
],
[
14,
14
],
[
26,
26
],
[
29,
29
],
[
31,
31
],
[
44,
44
],
[
61,
61
],
[
66,
66
]
]
]
|
1faae7b03dc59ce5d0cf8b79dbda170b915ceb46 | fd3f2268460656e395652b11ae1a5b358bfe0a59 | /cryptopp/sosemanuk.cpp | 333b96aa69d35cb132759567c7f25e5a95e45336 | [
"LicenseRef-scancode-cryptopp",
"LicenseRef-scancode-public-domain",
"LicenseRef-scancode-unknown-license-reference"
]
| permissive | mikezhoubill/emule-gifc | e1cc6ff8b1bb63197bcfc7e67c57cfce0538ff60 | 46979cf32a313ad6d58603b275ec0b2150562166 | refs/heads/master | 2021-01-10T20:37:07.581465 | 2011-08-13T13:58:37 | 2011-08-13T13:58:37 | 32,465,033 | 4 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 24,308 | cpp | // sosemanuk.cpp - written and placed in the public domain by Wei Dai
// use "cl /EP /P /DCRYPTOPP_GENERATE_X64_MASM sosemanuk.cpp" to generate MASM code
#include "pch.h"
#ifndef CRYPTOPP_GENERATE_X64_MASM
#include "sosemanuk.h"
#include "misc.h"
#include "cpu.h"
#include "serpentp.h"
NAMESPACE_BEGIN(CryptoPP)
void SosemanukPolicy::CipherSetKey(const NameValuePairs ¶ms, const byte *userKey, size_t keylen)
{
Serpent_KeySchedule(m_key, 24, userKey, keylen);
}
void SosemanukPolicy::CipherResynchronize(byte *keystreamBuffer, const byte *iv, size_t length)
{
assert(length==16);
word32 a, b, c, d, e;
typedef BlockGetAndPut<word32, LittleEndian> Block;
Block::Get(iv)(a)(b)(c)(d);
const word32 *k = m_key;
unsigned int i=1;
do
{
beforeS0(KX); beforeS0(S0); afterS0(LT);
afterS0(KX); afterS0(S1); afterS1(LT);
if (i == 3) // after 18th round
{
m_state[4] = b;
m_state[5] = e;
m_state[10] = c;
m_state[11] = a;
}
afterS1(KX); afterS1(S2); afterS2(LT);
afterS2(KX); afterS2(S3); afterS3(LT);
if (i == 2) // after 12th round
{
m_state[6] = c;
m_state[7] = d;
m_state[8] = b;
m_state[9] = e;
}
afterS3(KX); afterS3(S4); afterS4(LT);
afterS4(KX); afterS4(S5); afterS5(LT);
afterS5(KX); afterS5(S6); afterS6(LT);
afterS6(KX); afterS6(S7); afterS7(LT);
if (i == 3)
break;
++i;
c = b;
b = e;
e = d;
d = a;
a = e;
k += 32;
}
while (true);
afterS7(KX);
m_state[0] = a;
m_state[1] = b;
m_state[2] = e;
m_state[3] = d;
#define XMUX(c, x, y) (x ^ (y & (0 - (c & 1))))
m_state[11] += XMUX(m_state[10], m_state[1], m_state[8]);
m_state[10] = rotlFixed(m_state[10] * 0x54655307, 7);
}
extern "C" {
word32 s_sosemanukMulTables[512] = {
#if CRYPTOPP_BOOL_X86 | CRYPTOPP_BOOL_X64
0x00000000, 0xE19FCF12, 0x6B973724, 0x8A08F836,
0xD6876E48, 0x3718A15A, 0xBD10596C, 0x5C8F967E,
0x05A7DC90, 0xE4381382, 0x6E30EBB4, 0x8FAF24A6,
0xD320B2D8, 0x32BF7DCA, 0xB8B785FC, 0x59284AEE,
0x0AE71189, 0xEB78DE9B, 0x617026AD, 0x80EFE9BF,
0xDC607FC1, 0x3DFFB0D3, 0xB7F748E5, 0x566887F7,
0x0F40CD19, 0xEEDF020B, 0x64D7FA3D, 0x8548352F,
0xD9C7A351, 0x38586C43, 0xB2509475, 0x53CF5B67,
0x146722BB, 0xF5F8EDA9, 0x7FF0159F, 0x9E6FDA8D,
0xC2E04CF3, 0x237F83E1, 0xA9777BD7, 0x48E8B4C5,
0x11C0FE2B, 0xF05F3139, 0x7A57C90F, 0x9BC8061D,
0xC7479063, 0x26D85F71, 0xACD0A747, 0x4D4F6855,
0x1E803332, 0xFF1FFC20, 0x75170416, 0x9488CB04,
0xC8075D7A, 0x29989268, 0xA3906A5E, 0x420FA54C,
0x1B27EFA2, 0xFAB820B0, 0x70B0D886, 0x912F1794,
0xCDA081EA, 0x2C3F4EF8, 0xA637B6CE, 0x47A879DC,
0x28CE44DF, 0xC9518BCD, 0x435973FB, 0xA2C6BCE9,
0xFE492A97, 0x1FD6E585, 0x95DE1DB3, 0x7441D2A1,
0x2D69984F, 0xCCF6575D, 0x46FEAF6B, 0xA7616079,
0xFBEEF607, 0x1A713915, 0x9079C123, 0x71E60E31,
0x22295556, 0xC3B69A44, 0x49BE6272, 0xA821AD60,
0xF4AE3B1E, 0x1531F40C, 0x9F390C3A, 0x7EA6C328,
0x278E89C6, 0xC61146D4, 0x4C19BEE2, 0xAD8671F0,
0xF109E78E, 0x1096289C, 0x9A9ED0AA, 0x7B011FB8,
0x3CA96664, 0xDD36A976, 0x573E5140, 0xB6A19E52,
0xEA2E082C, 0x0BB1C73E, 0x81B93F08, 0x6026F01A,
0x390EBAF4, 0xD89175E6, 0x52998DD0, 0xB30642C2,
0xEF89D4BC, 0x0E161BAE, 0x841EE398, 0x65812C8A,
0x364E77ED, 0xD7D1B8FF, 0x5DD940C9, 0xBC468FDB,
0xE0C919A5, 0x0156D6B7, 0x8B5E2E81, 0x6AC1E193,
0x33E9AB7D, 0xD276646F, 0x587E9C59, 0xB9E1534B,
0xE56EC535, 0x04F10A27, 0x8EF9F211, 0x6F663D03,
0x50358817, 0xB1AA4705, 0x3BA2BF33, 0xDA3D7021,
0x86B2E65F, 0x672D294D, 0xED25D17B, 0x0CBA1E69,
0x55925487, 0xB40D9B95, 0x3E0563A3, 0xDF9AACB1,
0x83153ACF, 0x628AF5DD, 0xE8820DEB, 0x091DC2F9,
0x5AD2999E, 0xBB4D568C, 0x3145AEBA, 0xD0DA61A8,
0x8C55F7D6, 0x6DCA38C4, 0xE7C2C0F2, 0x065D0FE0,
0x5F75450E, 0xBEEA8A1C, 0x34E2722A, 0xD57DBD38,
0x89F22B46, 0x686DE454, 0xE2651C62, 0x03FAD370,
0x4452AAAC, 0xA5CD65BE, 0x2FC59D88, 0xCE5A529A,
0x92D5C4E4, 0x734A0BF6, 0xF942F3C0, 0x18DD3CD2,
0x41F5763C, 0xA06AB92E, 0x2A624118, 0xCBFD8E0A,
0x97721874, 0x76EDD766, 0xFCE52F50, 0x1D7AE042,
0x4EB5BB25, 0xAF2A7437, 0x25228C01, 0xC4BD4313,
0x9832D56D, 0x79AD1A7F, 0xF3A5E249, 0x123A2D5B,
0x4B1267B5, 0xAA8DA8A7, 0x20855091, 0xC11A9F83,
0x9D9509FD, 0x7C0AC6EF, 0xF6023ED9, 0x179DF1CB,
0x78FBCCC8, 0x996403DA, 0x136CFBEC, 0xF2F334FE,
0xAE7CA280, 0x4FE36D92, 0xC5EB95A4, 0x24745AB6,
0x7D5C1058, 0x9CC3DF4A, 0x16CB277C, 0xF754E86E,
0xABDB7E10, 0x4A44B102, 0xC04C4934, 0x21D38626,
0x721CDD41, 0x93831253, 0x198BEA65, 0xF8142577,
0xA49BB309, 0x45047C1B, 0xCF0C842D, 0x2E934B3F,
0x77BB01D1, 0x9624CEC3, 0x1C2C36F5, 0xFDB3F9E7,
0xA13C6F99, 0x40A3A08B, 0xCAAB58BD, 0x2B3497AF,
0x6C9CEE73, 0x8D032161, 0x070BD957, 0xE6941645,
0xBA1B803B, 0x5B844F29, 0xD18CB71F, 0x3013780D,
0x693B32E3, 0x88A4FDF1, 0x02AC05C7, 0xE333CAD5,
0xBFBC5CAB, 0x5E2393B9, 0xD42B6B8F, 0x35B4A49D,
0x667BFFFA, 0x87E430E8, 0x0DECC8DE, 0xEC7307CC,
0xB0FC91B2, 0x51635EA0, 0xDB6BA696, 0x3AF46984,
0x63DC236A, 0x8243EC78, 0x084B144E, 0xE9D4DB5C,
0xB55B4D22, 0x54C48230, 0xDECC7A06, 0x3F53B514,
#else
0x00000000, 0xE19FCF13, 0x6B973726, 0x8A08F835,
0xD6876E4C, 0x3718A15F, 0xBD10596A, 0x5C8F9679,
0x05A7DC98, 0xE438138B, 0x6E30EBBE, 0x8FAF24AD,
0xD320B2D4, 0x32BF7DC7, 0xB8B785F2, 0x59284AE1,
0x0AE71199, 0xEB78DE8A, 0x617026BF, 0x80EFE9AC,
0xDC607FD5, 0x3DFFB0C6, 0xB7F748F3, 0x566887E0,
0x0F40CD01, 0xEEDF0212, 0x64D7FA27, 0x85483534,
0xD9C7A34D, 0x38586C5E, 0xB250946B, 0x53CF5B78,
0x1467229B, 0xF5F8ED88, 0x7FF015BD, 0x9E6FDAAE,
0xC2E04CD7, 0x237F83C4, 0xA9777BF1, 0x48E8B4E2,
0x11C0FE03, 0xF05F3110, 0x7A57C925, 0x9BC80636,
0xC747904F, 0x26D85F5C, 0xACD0A769, 0x4D4F687A,
0x1E803302, 0xFF1FFC11, 0x75170424, 0x9488CB37,
0xC8075D4E, 0x2998925D, 0xA3906A68, 0x420FA57B,
0x1B27EF9A, 0xFAB82089, 0x70B0D8BC, 0x912F17AF,
0xCDA081D6, 0x2C3F4EC5, 0xA637B6F0, 0x47A879E3,
0x28CE449F, 0xC9518B8C, 0x435973B9, 0xA2C6BCAA,
0xFE492AD3, 0x1FD6E5C0, 0x95DE1DF5, 0x7441D2E6,
0x2D699807, 0xCCF65714, 0x46FEAF21, 0xA7616032,
0xFBEEF64B, 0x1A713958, 0x9079C16D, 0x71E60E7E,
0x22295506, 0xC3B69A15, 0x49BE6220, 0xA821AD33,
0xF4AE3B4A, 0x1531F459, 0x9F390C6C, 0x7EA6C37F,
0x278E899E, 0xC611468D, 0x4C19BEB8, 0xAD8671AB,
0xF109E7D2, 0x109628C1, 0x9A9ED0F4, 0x7B011FE7,
0x3CA96604, 0xDD36A917, 0x573E5122, 0xB6A19E31,
0xEA2E0848, 0x0BB1C75B, 0x81B93F6E, 0x6026F07D,
0x390EBA9C, 0xD891758F, 0x52998DBA, 0xB30642A9,
0xEF89D4D0, 0x0E161BC3, 0x841EE3F6, 0x65812CE5,
0x364E779D, 0xD7D1B88E, 0x5DD940BB, 0xBC468FA8,
0xE0C919D1, 0x0156D6C2, 0x8B5E2EF7, 0x6AC1E1E4,
0x33E9AB05, 0xD2766416, 0x587E9C23, 0xB9E15330,
0xE56EC549, 0x04F10A5A, 0x8EF9F26F, 0x6F663D7C,
0x50358897, 0xB1AA4784, 0x3BA2BFB1, 0xDA3D70A2,
0x86B2E6DB, 0x672D29C8, 0xED25D1FD, 0x0CBA1EEE,
0x5592540F, 0xB40D9B1C, 0x3E056329, 0xDF9AAC3A,
0x83153A43, 0x628AF550, 0xE8820D65, 0x091DC276,
0x5AD2990E, 0xBB4D561D, 0x3145AE28, 0xD0DA613B,
0x8C55F742, 0x6DCA3851, 0xE7C2C064, 0x065D0F77,
0x5F754596, 0xBEEA8A85, 0x34E272B0, 0xD57DBDA3,
0x89F22BDA, 0x686DE4C9, 0xE2651CFC, 0x03FAD3EF,
0x4452AA0C, 0xA5CD651F, 0x2FC59D2A, 0xCE5A5239,
0x92D5C440, 0x734A0B53, 0xF942F366, 0x18DD3C75,
0x41F57694, 0xA06AB987, 0x2A6241B2, 0xCBFD8EA1,
0x977218D8, 0x76EDD7CB, 0xFCE52FFE, 0x1D7AE0ED,
0x4EB5BB95, 0xAF2A7486, 0x25228CB3, 0xC4BD43A0,
0x9832D5D9, 0x79AD1ACA, 0xF3A5E2FF, 0x123A2DEC,
0x4B12670D, 0xAA8DA81E, 0x2085502B, 0xC11A9F38,
0x9D950941, 0x7C0AC652, 0xF6023E67, 0x179DF174,
0x78FBCC08, 0x9964031B, 0x136CFB2E, 0xF2F3343D,
0xAE7CA244, 0x4FE36D57, 0xC5EB9562, 0x24745A71,
0x7D5C1090, 0x9CC3DF83, 0x16CB27B6, 0xF754E8A5,
0xABDB7EDC, 0x4A44B1CF, 0xC04C49FA, 0x21D386E9,
0x721CDD91, 0x93831282, 0x198BEAB7, 0xF81425A4,
0xA49BB3DD, 0x45047CCE, 0xCF0C84FB, 0x2E934BE8,
0x77BB0109, 0x9624CE1A, 0x1C2C362F, 0xFDB3F93C,
0xA13C6F45, 0x40A3A056, 0xCAAB5863, 0x2B349770,
0x6C9CEE93, 0x8D032180, 0x070BD9B5, 0xE69416A6,
0xBA1B80DF, 0x5B844FCC, 0xD18CB7F9, 0x301378EA,
0x693B320B, 0x88A4FD18, 0x02AC052D, 0xE333CA3E,
0xBFBC5C47, 0x5E239354, 0xD42B6B61, 0x35B4A472,
0x667BFF0A, 0x87E43019, 0x0DECC82C, 0xEC73073F,
0xB0FC9146, 0x51635E55, 0xDB6BA660, 0x3AF46973,
0x63DC2392, 0x8243EC81, 0x084B14B4, 0xE9D4DBA7,
0xB55B4DDE, 0x54C482CD, 0xDECC7AF8, 0x3F53B5EB,
#endif
0x00000000, 0x180F40CD, 0x301E8033, 0x2811C0FE,
0x603CA966, 0x7833E9AB, 0x50222955, 0x482D6998,
0xC078FBCC, 0xD877BB01, 0xF0667BFF, 0xE8693B32,
0xA04452AA, 0xB84B1267, 0x905AD299, 0x88559254,
0x29F05F31, 0x31FF1FFC, 0x19EEDF02, 0x01E19FCF,
0x49CCF657, 0x51C3B69A, 0x79D27664, 0x61DD36A9,
0xE988A4FD, 0xF187E430, 0xD99624CE, 0xC1996403,
0x89B40D9B, 0x91BB4D56, 0xB9AA8DA8, 0xA1A5CD65,
0x5249BE62, 0x4A46FEAF, 0x62573E51, 0x7A587E9C,
0x32751704, 0x2A7A57C9, 0x026B9737, 0x1A64D7FA,
0x923145AE, 0x8A3E0563, 0xA22FC59D, 0xBA208550,
0xF20DECC8, 0xEA02AC05, 0xC2136CFB, 0xDA1C2C36,
0x7BB9E153, 0x63B6A19E, 0x4BA76160, 0x53A821AD,
0x1B854835, 0x038A08F8, 0x2B9BC806, 0x339488CB,
0xBBC11A9F, 0xA3CE5A52, 0x8BDF9AAC, 0x93D0DA61,
0xDBFDB3F9, 0xC3F2F334, 0xEBE333CA, 0xF3EC7307,
0xA492D5C4, 0xBC9D9509, 0x948C55F7, 0x8C83153A,
0xC4AE7CA2, 0xDCA13C6F, 0xF4B0FC91, 0xECBFBC5C,
0x64EA2E08, 0x7CE56EC5, 0x54F4AE3B, 0x4CFBEEF6,
0x04D6876E, 0x1CD9C7A3, 0x34C8075D, 0x2CC74790,
0x8D628AF5, 0x956DCA38, 0xBD7C0AC6, 0xA5734A0B,
0xED5E2393, 0xF551635E, 0xDD40A3A0, 0xC54FE36D,
0x4D1A7139, 0x551531F4, 0x7D04F10A, 0x650BB1C7,
0x2D26D85F, 0x35299892, 0x1D38586C, 0x053718A1,
0xF6DB6BA6, 0xEED42B6B, 0xC6C5EB95, 0xDECAAB58,
0x96E7C2C0, 0x8EE8820D, 0xA6F942F3, 0xBEF6023E,
0x36A3906A, 0x2EACD0A7, 0x06BD1059, 0x1EB25094,
0x569F390C, 0x4E9079C1, 0x6681B93F, 0x7E8EF9F2,
0xDF2B3497, 0xC724745A, 0xEF35B4A4, 0xF73AF469,
0xBF179DF1, 0xA718DD3C, 0x8F091DC2, 0x97065D0F,
0x1F53CF5B, 0x075C8F96, 0x2F4D4F68, 0x37420FA5,
0x7F6F663D, 0x676026F0, 0x4F71E60E, 0x577EA6C3,
0xE18D0321, 0xF98243EC, 0xD1938312, 0xC99CC3DF,
0x81B1AA47, 0x99BEEA8A, 0xB1AF2A74, 0xA9A06AB9,
0x21F5F8ED, 0x39FAB820, 0x11EB78DE, 0x09E43813,
0x41C9518B, 0x59C61146, 0x71D7D1B8, 0x69D89175,
0xC87D5C10, 0xD0721CDD, 0xF863DC23, 0xE06C9CEE,
0xA841F576, 0xB04EB5BB, 0x985F7545, 0x80503588,
0x0805A7DC, 0x100AE711, 0x381B27EF, 0x20146722,
0x68390EBA, 0x70364E77, 0x58278E89, 0x4028CE44,
0xB3C4BD43, 0xABCBFD8E, 0x83DA3D70, 0x9BD57DBD,
0xD3F81425, 0xCBF754E8, 0xE3E69416, 0xFBE9D4DB,
0x73BC468F, 0x6BB30642, 0x43A2C6BC, 0x5BAD8671,
0x1380EFE9, 0x0B8FAF24, 0x239E6FDA, 0x3B912F17,
0x9A34E272, 0x823BA2BF, 0xAA2A6241, 0xB225228C,
0xFA084B14, 0xE2070BD9, 0xCA16CB27, 0xD2198BEA,
0x5A4C19BE, 0x42435973, 0x6A52998D, 0x725DD940,
0x3A70B0D8, 0x227FF015, 0x0A6E30EB, 0x12617026,
0x451FD6E5, 0x5D109628, 0x750156D6, 0x6D0E161B,
0x25237F83, 0x3D2C3F4E, 0x153DFFB0, 0x0D32BF7D,
0x85672D29, 0x9D686DE4, 0xB579AD1A, 0xAD76EDD7,
0xE55B844F, 0xFD54C482, 0xD545047C, 0xCD4A44B1,
0x6CEF89D4, 0x74E0C919, 0x5CF109E7, 0x44FE492A,
0x0CD320B2, 0x14DC607F, 0x3CCDA081, 0x24C2E04C,
0xAC977218, 0xB49832D5, 0x9C89F22B, 0x8486B2E6,
0xCCABDB7E, 0xD4A49BB3, 0xFCB55B4D, 0xE4BA1B80,
0x17566887, 0x0F59284A, 0x2748E8B4, 0x3F47A879,
0x776AC1E1, 0x6F65812C, 0x477441D2, 0x5F7B011F,
0xD72E934B, 0xCF21D386, 0xE7301378, 0xFF3F53B5,
0xB7123A2D, 0xAF1D7AE0, 0x870CBA1E, 0x9F03FAD3,
0x3EA637B6, 0x26A9777B, 0x0EB8B785, 0x16B7F748,
0x5E9A9ED0, 0x4695DE1D, 0x6E841EE3, 0x768B5E2E,
0xFEDECC7A, 0xE6D18CB7, 0xCEC04C49, 0xD6CF0C84,
0x9EE2651C, 0x86ED25D1, 0xAEFCE52F, 0xB6F3A5E2
};
}
#if CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X64
unsigned int SosemanukPolicy::GetAlignment() const
{
#if CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE
#ifdef __INTEL_COMPILER
if (HasSSE2() && !IsP4()) // Intel compiler produces faster code for this algorithm on the P4
#else
if (HasSSE2())
#endif
return 16;
else
#endif
return GetAlignmentOf<word32>();
}
unsigned int SosemanukPolicy::GetOptimalBlockSize() const
{
#if CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE
#ifdef __INTEL_COMPILER
if (HasSSE2() && !IsP4()) // Intel compiler produces faster code for this algorithm on the P4
#else
if (HasSSE2())
#endif
return 4*BYTES_PER_ITERATION;
else
#endif
return BYTES_PER_ITERATION;
}
#endif
#ifdef CRYPTOPP_X64_MASM_AVAILABLE
extern "C" {
void Sosemanuk_OperateKeystream(size_t iterationCount, const byte *input, byte *output, word32 *state);
}
#endif
#pragma warning(disable: 4731) // frame pointer register 'ebp' modified by inline assembly code
void SosemanukPolicy::OperateKeystream(KeystreamOperation operation, byte *output, const byte *input, size_t iterationCount)
{
#endif // #ifdef CRYPTOPP_GENERATE_X64_MASM
#ifdef CRYPTOPP_X64_MASM_AVAILABLE
Sosemanuk_OperateKeystream(iterationCount, input, output, m_state.data());
return;
#endif
#if CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE
#ifdef CRYPTOPP_GENERATE_X64_MASM
ALIGN 8
Sosemanuk_OperateKeystream PROC FRAME
rex_push_reg rsi
push_reg rdi
alloc_stack(80*4*2+12*4+8*WORD_SZ + 2*16+8)
save_xmm128 xmm6, 02f0h
save_xmm128 xmm7, 0300h
.endprolog
mov rdi, r8
mov rax, r9
#else
#ifdef __INTEL_COMPILER
if (HasSSE2() && !IsP4()) // Intel compiler produces faster code for this algorithm on the P4
#else
if (HasSSE2())
#endif
{
#ifdef __GNUC__
#if CRYPTOPP_BOOL_X64
FixedSizeAlignedSecBlock<byte, 80*4*2+12*4+8*WORD_SZ> workspace;
#endif
__asm__ __volatile__
(
".intel_syntax noprefix;"
AS_PUSH_IF86( bx)
#else
word32 *state = m_state;
AS2( mov WORD_REG(ax), state)
AS2( mov WORD_REG(di), output)
AS2( mov WORD_REG(dx), input)
AS2( mov WORD_REG(cx), iterationCount)
#endif
#endif // #ifdef CRYPTOPP_GENERATE_X64_MASM
#if defined(__GNUC__) && CRYPTOPP_BOOL_X64
#define SSE2_workspace %5
#else
#define SSE2_workspace WORD_REG(sp)
#endif
#define SSE2_output WORD_PTR [SSE2_workspace+1*WORD_SZ]
#define SSE2_input WORD_PTR [SSE2_workspace+2*WORD_SZ]
#define SSE2_wordsLeft WORD_PTR [SSE2_workspace+3*WORD_SZ]
#define SSE2_diEnd WORD_PTR [SSE2_workspace+4*WORD_SZ]
#define SSE2_pMulTables WORD_PTR [SSE2_workspace+5*WORD_SZ]
#define SSE2_state WORD_PTR [SSE2_workspace+6*WORD_SZ]
#define SSE2_wordsLeft2 WORD_PTR [SSE2_workspace+7*WORD_SZ]
#define SSE2_stateCopy SSE2_workspace + 8*WORD_SZ
#define SSE2_uvStart SSE2_stateCopy + 12*4
#if CRYPTOPP_BOOL_X86
AS_PUSH_IF86( bp)
AS2( mov AS_REG_6, esp)
AS2( and esp, -16)
AS2( sub esp, 80*4*2+12*4+8*WORD_SZ) // 80 v's, 80 u's, 12 state, 8 locals
AS2( mov [esp], AS_REG_6)
#endif
AS2( mov SSE2_output, WORD_REG(di))
AS2( mov SSE2_input, WORD_REG(dx))
AS2( mov SSE2_state, WORD_REG(ax))
#ifndef _MSC_VER
AS2( mov SSE2_pMulTables, WORD_REG(si))
#endif
AS2( lea WORD_REG(cx), [4*WORD_REG(cx)+WORD_REG(cx)])
AS2( lea WORD_REG(si), [4*WORD_REG(cx)])
AS2( mov SSE2_wordsLeft, WORD_REG(si))
AS2( movdqa xmm0, [WORD_REG(ax)+0*16]) // copy state to stack to save a register
AS2( movdqa [SSE2_stateCopy+0*16], xmm0)
AS2( movdqa xmm0, [WORD_REG(ax)+1*16])
AS2( movdqa [SSE2_stateCopy+1*16], xmm0)
AS2( movq xmm0, QWORD PTR [WORD_REG(ax)+2*16])
AS2( movq QWORD PTR [SSE2_stateCopy+2*16], xmm0)
AS2( psrlq xmm0, 32)
AS2( movd AS_REG_6d, xmm0) // s(9)
AS2( mov ecx, [WORD_REG(ax)+10*4])
AS2( mov edx, [WORD_REG(ax)+11*4])
AS2( pcmpeqb xmm7, xmm7) // all ones
#define s(i) SSE2_stateCopy + ASM_MOD(i,10)*4
#define u(j) WORD_REG(di) + (ASM_MOD(j,4)*20 + (j/4)) * 4
#define v(j) WORD_REG(di) + (ASM_MOD(j,4)*20 + (j/4)) * 4 + 80*4
#define R10 ecx
#define R11 edx
#define R20 edx
#define R21 ecx
// workaround bug in GAS 2.15
#define R20r WORD_REG(dx)
#define R21r WORD_REG(cx)
#define SSE2_STEP(i, j) \
AS2( mov eax, [s(i+0)])\
AS2( mov [v(i)], eax)\
AS2( rol eax, 8)\
AS2( lea AS_REG_7, [AS_REG_6 + R2##j##r])\
AS2( xor AS_REG_7d, R1##j)\
AS2( mov [u(i)], AS_REG_7d)\
AS2( mov AS_REG_7d, 1)\
AS2( and AS_REG_7d, R2##j)\
AS1( neg AS_REG_7d)\
AS2( and AS_REG_7d, AS_REG_6d)\
AS2( xor AS_REG_6d, eax)\
AS2( movzx eax, al)\
AS2( xor AS_REG_6d, [WORD_REG(si)+WORD_REG(ax)*4])\
AS2( mov eax, [s(i+3)])\
AS2( xor AS_REG_7d, [s(i+2)])\
AS2( add R1##j, AS_REG_7d)\
AS2( movzx AS_REG_7d, al)\
AS2( shr eax, 8)\
AS2( xor AS_REG_6d, [WORD_REG(si)+1024+AS_REG_7*4])\
AS2( xor AS_REG_6d, eax)\
AS2( imul R2##j, AS_HEX(54655307))\
AS2( rol R2##j, 7)\
AS2( mov [s(i+0)], AS_REG_6d)\
ASL(2) // outer loop, each iteration of this processes 80 words
AS2( lea WORD_REG(di), [SSE2_uvStart]) // start of v and u
AS2( mov WORD_REG(ax), 80)
AS2( cmp WORD_REG(si), 80)
AS2( cmovg WORD_REG(si), WORD_REG(ax))
AS2( mov SSE2_wordsLeft2, WORD_REG(si))
AS2( lea WORD_REG(si), [WORD_REG(di)+WORD_REG(si)]) // use to end first inner loop
AS2( mov SSE2_diEnd, WORD_REG(si))
#ifdef _MSC_VER
AS2( lea WORD_REG(si), s_sosemanukMulTables)
#else
AS2( mov WORD_REG(si), SSE2_pMulTables)
#endif
ASL(0) // first inner loop, 20 words each, 4 iterations
SSE2_STEP(0, 0)
SSE2_STEP(1, 1)
SSE2_STEP(2, 0)
SSE2_STEP(3, 1)
SSE2_STEP(4, 0)
SSE2_STEP(5, 1)
SSE2_STEP(6, 0)
SSE2_STEP(7, 1)
SSE2_STEP(8, 0)
SSE2_STEP(9, 1)
SSE2_STEP(10, 0)
SSE2_STEP(11, 1)
SSE2_STEP(12, 0)
SSE2_STEP(13, 1)
SSE2_STEP(14, 0)
SSE2_STEP(15, 1)
SSE2_STEP(16, 0)
SSE2_STEP(17, 1)
SSE2_STEP(18, 0)
SSE2_STEP(19, 1)
// loop
AS2( add WORD_REG(di), 5*4)
AS2( cmp WORD_REG(di), SSE2_diEnd)
ASJ( jne, 0, b)
AS2( mov WORD_REG(ax), SSE2_input)
AS2( mov AS_REG_7, SSE2_output)
AS2( lea WORD_REG(di), [SSE2_uvStart]) // start of v and u
AS2( mov WORD_REG(si), SSE2_wordsLeft2)
ASL(1) // second inner loop, 16 words each, 5 iterations
AS2( movdqa xmm0, [WORD_REG(di)+0*20*4])
AS2( movdqa xmm2, [WORD_REG(di)+2*20*4])
AS2( movdqa xmm3, [WORD_REG(di)+3*20*4])
AS2( movdqa xmm1, [WORD_REG(di)+1*20*4])
// S2
AS2( movdqa xmm4, xmm0)
AS2( pand xmm0, xmm2)
AS2( pxor xmm0, xmm3)
AS2( pxor xmm2, xmm1)
AS2( pxor xmm2, xmm0)
AS2( por xmm3, xmm4)
AS2( pxor xmm3, xmm1)
AS2( pxor xmm4, xmm2)
AS2( movdqa xmm1, xmm3)
AS2( por xmm3, xmm4)
AS2( pxor xmm3, xmm0)
AS2( pand xmm0, xmm1)
AS2( pxor xmm4, xmm0)
AS2( pxor xmm1, xmm3)
AS2( pxor xmm1, xmm4)
AS2( pxor xmm4, xmm7)
// xor with v
AS2( pxor xmm2, [WORD_REG(di)+80*4])
AS2( pxor xmm3, [WORD_REG(di)+80*5])
AS2( pxor xmm1, [WORD_REG(di)+80*6])
AS2( pxor xmm4, [WORD_REG(di)+80*7])
// exit loop early if less than 16 words left to output
// this is necessary because block size is 20 words, and we output 16 words in each iteration of this loop
AS2( cmp WORD_REG(si), 16)
ASJ( jl, 4, f)
// unpack
AS2( movdqa xmm6, xmm2)
AS2( punpckldq xmm2, xmm3)
AS2( movdqa xmm5, xmm1)
AS2( punpckldq xmm1, xmm4)
AS2( movdqa xmm0, xmm2)
AS2( punpcklqdq xmm2, xmm1)
AS2( punpckhqdq xmm0, xmm1)
AS2( punpckhdq xmm6, xmm3)
AS2( punpckhdq xmm5, xmm4)
AS2( movdqa xmm3, xmm6)
AS2( punpcklqdq xmm6, xmm5)
AS2( punpckhqdq xmm3, xmm5)
// output keystream
AS_XMM_OUTPUT4(SSE2_Sosemanuk_Output, WORD_REG(ax), AS_REG_7, 2,0,6,3, 1, 0,1,2,3, 4)
// loop
AS2( add WORD_REG(di), 4*4)
AS2( sub WORD_REG(si), 16)
ASJ( jnz, 1, b)
// outer loop
AS2( mov WORD_REG(si), SSE2_wordsLeft)
AS2( sub WORD_REG(si), 80)
ASJ( jz, 6, f)
AS2( mov SSE2_wordsLeft, WORD_REG(si))
AS2( mov SSE2_input, WORD_REG(ax))
AS2( mov SSE2_output, AS_REG_7)
ASJ( jmp, 2, b)
ASL(4) // final output of less than 16 words
AS2( test WORD_REG(ax), WORD_REG(ax))
ASJ( jz, 5, f)
AS2( movd xmm0, dword ptr [WORD_REG(ax)+0*4])
AS2( pxor xmm2, xmm0)
AS2( movd xmm0, dword ptr [WORD_REG(ax)+1*4])
AS2( pxor xmm3, xmm0)
AS2( movd xmm0, dword ptr [WORD_REG(ax)+2*4])
AS2( pxor xmm1, xmm0)
AS2( movd xmm0, dword ptr [WORD_REG(ax)+3*4])
AS2( pxor xmm4, xmm0)
AS2( add WORD_REG(ax), 16)
ASL(5)
AS2( movd dword ptr [AS_REG_7+0*4], xmm2)
AS2( movd dword ptr [AS_REG_7+1*4], xmm3)
AS2( movd dword ptr [AS_REG_7+2*4], xmm1)
AS2( movd dword ptr [AS_REG_7+3*4], xmm4)
AS2( sub WORD_REG(si), 4)
ASJ( jz, 6, f)
AS2( add AS_REG_7, 16)
AS2( psrldq xmm2, 4)
AS2( psrldq xmm3, 4)
AS2( psrldq xmm1, 4)
AS2( psrldq xmm4, 4)
ASJ( jmp, 4, b)
ASL(6) // save state
AS2( mov AS_REG_6, SSE2_state)
AS2( movdqa xmm0, [SSE2_stateCopy+0*16])
AS2( movdqa [AS_REG_6+0*16], xmm0)
AS2( movdqa xmm0, [SSE2_stateCopy+1*16])
AS2( movdqa [AS_REG_6+1*16], xmm0)
AS2( movq xmm0, QWORD PTR [SSE2_stateCopy+2*16])
AS2( movq QWORD PTR [AS_REG_6+2*16], xmm0)
AS2( mov [AS_REG_6+10*4], ecx)
AS2( mov [AS_REG_6+11*4], edx)
AS_POP_IF86( sp)
AS_POP_IF86( bp)
#ifdef __GNUC__
AS_POP_IF86( bx)
".att_syntax prefix;"
:
: "a" (m_state.m_ptr), "c" (iterationCount), "S" (s_sosemanukMulTables), "D" (output), "d" (input)
#if CRYPTOPP_BOOL_X64
, "r" (workspace.m_ptr)
: "memory", "cc", "%r9", "%r10", "%xmm0", "%xmm1", "%xmm2", "%xmm3", "%xmm4", "%xmm5", "%xmm6", "%xmm7"
#else
: "memory", "cc"
#endif
);
#endif
#ifdef CRYPTOPP_GENERATE_X64_MASM
movdqa xmm6, [rsp + 02f0h]
movdqa xmm7, [rsp + 0300h]
add rsp, 80*4*2+12*4+8*WORD_SZ + 2*16+8
pop rdi
pop rsi
ret
Sosemanuk_OperateKeystream ENDP
#else
}
else
#endif
#endif
#ifndef CRYPTOPP_GENERATE_X64_MASM
{
#if CRYPTOPP_BOOL_X86 | CRYPTOPP_BOOL_X64
#define MUL_A(x) (x = rotlFixed(x, 8), x ^ s_sosemanukMulTables[byte(x)])
#else
#define MUL_A(x) (((x) << 8) ^ s_sosemanukMulTables[(x) >> 24])
#endif
#define DIV_A(x) (((x) >> 8) ^ s_sosemanukMulTables[256 + byte(x)])
#define r1(i) ((i%2) ? reg2 : reg1)
#define r2(i) ((i%2) ? reg1 : reg2)
#define STEP(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, v, u) \
u = (s##x9 + r2(x0)) ^ r1(x0);\
v = s##x0;\
s##x0 = MUL_A(s##x0) ^ DIV_A(s##x3) ^ s##x9;\
r1(x0) += XMUX(r2(x0), s##x2, s##x9);\
r2(x0) = rotlFixed(r2(x0) * 0x54655307, 7);\
#define SOSEMANUK_OUTPUT(x) \
CRYPTOPP_KEYSTREAM_OUTPUT_WORD(x, LITTLE_ENDIAN_ORDER, 0, u2 ^ v0);\
CRYPTOPP_KEYSTREAM_OUTPUT_WORD(x, LITTLE_ENDIAN_ORDER, 1, u3 ^ v1);\
CRYPTOPP_KEYSTREAM_OUTPUT_WORD(x, LITTLE_ENDIAN_ORDER, 2, u1 ^ v2);\
CRYPTOPP_KEYSTREAM_OUTPUT_WORD(x, LITTLE_ENDIAN_ORDER, 3, u4 ^ v3);
#define OUTPUT4 \
S2(0, u0, u1, u2, u3, u4);\
CRYPTOPP_KEYSTREAM_OUTPUT_SWITCH(SOSEMANUK_OUTPUT, 4*4);
word32 s0 = m_state[0];
word32 s1 = m_state[1];
word32 s2 = m_state[2];
word32 s3 = m_state[3];
word32 s4 = m_state[4];
word32 s5 = m_state[5];
word32 s6 = m_state[6];
word32 s7 = m_state[7];
word32 s8 = m_state[8];
word32 s9 = m_state[9];
word32 reg1 = m_state[10];
word32 reg2 = m_state[11];
word32 u0, u1, u2, u3, u4, v0, v1, v2, v3;
do
{
STEP(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, v0, u0)
STEP(1, 2, 3, 4, 5, 6, 7, 8, 9, 0, v1, u1)
STEP(2, 3, 4, 5, 6, 7, 8, 9, 0, 1, v2, u2)
STEP(3, 4, 5, 6, 7, 8, 9, 0, 1, 2, v3, u3)
OUTPUT4
STEP(4, 5, 6, 7, 8, 9, 0, 1, 2, 3, v0, u0)
STEP(5, 6, 7, 8, 9, 0, 1, 2, 3, 4, v1, u1)
STEP(6, 7, 8, 9, 0, 1, 2, 3, 4, 5, v2, u2)
STEP(7, 8, 9, 0, 1, 2, 3, 4, 5, 6, v3, u3)
OUTPUT4
STEP(8, 9, 0, 1, 2, 3, 4, 5, 6, 7, v0, u0)
STEP(9, 0, 1, 2, 3, 4, 5, 6, 7, 8, v1, u1)
STEP(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, v2, u2)
STEP(1, 2, 3, 4, 5, 6, 7, 8, 9, 0, v3, u3)
OUTPUT4
STEP(2, 3, 4, 5, 6, 7, 8, 9, 0, 1, v0, u0)
STEP(3, 4, 5, 6, 7, 8, 9, 0, 1, 2, v1, u1)
STEP(4, 5, 6, 7, 8, 9, 0, 1, 2, 3, v2, u2)
STEP(5, 6, 7, 8, 9, 0, 1, 2, 3, 4, v3, u3)
OUTPUT4
STEP(6, 7, 8, 9, 0, 1, 2, 3, 4, 5, v0, u0)
STEP(7, 8, 9, 0, 1, 2, 3, 4, 5, 6, v1, u1)
STEP(8, 9, 0, 1, 2, 3, 4, 5, 6, 7, v2, u2)
STEP(9, 0, 1, 2, 3, 4, 5, 6, 7, 8, v3, u3)
OUTPUT4
}
while (--iterationCount);
m_state[0] = s0;
m_state[1] = s1;
m_state[2] = s2;
m_state[3] = s3;
m_state[4] = s4;
m_state[5] = s5;
m_state[6] = s6;
m_state[7] = s7;
m_state[8] = s8;
m_state[9] = s9;
m_state[10] = reg1;
m_state[11] = reg2;
}
}
NAMESPACE_END
#endif // #ifndef CRYPTOPP_GENERATE_X64_MASM
| [
"Mike.Ken.S@dd569cc8-ff36-11de-bbca-1111db1fd05b",
"[email protected]@dd569cc8-ff36-11de-bbca-1111db1fd05b"
]
| [
[
[
1,
21
],
[
23,
23
],
[
26,
295
],
[
297,
351
],
[
353,
418
],
[
422,
426
],
[
428,
599
],
[
602,
711
]
],
[
[
22,
22
],
[
24,
25
],
[
296,
296
],
[
352,
352
],
[
419,
421
],
[
427,
427
],
[
600,
601
]
]
]
|
3db65ebcf48e27be162511379cb18f8032f147c2 | 436c40ae4fd156e1c53a2a9915fdf9ea67c0eca0 | /src/test.cpp | 62f7767198d7077d2067b530ee3e10229abc8a69 | []
| no_license | mweiguo/tinylogger | 06490d51aa317842ae007f8fc9a265f409b5d6c0 | c86675cf926b1e3a2ab1f826b951ca20197d5845 | refs/heads/master | 2021-01-13T02:06:12.999545 | 2010-12-29T12:54:08 | 2010-12-29T12:54:08 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 595 | cpp | #include "tinyLog.h"
//#include <windows.h>
int main(int argc, char* argv[])
{
LOG_LEVEL ( tinyLog::info );
LOG_FORMAT ( "%25(asctime)'%(filename)' : %(lineno) : %(funame)\t:\t" );
// LOG_ALLDESTINATION ( "d:\\test.log" );
// LOG_DESTINATION ( tinyLog::warning, "d:\\warning.log" );
// LOG_DESTINATION ( tinyLog::error, "d:\\warning.log" );
for ( int i=0; i<60; i++ ) {
LOG_INFO ( "log message%10d", 1 );
LOG_WARNING ( "warn message" );
LOG_ERROR ( "error message" );
LOG_DEBUG ( "debug message" );
Sleep ( 1000 );
}
return 0;
}
| [
"[email protected]"
]
| [
[
[
1,
20
]
]
]
|
8b06f50e32136f2337546fc08b9007f6f6bbd72b | 74c8da5b29163992a08a376c7819785998afb588 | /NetAnimal/addons/pa/ParticleUniverse/src/ParticleObservers/ParticleUniverseOnPositionObserver.cpp | dad2dc5184e4fb7557d951e30554265b078821ed | []
| no_license | dbabox/aomi | dbfb46c1c9417a8078ec9a516cc9c90fe3773b78 | 4cffc8e59368e82aed997fe0f4dcbd7df626d1d0 | refs/heads/master | 2021-01-13T14:05:10.813348 | 2011-06-07T09:36:41 | 2011-06-07T09:36:41 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,295 | cpp | /*
-----------------------------------------------------------------------------------------------
This source file is part of the Particle Universe product.
Copyright (c) 2010 Henry van Merode
Usage of this program is licensed under the terms of the Particle Universe Commercial License.
You can find a copy of the Commercial License in the Particle Universe package.
-----------------------------------------------------------------------------------------------
*/
#include "ParticleUniversePCH.h"
#ifndef PARTICLE_UNIVERSE_EXPORTS
#define PARTICLE_UNIVERSE_EXPORTS
#endif
#include "ParticleObservers/ParticleUniverseOnPositionObserver.h"
namespace ParticleUniverse
{
// Constants
const Ogre::Vector3 OnPositionObserver::DEFAULT_POSITION_THRESHOLD = Ogre::Vector3::ZERO;
//-----------------------------------------------------------------------
OnPositionObserver::OnPositionObserver(void) :
ParticleObserver(),
mPositionXThreshold(DEFAULT_POSITION_THRESHOLD.x),
mPositionYThreshold(DEFAULT_POSITION_THRESHOLD.y),
mPositionZThreshold(DEFAULT_POSITION_THRESHOLD.z),
mComparePositionX(CO_LESS_THAN),
mComparePositionY(CO_LESS_THAN),
mComparePositionZ(CO_LESS_THAN),
mPositionXThresholdSet(false),
mPositionYThresholdSet(false),
mPositionZThresholdSet(false)
{
};
//-----------------------------------------------------------------------
bool OnPositionObserver::_observe (ParticleTechnique* particleTechnique, Particle* particle, Ogre::Real timeElapsed)
{
if (!particle)
return false;
if (mPositionXThresholdSet && mComparePositionX == CO_LESS_THAN && particle->position.x < mPositionXThreshold)
return true;
if (mPositionXThresholdSet && mComparePositionX == CO_GREATER_THAN && particle->position.x > mPositionXThreshold)
return true;
if (mPositionYThresholdSet && mComparePositionY == CO_LESS_THAN && particle->position.y < mPositionYThreshold)
return true;
if (mPositionYThresholdSet && mComparePositionY == CO_GREATER_THAN && particle->position.y > mPositionYThreshold)
return true;
if (mPositionZThresholdSet && mComparePositionZ == CO_LESS_THAN && particle->position.z < mPositionZThreshold)
return true;
if (mPositionZThresholdSet && mComparePositionZ == CO_GREATER_THAN && particle->position.z > mPositionZThreshold)
return true;
return false;
}
//-----------------------------------------------------------------------
void OnPositionObserver::copyAttributesTo(ParticleObserver* observer)
{
ParticleObserver::copyAttributesTo(observer);
OnPositionObserver* onPositionObserver = static_cast<OnPositionObserver*>(observer);
onPositionObserver->mPositionXThreshold = mPositionXThreshold;
onPositionObserver->mPositionYThreshold = mPositionYThreshold;
onPositionObserver->mPositionZThreshold = mPositionZThreshold;
onPositionObserver->mComparePositionX = mComparePositionX;
onPositionObserver->mComparePositionY = mComparePositionY;
onPositionObserver->mComparePositionZ = mComparePositionZ;
onPositionObserver->mPositionXThresholdSet = mPositionXThresholdSet;
onPositionObserver->mPositionYThresholdSet = mPositionYThresholdSet;
onPositionObserver->mPositionZThresholdSet = mPositionZThresholdSet;
}
}
| [
"[email protected]"
]
| [
[
[
1,
79
]
]
]
|
43e8aa5cdc0990738880fdfc082a07e20f741e8b | 709cd826da3ae55945fd7036ecf872ee7cdbd82a | /Term/WildMagic2/Renderers/OpenGL/WmlWglRenderer.h | 361b442b8e55291d972a4868f9777d55f08ebacb | []
| no_license | argapratama/kucgbowling | 20dbaefe1596358156691e81ccceb9151b15efb0 | 65e40b6f33c5511bddf0fa350c1eefc647ace48a | refs/heads/master | 2018-01-08T15:27:44.784437 | 2011-06-19T15:23:39 | 2011-06-19T15:23:39 | 36,738,655 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,832 | h | // Magic Software, Inc.
// http://www.magic-software.com
// http://www.wild-magic.com
// Copyright (c) 2003. All Rights Reserved
//
// The Wild Magic Library (WML) source code is supplied under the terms of
// the license agreement http://www.magic-software.com/License/WildMagic.pdf
// and may not be copied or disclosed except in accordance with the terms of
// that agreement.
#ifndef WMLWGLRENDERER_H
#define WMLWGLRENDERER_H
#include "WmlOpenGLRenderer.h"
#include <map>
namespace Wml
{
class WML_RENDERER_ITEM WglRenderer : public OpenGLRenderer
{
WmlDeclareRTTI;
public:
// construction and destruction
WglRenderer (HWND hWnd, int iWidth, int iHeight);
virtual ~WglRenderer ();
virtual void DisplayBackBuffer ();
virtual void Draw (int iX, int iY, const ColorRGB& rkColor,
const char* acText);
virtual bool LoadFont (const RendererFont& rkFont);
virtual void UnloadFont (const RendererFont& rkFont);
virtual void Draw (int iX, int iY, const RendererFont& rkFont,
const char* acText);
// Test if a specified extension is supported. If you need to test for
// multiple extensions, the function must be called for each extension.
// The extensions could vary per rendering context, so check for
// extensions immediately after setting the context.
static bool ExtensionSupported (const char* acExt);
protected:
class WML_RENDERER_ITEM FontDesc
{
public:
RendererFont kFont;
int iListStart;
int iNumChars;
int iListBase;
};
// window parameters
HWND m_hWnd;
HDC m_hWindowDC;
HGLRC m_hWindowRC;
FontDesc m_kDefaultFont;
std::map<unsigned int,FontDesc*> m_kFontMap;
};
WmlSmartPointer(WglRenderer);
}
#endif
| [
"[email protected]"
]
| [
[
[
1,
65
]
]
]
|
b181ba2ca9d1f3c86614f67048e796902ec04319 | d2e6d2d8f8bdf4e5eae823e1f1aef71164954df5 | /vsprojects/Viewer/MainFrm.h | 1d41f89a749e32446a79cc7816e6ba34950d1e18 | []
| no_license | beru/hew-io-file | 0c6bbb43a980eeb8a5fe1888c2ce5ecc20855d63 | ee4d5fd46de4a86294a19f16c178194f5addf28a | refs/heads/master | 2016-08-04T02:06:40.622339 | 2011-10-02T15:16:00 | 2011-10-02T15:16:00 | 33,050,465 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,262 | h | // MainFrm.h : interface of the CMainFrame class
//
/////////////////////////////////////////////////////////////////////////////
#pragma once
class CMainFrame : public CFrameWindowImpl<CMainFrame>, public CUpdateUI<CMainFrame>,
public CMessageFilter, public CIdleHandler
{
public:
DECLARE_FRAME_WND_CLASS(NULL, IDR_MAINFRAME)
CViewerView m_view;
CCommandBarCtrl m_CmdBar;
virtual BOOL PreTranslateMessage(MSG* pMsg);
virtual BOOL OnIdle();
BEGIN_UPDATE_UI_MAP(CMainFrame)
UPDATE_ELEMENT(ID_VIEW_TOOLBAR, UPDUI_MENUPOPUP)
UPDATE_ELEMENT(ID_VIEW_STATUS_BAR, UPDUI_MENUPOPUP)
END_UPDATE_UI_MAP()
BEGIN_MSG_MAP(CMainFrame)
MESSAGE_HANDLER(WM_CREATE, OnCreate)
MESSAGE_HANDLER(WM_DESTROY, OnDestroy)
COMMAND_ID_HANDLER(ID_APP_EXIT, OnFileExit)
COMMAND_ID_HANDLER(ID_FILE_NEW, OnFileNew)
COMMAND_ID_HANDLER(ID_VIEW_TOOLBAR, OnViewToolBar)
COMMAND_ID_HANDLER(ID_VIEW_STATUS_BAR, OnViewStatusBar)
COMMAND_ID_HANDLER(ID_APP_ABOUT, OnAppAbout)
COMMAND_ID_HANDLER(ID_FILE_OPEN, OnFileOpen)
CHAIN_MSG_MAP(CUpdateUI<CMainFrame>)
CHAIN_MSG_MAP(CFrameWindowImpl<CMainFrame>)
END_MSG_MAP()
// Handler prototypes (uncomment arguments if needed):
// LRESULT MessageHandler(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
// LRESULT CommandHandler(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
// LRESULT NotifyHandler(int /*idCtrl*/, LPNMHDR /*pnmh*/, BOOL& /*bHandled*/)
LRESULT OnCreate(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/);
LRESULT OnDestroy(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled);
LRESULT OnFileExit(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/);
LRESULT OnFileNew(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/);
LRESULT OnViewToolBar(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/);
LRESULT OnViewStatusBar(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/);
LRESULT OnAppAbout(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/);
LRESULT OnFileOpen(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/);
};
| [
"[email protected]"
]
| [
[
[
1,
50
]
]
]
|
b46934af3373a9af5aa0ab0f9e7d4cf451482418 | 478570cde911b8e8e39046de62d3b5966b850384 | /apicompatanamdw/bcdrivers/mw/classicui/uifw/apps/S60_SDK3.0/bctestvolume/inc/bctestvolumecontainer.h | 5ee09ff27d3cd14bf05379b3c35f54164c6de690 | []
| no_license | SymbianSource/oss.FCL.sftools.ana.compatanamdw | a6a8abf9ef7ad71021d43b7f2b2076b504d4445e | 1169475bbf82ebb763de36686d144336fcf9d93b | refs/heads/master | 2020-12-24T12:29:44.646072 | 2010-11-11T14:03:20 | 2010-11-11T14:03:20 | 72,994,432 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,410 | h | /*
* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: Declares container control for application.
*
*/
#ifndef C_BCTESTVOLUMECONTAINER_H
#define C_BCTESTVOLUMECONTAINER_H
// INCLUDES
#include <coecntrl.h>
#include <apadef.h>
// FORWARD DECLARATIONS
class CEikLabel;
class CAknNavigationControlContainer;
class CAknNavigationDecorator;
class CBCTestVolumeView;
class CBCTestVolumePopUpWindow;
class CAknVolumePopup;
// CLASS DECLARATION
/**
* CBCTestVolumeContainer container control class.
*/
class CBCTestVolumeContainer : public CCoeControl
{
private: // Enumerations
enum TBCTestVolumeComponentControls
{
EBCTestVolumeComponent1,
EBCTestVolumeComponent2
};
public: // Constructors and destructor
/**
* Overload constructor.
* @param aView Pointer to view class object.
*/
CBCTestVolumeContainer( CBCTestVolumeView* aView );
/**
* Symbian 2nd phase constructor.
* @param aRect Frame rectangle for container.
*/
void ConstructL( const TRect& aRect );
/**
* Destructor.
*/
virtual ~CBCTestVolumeContainer();
public: // New functions
/**
* Displays each outline screen.
* @param aOutlineId The ID of outline to display it.
*/
void DisplayOutlineL( const TInt aOutlineId );
/**
* Delete all components and set them to NULL.
*/
void ResetComponentsL();
/**
* Update components for redraw.
*/
void UpdateComponentsL();
/**
* Getter of the navigation pane.
*/
CAknNavigationControlContainer* NaviPane();
/**
* Setter of the decorator in the navigation pane.
* @param aDecorator, the decorator you want to set.
*/
void SetDecorator(CAknNavigationDecorator* aDecorator);
/**
* Creates the label object.
* @param aResourceId The ID of resource to create that.
*/
void CreateLabelL( const TInt aResourceId );
private: // New function
/**
* Release the navigation pane as well as the decorator.
*/
void ResetNaviPane();
private: // From CCoeControl
/**
* From CCoeControl, OfferKeyEventL.
* Handles the key events.
* @return If key-event is consumed, EKeyWasConsumed.
* Else EKeyWasNotConsumed.
* @param aKeyEvent Key event
* @param aType Type of key event(EEventKey, EEventKeyUp or
* EEventKeyDown).
*/
TKeyResponse OfferKeyEventL(
const TKeyEvent& aKeyEvent,
TEventCode aType );
/**
* From CoeControl,SizeChanged.
* Called by framework when the view size is changed.
*/
void SizeChanged();
/**
* From CoeControl,CountComponentControls.
* Returns number of component.
* @return Number of controls.
*/
TInt CountComponentControls() const;
/**
* From CCoeControl,ComponentControl.
* Returns pointer to particular component.
* @return Pointer to Control's component control, identified by index.
* @param aIndex Index of the control.
*/
CCoeControl* ComponentControl( TInt aIndex ) const;
/**
* From CCoeControl,Draw.
* @param aRect Region of the control to be (re)drawn.
*/
void Draw( const TRect& aRect ) const;
/**
* From CCoeControl, HandleResourceChange.
* Make dynamic resolution change smoother.
* @param aType A message UID value.
*/
void HandleResourceChange( TInt aType );
private: // Data
/**
* lable to show the neccessary informations
* own
*/
CEikLabel* iLabel;
/**
* point to navigation pane
* own
*/
CAknNavigationControlContainer* iNaviPane;
/**
* point to decorator in the navigation pane.
* own
*/
CAknNavigationDecorator* iDecorator;
/**
* point to the active view
* not own.
*/
CBCTestVolumeView* iView;
/**
* record the the current outline ID
*/
TInt iCurrentOutlineId;
/**
* a popup control for masking clock
* own.
*/
CBCTestVolumePopUpWindow* iPopUpControl;
TInt iVolume;
TBool iMuted;
TInt32 iKeyHandle1;
TInt32 iKeyHandle2;
TInt32 iKeyHandle3;
TInt32 iKeyHandle4;
};
#endif // C_BCTESTVOLUMECONTAINER_H
// End of File
| [
"none@none"
]
| [
[
[
1,
208
]
]
]
|
60d16c7bbc8797024a5b627fc6cfdd4f65085933 | 4a266d6931aa06a2343154cab99d8d5cfdac6684 | /csci3081/project-phase3/include/ModelFactory.h | 620db278caba10b4c4e2f649872a12e496be6c56 | []
| no_license | Magneticmagnum/robotikdude-school | f0185feb6839ad5c5324756fc86f984fce7abdc1 | cb39138b500c8bbc533e796225588439dcfa6555 | refs/heads/master | 2021-01-10T19:01:39.479621 | 2011-05-17T04:44:47 | 2011-05-17T04:44:47 | 35,382,573 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,233 | h | #ifndef MODELFACTORY_H_
#define MODELFACTORY_H_
#include "Model.h"
#include "Scheduler.h"
#include "House.h"
#include "Bath.h"
#include "Dishwasher.h"
#include "Microwave.h"
#include "Oven.h"
#include "PersonB.h"
#include "Refrigerator.h"
#include "Shower.h"
#include "Stove.h"
#include "Television.h"
#include "Toaster.h"
#include "WaterHeater.h"
#include "Random.h"
#include <log4cxx/logger.h>
#include <string>
#include <map>
// TODO user23: comment all
class ModelFactory
{
public:
ModelFactory(Scheduler* scheduler);
virtual ~ModelFactory();
Model* getModel(const std::string& model);
Model* createModel(const std::string& type, const std::string& name,
const std::string& configFile, House* house);
House* getHouse(const std::string& house);
House* createHouse(const std::string& house, const std::string& configFile);
Bath* getBath(const std::string& bath);
Bath* createBath(const std::string& bath, const std::string& configFile,
House* house);
Dishwasher* getDishwasher(const std::string& dishwasher);
Dishwasher* createDishwasher(const std::string& dishwasher,
const std::string& configFile, House* house);
Microwave* getMicrowave(const std::string& microwave);
Microwave* createMicrowave(const std::string& microwave,
const std::string& configFile, House* house);
Oven* getOven(const std::string& oven);
Oven* createOven(const std::string& oven, const std::string& configFile,
House* house);
Person* getPerson(const std::string& person);
Person* createPerson(const std::string& person,
const std::string& configFile, House* house);
Refrigerator* getRefrigerator(const std::string& refrigerator);
Refrigerator* createRefrigerator(const std::string& refrigerator,
const std::string& configFile,
House* house);
Shower* getShower(const std::string& shower);
Shower* createShower(const std::string& shower,
const std::string& configFile, House* house);
Stove* getStove(const std::string& stove);
Stove* createStove(const std::string& stove, const std::string& configFile,
House* house);
Television* getTelevision(const std::string& television);
Television* createTelevision(const std::string& television,
const std::string& configFile, House* house);
Toaster* getToaster(const std::string& toaster);
Toaster* createToaster(const std::string& toaster,
const std::string& configFile, House* house);
WaterHeater* getWaterHeater(const std::string& waterheater);
WaterHeater* createWaterHeater(const std::string& waterheater,
const std::string& configFile, House* house);
private:
ModelMap models_;
Scheduler* scheduler_;
Random* random_;
static log4cxx::LoggerPtr log_;
};
#endif /* MODELFACTORY_H_ */
| [
"robotikdude@e80761d0-8fc2-79d0-c9d0-3546e327c268"
]
| [
[
[
1,
99
]
]
]
|
07712a44a2ac1a9e424475126fd4b215960bf2a0 | 83ed25c6e6b33b2fabd4f81bf91d5fae9e18519c | /code/DefaultIOStream.h | bcb6244d8cbbd378c5c0326589fd6b15dbd5228b | [
"BSD-3-Clause"
]
| permissive | spring/assimp | fb53b91228843f7677fe8ec18b61d7b5886a6fd3 | db29c9a20d0dfa9f98c8fd473824bba5a895ae9e | refs/heads/master | 2021-01-17T23:19:56.511185 | 2011-11-08T12:15:18 | 2011-11-08T12:15:18 | 2,017,841 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 4,327 | h | /*
Open Asset Import Library (ASSIMP)
----------------------------------------------------------------------
Copyright (c) 2006-2010, ASSIMP Development Team
All rights reserved.
Redistribution and use of this software in source and binary forms,
with or without modification, are permitted provided that the
following conditions are met:
* Redistributions of source code must retain the above
copyright notice, this list of conditions and the
following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the
following disclaimer in the documentation and/or other
materials provided with the distribution.
* Neither the name of the ASSIMP team, nor the names of its
contributors may be used to endorse or promote products
derived from this software without specific prior
written permission of the ASSIMP Development Team.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------
*/
/** @file Default file I/O using fXXX()-family of functions */
#ifndef AI_DEFAULTIOSTREAM_H_INC
#define AI_DEFAULTIOSTREAM_H_INC
#include <stdio.h>
#include "../include/IOStream.h"
namespace Assimp {
// ----------------------------------------------------------------------------------
//! @class DefaultIOStream
//! @brief Default IO implementation, use standard IO operations
//! @note An instance of this class can exist without a valid file handle
//! attached to it. All calls fail, but the instance can nevertheless be
//! used with no restrictions.
class DefaultIOStream : public IOStream
{
friend class DefaultIOSystem;
protected:
DefaultIOStream ();
DefaultIOStream (FILE* pFile, const std::string &strFilename);
public:
/** Destructor public to allow simple deletion to close the file. */
~DefaultIOStream ();
// -------------------------------------------------------------------
// Read from stream
size_t Read(void* pvBuffer,
size_t pSize,
size_t pCount);
// -------------------------------------------------------------------
// Write to stream
size_t Write(const void* pvBuffer,
size_t pSize,
size_t pCount);
// -------------------------------------------------------------------
// Seek specific position
aiReturn Seek(size_t pOffset,
aiOrigin pOrigin);
// -------------------------------------------------------------------
// Get current seek position
size_t Tell() const;
// -------------------------------------------------------------------
// Get size of file
size_t FileSize() const;
// -------------------------------------------------------------------
// Flush file contents
void Flush();
private:
//! File datastructure, using clib
FILE* mFile;
//! Filename
std::string mFilename;
//! Cached file size
mutable size_t cachedSize;
};
// ----------------------------------------------------------------------------------
inline DefaultIOStream::DefaultIOStream () :
mFile (NULL),
mFilename (""),
cachedSize (SIZE_MAX)
{
// empty
}
// ----------------------------------------------------------------------------------
inline DefaultIOStream::DefaultIOStream (FILE* pFile,
const std::string &strFilename) :
mFile(pFile),
mFilename(strFilename),
cachedSize (SIZE_MAX)
{
// empty
}
// ----------------------------------------------------------------------------------
} // ns assimp
#endif //!!AI_DEFAULTIOSTREAM_H_INC
| [
"aramis_acg@67173fc5-114c-0410-ac8e-9d2fd5bffc1f",
"kimmi@67173fc5-114c-0410-ac8e-9d2fd5bffc1f",
"ulfjorensen@67173fc5-114c-0410-ac8e-9d2fd5bffc1f"
]
| [
[
[
1,
40
],
[
48,
48
],
[
50,
55
],
[
69,
69
],
[
76,
76
],
[
82,
82
],
[
87,
87
],
[
90,
91
],
[
94,
97
],
[
103,
105
],
[
107,
109
],
[
111,
113
],
[
118,
119
],
[
123,
124
],
[
128,
128
],
[
133,
133
]
],
[
[
41,
45
],
[
47,
47
],
[
49,
49
],
[
56,
68
],
[
70,
75
],
[
77,
81
],
[
83,
86
],
[
88,
89
],
[
92,
93
],
[
98,
102
],
[
106,
106
],
[
110,
110
],
[
114,
117
],
[
120,
122
],
[
125,
127
],
[
129,
132
]
],
[
[
46,
46
]
]
]
|
5115ef2fd684b50a6d05980c5f69332bff5e6fb7 | c86f787916e295d20607cbffc13c524018888a0f | /tp1/codigo/ejercicio2/benchmark/poda_cant_operaciones/Cosa.cpp | 08b63e301ad426651a2d514dfd7adaed3ce0229d | []
| no_license | federicoemartinez/algo3-2008 | 0039a4bc6d83ab8005fa2169b919e6c03524bad5 | 3b04cbea4583d76d7a97f2aee72493b4b571a77b | refs/heads/master | 2020-06-05T05:56:20.127248 | 2008-08-04T04:59:32 | 2008-08-04T04:59:32 | 32,117,945 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 264 | cpp | #include "Cosa.h"
Cosa :: Cosa(){};
Cosa :: Cosa(unsigned v, unsigned c) {
valor = v;
peso = c;
}
std::ostream& operator<< (std::ostream& o, const Cosa& c) {
return o << "Cosa de valor: " << c.valor << " y costo " << c.peso << endl;
}
| [
"seges.ar@bfd18afd-6e49-0410-abef-09437ef2666c"
]
| [
[
[
1,
13
]
]
]
|
38efe3107447f81c8dc49e1a0120e94a79ae94bf | ea12fed4c32e9c7992956419eb3e2bace91f063a | /zombie/code/zombie/nspatial/src/nspatial/noccludingfrustumvisitor.cc | 5959b01c09c2e537266d2acade41324c6a284b3e | []
| no_license | ugozapad/TheZombieEngine | 832492930df28c28cd349673f79f3609b1fe7190 | 8e8c3e6225c2ed93e07287356def9fbdeacf3d6a | refs/heads/master | 2020-04-30T11:35:36.258363 | 2011-02-24T14:18:43 | 2011-02-24T14:18:43 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,227 | cc | #include "precompiled/pchnspatial.h"
//--------------------------------------------------
// noccludingfrustumvisitor.cc
// (C) 2004 Gary Haussmann
//--------------------------------------------------
#include "nspatial/noccludingfrustumvisitor.h"
nOccludingFrustumVisitor::nOccludingFrustumVisitor(const nCamera2 &cameraprojection, const matrix44 &cameratransform)
: nVisibleFrustumVisitor(cameraprojection, cameratransform)
{
// initialize the view frustum, matrix, etc.
}
nOccludingFrustumVisitor::~nOccludingFrustumVisitor()
{
}
void nOccludingFrustumVisitor::Reset()
{
// clear out the occluders
m_occluders.Clear();
nVisibleFrustumVisitor::Reset();
}
void nOccludingFrustumVisitor::Visit(nSpatialSector *visitee, int recursedepth)
{
// bug out if we're hit the bottom of our allowed recursion
if (recursedepth < 1)
return;
// n_assert(visitee->GetOctree() != NULL);
nOctNode *rootnode = visitee->/*GetOctree()->*/GetRoot();
nFrustumClipper::result_info clipinfo;
nFrustumClipper frustum = m_viewfrustumstack.Back();
// record the size of the occluder array before doing this sector
int previousoccludersize = m_occluders.Size();
// get up to 3 occluders for this sector
CollectOccluders(rootnode, frustum, clipinfo, 3);
// if in debug mode, render the view frustum and occluders
if (m_gfxdebug)
{
frustum.VisualizeFrustum(m_gfxdebug, vector4(1.0f,0.0f,1.0f,1.0f));
// draw the occluders
for (nArray<nBBoxOccluder>::iterator bboxi = m_occluders.Begin(); bboxi != m_occluders.End(); bboxi++)
{
bboxi->VisualizeBBox(m_gfxdebug, vector4(0.0f,1.0f,1.0f,1.0f));
}
}
// recursively descend the octree checking each node for clipping
CheckOctNode(rootnode, frustum, clipinfo, recursedepth);
// wipe out any occluders added to the stack upon entering this sector
while (m_occluders.Size() > previousoccludersize)
{
m_occluders.Erase(m_occluders.End()-1);
}
}
void nOccludingFrustumVisitor::CheckOctNode(nOctNode *testnode, nFrustumClipper &clipper, nFrustumClipper::result_info clipstatus, int recursivedepth)
{
// if the node is totally enclosed, trivially accept all the children nodes. otherwise, do a frustum clip test
bbox3 nodebbox ( (testnode->minCorner + testnode->maxCorner)*0.5, (testnode->maxCorner - testnode->minCorner)*0.5);
if (clipstatus.active_planes != 0)
{
clipstatus = clipper.TestBBox(nodebbox, clipstatus);
}
// if the node is culled, then ignore this node and all nodes below it
if (clipstatus.culled)
return;
// if the node is occluded, ignore this node and all nodes below it
if (IsOccluded(sphere(nodebbox.center(), nodebbox.extents().len())))
return;
// this node is not culled. Test all the elements in this node, and then recurse to child nodes.
nOctElement *oe;
for (oe = (nOctElement *) testnode->elm_list.GetHead();
oe;
oe = (nOctElement *) oe->GetSucc())
{
bbox3 thisbbox( (oe->minCorner + oe->maxCorner)*0.5, (oe->maxCorner - oe->minCorner)*0.5);
nFrustumClipper::result_info ri(clipper.TestBBox(thisbbox, clipstatus));
if (!ri.culled)
{
nSpatialElement *se = (nSpatialElement *)oe;
// is this element occluded? skip if it is
if (!IsOccluded(sphere(se->pos, se->radius)))
se->Accept(*this, recursivedepth);
}
}
// now check the children of this node
if (testnode->c[0])
for (int childix=0; childix < 8; childix++)
{
this->CheckOctNode(testnode->c[childix], clipper, clipstatus, recursivedepth);
}
}
// recursive collection of occluders in this octree
int nOccludingFrustumVisitor::CollectOccluders(nOctNode *collectnode, nFrustumClipper &clipper, nFrustumClipper::result_info clipstatus, int maxoccluders)
{
// if the node is totally enclosed, trivially accept all the children nodes. otherwise, do a frustum clip test
bbox3 nodebbox ( (collectnode->minCorner + collectnode->maxCorner)*0.5, (collectnode->maxCorner - collectnode->minCorner)*0.5);
if (clipstatus.active_planes != 0)
{
clipstatus = clipper.TestBBox(nodebbox, clipstatus);
}
// if the node is culled, then ignore this node and all nodes below it
if (clipstatus.culled)
return maxoccluders;
// if the node is occluded, ignore this node and all nodes below it
if (IsOccluded(sphere(nodebbox.center(), nodebbox.extents().len())))
return maxoccluders;
// this node is not culled. Test all the elements in this node, and then recurse to child nodes.
nOctElement *oe;
for (oe = (nOctElement *) collectnode->elm_list.GetHead();
oe;
oe = (nOctElement *) oe->GetSucc())
{
bbox3 thisbbox( (oe->minCorner + oe->maxCorner)*0.5, (oe->maxCorner - oe->minCorner)*0.5);
nFrustumClipper::result_info ri(clipper.TestBBox(thisbbox, clipstatus));
if (!ri.culled)
{
nSpatialElement *se = (nSpatialElement *)oe;
// if it's an occluder then add to the occluder set
if (se->GetSpatialType() & nSpatialElement::N_SPATIAL_OCCLUDER)
{
// stuff a new sphereoccluder on the array
m_occluders.PushBack(nBBoxOccluder(GetViewPoint(), thisbbox));
maxoccluders -= 1;
}
}
}
// now check the children of this node
if (collectnode->c[0])
for (int childix=0; childix < 8; childix++)
{
maxoccluders = this->CollectOccluders(collectnode->c[childix], clipper, clipstatus, maxoccluders);
}
return maxoccluders;
}
bool nOccludingFrustumVisitor::VisibilityTest(nSpatialElement *visitee)
{
// test against the current frustum clipper
nFrustumClipper &clipper = GetFrustumClipper();
nFrustumClipper::result_info in, out;
bbox3 totest( (visitee->minCorner + visitee->maxCorner)*0.5, (visitee->maxCorner - visitee->minCorner)*0.5);
out = clipper.TestBBox( totest, in);
return !out.culled;
}
// checks that a given sphere is not blocked by any occluders
bool nOccludingFrustumVisitor::IsOccluded(const sphere &testsphere)
{
// now check against all occluders as well
for (nArray<nBBoxOccluder>::iterator occluderiter = m_occluders.Begin();
occluderiter != m_occluders.End();
occluderiter++)
{
// does this one occlude it?
nBBoxOccluder::result_info occludetest;
occludetest = occluderiter->TestSphere(testsphere, occludetest);
if (occludetest.culled)
return true;
}
// not occluded
return false;
}
void nOccludingFrustumVisitor::EnterLocalSpace(matrix44 &warp)
{
nVisibilityVisitor::EnterLocalSpace(warp);
}
void nOccludingFrustumVisitor::LeaveLocalSpace()
{
nVisibilityVisitor::LeaveLocalSpace();
}
| [
"magarcias@c1fa4281-9647-0410-8f2c-f027dd5e0a91"
]
| [
[
[
1,
198
]
]
]
|
28e41bbf35d8239505e9738e6c7b3f9a2027101f | 2dbbca065b62a24f47aeb7ec5cd7a4fd82083dd4 | /OUAN/OUAN/Src/Logic/LogicComponent/AttackComponent.h | 4b94e05fe8dc1a176e06d42566dc81feec20428b | []
| no_license | juanjmostazo/once-upon-a-night | 9651dc4dcebef80f0475e2e61865193ad61edaaa | f8d5d3a62952c45093a94c8b073cbb70f8146a53 | refs/heads/master | 2020-05-28T05:45:17.386664 | 2010-10-06T12:49:50 | 2010-10-06T12:49:50 | 38,101,059 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,996 | h | #ifndef ATTACKCOMPONENTH_H
#define ATTACKCOMPONENTH_H
#include "../../Component/Component.h"
namespace OUAN
{
typedef enum
{
ATTACK_TYPE_DEFAULT=0,
ATTACK_TYPE_FLASHLIGHT=1,
ATTACK_TYPE_PILLOW=2
} TAttackType;
class AttackData
{
public:
AttackData(){}
virtual ~AttackData(){}
std::string attackName;
int damage;
int attackRange;
std::string animationName;
double cooldownDelay;
double area; //Area damage radius: 0.0 for single target
int powerCost;
//when choosing an attack type, the chance of this particular type being selected
//by the AI
double weight;
};
class FlashlightAttackData: public AttackData
{
public:
FlashlightAttackData(){}
virtual ~FlashlightAttackData(){}
int rgb;
double coneRadius;
};
class PillowAttackData: public AttackData
{
public:
PillowAttackData(){}
virtual ~PillowAttackData(){}
double comboDelay;
std::string nextComboAttack;
};
typedef boost::shared_ptr<AttackData> AttackDataPtr;
typedef boost::shared_ptr<FlashlightAttackData> FlashlightAttackDataPtr;
typedef boost::shared_ptr<PillowAttackData> PillowAttackDataPtr;
typedef std::map<std::string, AttackDataPtr> TAttackCollection;
/// Class to model and manage the available attacks that a GameObject may have.
class AttackComponent: public Component
{
private:
TAttackCollection mAttacks;
AttackDataPtr mSelectedAttackData;
public:
AttackComponent(const std::string& type="");
~AttackComponent();
void init(TAttackCollection attacks, const std::string& selectedAttack="");
void cleanUp();
void setSelectedAttack(const std::string attackName);
AttackDataPtr getSelectedAttack();
void update(long elapsedTime);
};
class TAttackComponentParameters: public TComponentParameters
{
public:
TAttackComponentParameters();
~TAttackComponentParameters();
TAttackCollection mAttacks;
std::string mSelectedAttack;
};
}
#endif | [
"ithiliel@1610d384-d83c-11de-a027-019ae363d039"
]
| [
[
[
1,
82
]
]
]
|
eae9f1a9738dbc7505b3fb41a6d05efeeabafd65 | 7c93f9e101f6bba916bc1a967eb8e787afe9be92 | /7z920/CPP/Windows/Error.cpp | e26b8171de6d1cae6acb1c80cfd36933326b91e5 | []
| no_license | ditupao/vx7zip | 95759f909368c14f5b8f9a3cbee18a54dc3eae78 | 13fa94305e8d3491f9d920351e5d1534957a1c06 | refs/heads/master | 2016-08-11T10:55:47.619762 | 2011-06-05T09:50:51 | 2011-06-05T09:50:51 | 47,533,061 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,479 | cpp | // Windows/Error.h
#include "StdAfx.h"
#include <stdio.h>
#include <stdlib.h>
#include "Windows/Error.h"
#include "Common/StringConvert.h"
namespace NWindows {
namespace NError {
bool MyFormatMessage(DWORD messageID, CSysString &message)
{
const char * txt = 0;
AString msg;
switch(messageID) {
case ERROR_NO_MORE_FILES : txt = "No more files"; break ;
case E_NOTIMPL : txt = "E_NOTIMPL"; break ;
case E_NOINTERFACE : txt = "E_NOINTERFACE"; break ;
case E_ABORT : txt = "E_ABORT"; break ;
case E_FAIL : txt = "E_FAIL"; break ;
case STG_E_INVALIDFUNCTION : txt = "STG_E_INVALIDFUNCTION"; break ;
case E_OUTOFMEMORY : txt = "E_OUTOFMEMORY"; break ;
case E_INVALIDARG : txt = "E_INVALIDARG"; break ;
default:
txt = strerror(messageID);
}
if (txt) {
msg = txt;
} else {
char msgBuf[256];
snprintf(msgBuf,sizeof(msgBuf),"error #%x",(unsigned)messageID);
msgBuf[sizeof(msgBuf)-1] = 0;
msg = msgBuf;
}
msg += " ";
#ifdef _UNICODE
message = MultiByteToUnicodeString(msg);
#else
message = msg;
#endif
return true;
}
#ifndef _UNICODE
bool MyFormatMessage(DWORD messageID, UString &message)
{
CSysString messageSys;
bool result = MyFormatMessage(messageID, messageSys);
message = GetUnicodeString(messageSys);
return result;
}
#endif
}}
| [
"[email protected]"
]
| [
[
[
1,
59
]
]
]
|
0662da2de93f76c36ab8ff86419ee26a8eebe827 | 8ff96ae1519a2838307c57d42d68d9403cf06304 | /src/byzgeneralthread.h | 79a225ab07312422b2f9e19ffb458292df428576 | []
| no_license | reshen/byzantine_generals | e919a4bda09dccccb42e9d9a448aabe4950511db | 204ccea6274b62ee7c1df8617e9e64ad7e76a52c | refs/heads/master | 2020-05-19T21:17:26.343320 | 2010-01-22T18:31:46 | 2010-01-22T18:31:46 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,449 | h | #ifndef BYZGENERALTHREAD_H
#define BYZGENERALTHREAD_H
/* <http://stackoverflow.com/questions/614302/c-header-order>
* Order of headers should follow
* - corresponded header file
* - necessary project headers
* - 3rd party libraries headers
* - standard libraries headers
* - system headers
*/
#include "order.h"
#include "sharedmemtypes.h"
#include <boost/thread/thread.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/interprocess/managed_shared_memory.hpp>
class byzgeneralthread
{
public:
/**
* @brief Constructor
* // TODO
*/
byzgeneralthread(const char* sharedMemName, const char* byzGeneralsNamesVector, unsigned int uniqueID, bool isLoyal, unsigned int totalNumGenerals);
/**
* @brief Destructor
*/
~byzgeneralthread(void);
/**
* @brief Request that this thread stop
*/
void stop();
/**
* @brief Create and run this thread
*/
void start();
private:
boost::shared_ptr<boost::thread> thread_;
unsigned int uniqueID_;
unsigned int totalNumGenerals_;
bool stopRequested_;
bool stopFinished_;
bool isLoyal_;
void run();
boost::interprocess::managed_shared_memory *segment_;
shmOrderDeque *orderDeque_;
};
#endif // BYZGENERALTHREAD_H
| [
"[email protected]"
]
| [
[
[
1,
58
]
]
]
|
11558eda4c841e2e303b4b257857a48f0976e494 | 1eb441701fc977785b13ea70bc590234f4a45705 | /nukak3d/include/nkPlugin.h | 931b7997e0461b786d5dd7dfc7820224b15275ab | []
| no_license | svn2github/Nukak3D | 942947dc37c56fc54245bbc489e61923c7623933 | ec461c40431c6f2a04d112b265e184d260f929b8 | refs/heads/master | 2021-01-10T03:13:54.715360 | 2011-01-18T22:16:52 | 2011-01-18T22:16:52 | 47,416,318 | 1 | 2 | null | null | null | null | ISO-8859-2 | C++ | false | false | 2,834 | h | /**
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 3
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* The Original Code is Copyright (C) 2007-2010 by Bioingenium Research Group.
* Bogota - Colombia
* All rights reserved.
*
* Author(s): Alexander Pinzón Fernández.
*
* ***** END GPL LICENSE BLOCK *****
*/
#ifndef __NKPLUGIN__H__
#define __NKPLUGIN__H__
#include "nkEngine.h"
#include <string>
#if defined (WIN32) || defined (_WIN32_)
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#define NKHANDLER HMODULE
#else
#ifdef __APPLE__
#include <mach-o/dyld.h>
#include <dlfcn.h>
#include <stdarg.h>
#define NKHANDLER void *
#else //UNIX
#include <dlfcn.h>
#define NKHANDLER void *
#endif //__APPLE__
#endif //WIN32
namespace nukak3d {
class nkKernel;
/// Representation of a plugin
class nkPlugin {
public:
/// Initialize and load plugin
NKENGINE_API nkPlugin(const std::string &sFilename);
/// Copy existing plugin instance
NKENGINE_API nkPlugin(const nkPlugin &Other);
/// Unload a plugin
NKENGINE_API ~nkPlugin();
NKENGINE_API bool isLoaded();
//
// Plugin implementation
//
public:
/// Query the plugin for its expected engine version
NKENGINE_API int getEngineVersion() const {
return m_pfnGetEngineVersion();
}
/// Register the plugin to a kernel
NKENGINE_API void registerPlugin(nkKernel &K) {
m_pfnRegisterPlugin(K);
}
private:
/// Too lazy to this now...
nkPlugin &operator =(const nkPlugin &Other);
/// Signature for the version query function
typedef int fnGetEngineVersion();
/// Signature for the plugin's registration function
typedef void fnRegisterPlugin(nkKernel &);
NKHANDLER m_hDLL; ///< DLL handle
size_t *m_pDLLRefCount; ///< Number of references to the DLL
fnGetEngineVersion *m_pfnGetEngineVersion; ///< Version query function
fnRegisterPlugin *m_pfnRegisterPlugin; ///< Plugin registration function
};
} // namespace MyEngine
#endif // __NKPLUGIN__H__ | [
"apinzonf@4b68e429-1748-0410-913f-c2fc311d3372"
]
| [
[
[
1,
96
]
]
]
|
2f72fa1b2ab3e47a2819807e737cc9386ff503d9 | 44d23a0a9240c3a622d36aab3106b1ce7db0736f | /ClassWizard/VFCAddinNET/AddIn.h | bda54fa24184320c3532b22fa64ed65555fce457 | []
| no_license | skyformat99/visualfc | 238a8e479c98b861392ab4e61bc8e49bb61c9a04 | a4e91fc45f33acbc06029b6a45d3d498116931b6 | refs/heads/master | 2021-07-20T03:43:23.819252 | 2009-05-18T05:29:32 | 2009-05-18T05:29:32 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,087 | h |
/* this ALWAYS GENERATED file contains the definitions for the interfaces */
/* File created by MIDL compiler version 6.00.0361 */
/* at Tue Jun 03 16:35:10 2008
*/
/* Compiler settings for .\AddIn.idl:
Oicf, W1, Zp8, env=Win32 (32b run)
protocol : dce , ms_ext, c_ext, robust
error checks: allocation ref bounds_check enum stub_data
VC __declspec() decoration level:
__declspec(uuid()), __declspec(selectany), __declspec(novtable)
DECLSPEC_UUID(), MIDL_INTERFACE()
*/
//@@MIDL_FILE_HEADING( )
#pragma warning( disable: 4049 ) /* more than 64k source lines */
/* verify that the <rpcndr.h> version is high enough to compile this file*/
#ifndef __REQUIRED_RPCNDR_H_VERSION__
#define __REQUIRED_RPCNDR_H_VERSION__ 475
#endif
#include "rpc.h"
#include "rpcndr.h"
#ifndef __RPCNDR_H_VERSION__
#error this stub requires an updated version of <rpcndr.h>
#endif // __RPCNDR_H_VERSION__
#ifndef __AddIn_h__
#define __AddIn_h__
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
#pragma once
#endif
/* Forward Declarations */
#ifndef __Connect_FWD_DEFINED__
#define __Connect_FWD_DEFINED__
#ifdef __cplusplus
typedef class Connect Connect;
#else
typedef struct Connect Connect;
#endif /* __cplusplus */
#endif /* __Connect_FWD_DEFINED__ */
/* header files for imported files */
#include "oaidl.h"
#include "ocidl.h"
#ifdef __cplusplus
extern "C"{
#endif
void * __RPC_USER MIDL_user_allocate(size_t);
void __RPC_USER MIDL_user_free( void * );
#ifndef __VFCAddinNETLib_LIBRARY_DEFINED__
#define __VFCAddinNETLib_LIBRARY_DEFINED__
/* library VFCAddinNETLib */
/* [helpstring][version][uuid] */
EXTERN_C const IID LIBID_VFCAddinNETLib;
EXTERN_C const CLSID CLSID_Connect;
#ifdef __cplusplus
class DECLSPEC_UUID("7C01827B-4FA2-4FFE-9963-D6F158ADE304")
Connect;
#endif
#endif /* __VFCAddinNETLib_LIBRARY_DEFINED__ */
/* Additional Prototypes for ALL interfaces */
/* end of Additional Prototypes */
#ifdef __cplusplus
}
#endif
#endif
| [
"visualfc@5ba4977a-b047-0410-9b11-9d7bf4ba98c9"
]
| [
[
[
1,
96
]
]
]
|
e39ebee65b94443c6d946802aeae26e76da5b6c1 | b73f27ba54ad98fa4314a79f2afbaee638cf13f0 | /libproject/Hardware/hardwareinfo.cpp | 41a6fe35df813bda822b12e8f46a300c89a06ade | []
| no_license | weimingtom/httpcontentparser | 4d5ed678f2b38812e05328b01bc6b0c161690991 | 54554f163b16a7c56e8350a148b1bd29461300a0 | refs/heads/master | 2021-01-09T21:58:30.326476 | 2009-09-23T08:05:31 | 2009-09-23T08:05:31 | 48,733,304 | 3 | 0 | null | null | null | null | GB18030 | C++ | false | false | 17,730 | cpp | #include "stdafx.h"
#include ".\hardwareinfo.h"
#define FILE_DEVICE_SCSI 0x0000001b
#define IOCTL_SCSI_MINIPORT_IDENTIFY ( ( FILE_DEVICE_SCSI << 16 ) + 0x0501 )
#define IOCTL_SCSI_MINIPORT 0x0004D008 // see NTDDSCSI.H for definition
#define IDENTIFY_BUFFER_SIZE 512
#define SENDIDLENGTH ( sizeof( SENDCMDOUTPARAMS ) + IDENTIFY_BUFFER_SIZE )
#define IDE_ATAPI_IDENTIFY 0xA1 // Returns ID sector for ATAPI.
#define IDE_ATA_IDENTIFY 0xEC // Returns ID sector for ATA.
#define DFP_RECEIVE_DRIVE_DATA 0x0007c088
typedef struct _IDSECTOR
{
USHORT wGenConfig;
USHORT wNumCyls;
USHORT wReserved;
USHORT wNumHeads;
USHORT wBytesPerTrack;
USHORT wBytesPerSector;
USHORT wSectorsPerTrack;
USHORT wVendorUnique[3];
CHAR sSerialNumber[20];
USHORT wBufferType;
USHORT wBufferSize;
USHORT wECCSize;
CHAR sFirmwareRev[8];
CHAR sModelNumber[40];
USHORT wMoreVendorUnique;
USHORT wDoubleWordIO;
USHORT wCapabilities;
USHORT wReserved1;
USHORT wPIOTiming;
USHORT wDMATiming;
USHORT wBS;
USHORT wNumCurrentCyls;
USHORT wNumCurrentHeads;
USHORT wNumCurrentSectorsPerTrack;
ULONG ulCurrentSectorCapacity;
USHORT wMultSectorStuff;
ULONG ulTotalAddressableSectors;
USHORT wSingleWordDMA;
USHORT wMultiWordDMA;
BYTE bReserved[128];
} IDSECTOR, *PIDSECTOR;
#ifndef _VISUAL_STUDIO_2008_
typedef struct _DRIVERSTATUS
{
BYTE bDriverError; // Error code from driver, or 0 if no error.
BYTE bIDEStatus; // Contents of IDE Error register.
// Only valid when bDriverError is SMART_IDE_ERROR.
BYTE bReserved[2]; // Reserved for future expansion.
DWORD dwReserved[2]; // Reserved for future expansion.
} DRIVERSTATUS, *PDRIVERSTATUS, *LPDRIVERSTATUS;
#endif
#ifndef _VISUAL_STUDIO_2008_
typedef struct _SENDCMDOUTPARAMS
{
DWORD cBufferSize; // Size of bBuffer in bytes
DRIVERSTATUS DriverStatus; // Driver status structure.
BYTE bBuffer[1]; // Buffer of arbitrary length in which to store the data read from the // drive.
} SENDCMDOUTPARAMS, *PSENDCMDOUTPARAMS, *LPSENDCMDOUTPARAMS;
#endif
typedef struct _SRB_IO_CONTROL
{
ULONG HeaderLength;
UCHAR Signature[8];
ULONG Timeout;
ULONG ControlCode;
ULONG ReturnCode;
ULONG Length;
} SRB_IO_CONTROL, *PSRB_IO_CONTROL;
#ifndef _VISUAL_STUDIO_2008_
typedef struct _IDEREGS
{
BYTE bFeaturesReg; // Used for specifying SMART "commands".
BYTE bSectorCountReg; // IDE sector count register
BYTE bSectorNumberReg; // IDE sector number register
BYTE bCylLowReg; // IDE low order cylinder value
BYTE bCylHighReg; // IDE high order cylinder value
BYTE bDriveHeadReg; // IDE drive/head register
BYTE bCommandReg; // Actual IDE command.
BYTE bReserved; // reserved for future use. Must be zero.
} IDEREGS, *PIDEREGS, *LPIDEREGS;
#endif
#ifndef _VISUAL_STUDIO_2008_
typedef struct _SENDCMDINPARAMS
{
DWORD cBufferSize; // Buffer size in bytes
IDEREGS irDriveRegs; // Structure with drive register values.
BYTE bDriveNumber; // Physical drive number to send
// command to (0,1,2,3).
BYTE bReserved[3]; // Reserved for future expansion.
DWORD dwReserved[4]; // For future use.
BYTE bBuffer[1]; // Input buffer.
} SENDCMDINPARAMS, *PSENDCMDINPARAMS, *LPSENDCMDINPARAMS;
#endif
typedef struct _GETVERSIONOUTPARAMS
{
BYTE bVersion; // Binary driver version.
BYTE bRevision; // Binary driver revision.
BYTE bReserved; // Not used.
BYTE bIDEDeviceMap; // Bit map of IDE devices.
DWORD fCapabilities; // Bit mask of driver capabilities.
DWORD dwReserved[4]; // For future use.
} GETVERSIONOUTPARAMS, *PGETVERSIONOUTPARAMS, *LPGETVERSIONOUTPARAMS;
//////////////////////////////////////////////////////////////////////
//结构定义
typedef struct _UNICODE_STRING
{
USHORT Length;//长度
USHORT MaximumLength;//最大长度
PWSTR Buffer;//缓存指针
} UNICODE_STRING,*PUNICODE_STRING;
typedef struct _OBJECT_ATTRIBUTES
{
ULONG Length;//长度 18h
HANDLE RootDirectory;// 00000000
PUNICODE_STRING ObjectName;//指向对象名的指针
ULONG Attributes;//对象属性00000040h
PVOID SecurityDescriptor; // Points to type SECURITY_DESCRIPTOR，0
PVOID SecurityQualityOfService; // Points to type SECURITY_QUALITY_OF_SERVICE，0
} OBJECT_ATTRIBUTES;
typedef OBJECT_ATTRIBUTES *POBJECT_ATTRIBUTES;
//函数指针变量类型
typedef DWORD (__stdcall *ZWOS )( PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES);
typedef DWORD (__stdcall *ZWMV )( HANDLE,HANDLE,PVOID,ULONG,ULONG,PLARGE_INTEGER,PSIZE_T,DWORD,ULONG,ULONG);
typedef DWORD (__stdcall *ZWUMV )( HANDLE,PVOID);
BOOL WinNTHDSerialNumAsScsiRead( BYTE* dwSerial, UINT* puSerialLen, UINT uMaxSerialLen )
{
BOOL bInfoLoaded = FALSE;
for( int iController = 0; iController < 2; ++ iController )
{
HANDLE hScsiDriveIOCTL = 0;
char szDriveName[256];
// Try to get a handle to PhysicalDrive IOCTL, report failure
// and exit if can't.
sprintf( szDriveName, "\\\\.\\Scsi%d:", iController );
// Windows NT, Windows 2000, any rights should do
hScsiDriveIOCTL = CreateFile( szDriveName,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
OPEN_EXISTING, 0, NULL);
// if (hScsiDriveIOCTL == INVALID_HANDLE_VALUE)
// printf ("Unable to open SCSI controller %d, error code: 0x%lX\n",
// controller, GetLastError ());
if( hScsiDriveIOCTL != INVALID_HANDLE_VALUE )
{
int iDrive = 0;
for( iDrive = 0; iDrive < 2; ++ iDrive )
{
char szBuffer[sizeof( SRB_IO_CONTROL ) + SENDIDLENGTH] = { 0 };
SRB_IO_CONTROL* p = ( SRB_IO_CONTROL* )szBuffer;
SENDCMDINPARAMS* pin = ( SENDCMDINPARAMS* )( szBuffer + sizeof( SRB_IO_CONTROL ) );
DWORD dwResult;
p->HeaderLength = sizeof( SRB_IO_CONTROL );
p->Timeout = 10000;
p->Length = SENDIDLENGTH;
p->ControlCode = IOCTL_SCSI_MINIPORT_IDENTIFY;
strncpy( ( char* )p->Signature, "SCSIDISK", 8 );
pin->irDriveRegs.bCommandReg = IDE_ATA_IDENTIFY;
pin->bDriveNumber = iDrive;
if( DeviceIoControl( hScsiDriveIOCTL, IOCTL_SCSI_MINIPORT,
szBuffer,
sizeof( SRB_IO_CONTROL ) + sizeof( SENDCMDINPARAMS ) - 1,
szBuffer,
sizeof( SRB_IO_CONTROL ) + SENDIDLENGTH,
&dwResult, NULL ) )
{
SENDCMDOUTPARAMS* pOut = ( SENDCMDOUTPARAMS* )( szBuffer + sizeof( SRB_IO_CONTROL ) );
IDSECTOR* pId = ( IDSECTOR* )( pOut->bBuffer );
if( pId->sModelNumber[0] )
{
if( * puSerialLen + 20U <= uMaxSerialLen )
{
// 序列号
CopyMemory( dwSerial + * puSerialLen, ( ( USHORT* )pId ) + 10, 20 );
// Cut off the trailing blanks
UINT i =0;
for(i = 20; i != 0U && ' ' == dwSerial[* puSerialLen + i - 1]; -- i )
{}
* puSerialLen += i;
// 型号
CopyMemory( dwSerial + * puSerialLen, ( ( USHORT* )pId ) + 27, 40 );
// Cut off the trailing blanks
for( i = 40; i != 0U && ' ' == dwSerial[* puSerialLen + i - 1]; -- i )
{}
* puSerialLen += i;
bInfoLoaded = TRUE;
}
else
{
::CloseHandle( hScsiDriveIOCTL );
return bInfoLoaded;
}
}
}
}
::CloseHandle( hScsiDriveIOCTL );
}
}
return bInfoLoaded;
}
BOOL DoIdentify( HANDLE hPhysicalDriveIOCTL, PSENDCMDINPARAMS pSCIP,
PSENDCMDOUTPARAMS pSCOP, BYTE bIDCmd, BYTE bDriveNum,
PDWORD lpcbBytesReturned )
{
// Set up data structures for IDENTIFY command.
pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
pSCIP->irDriveRegs.bFeaturesReg = 0;
pSCIP->irDriveRegs.bSectorCountReg = 1;
pSCIP->irDriveRegs.bSectorNumberReg = 1;
pSCIP->irDriveRegs.bCylLowReg = 0;
pSCIP->irDriveRegs.bCylHighReg = 0;
// calc the drive number.
pSCIP->irDriveRegs.bDriveHeadReg = 0xA0 | ( ( bDriveNum & 1 ) << 4 );
// The command can either be IDE identify or ATAPI identify.
pSCIP->irDriveRegs.bCommandReg = bIDCmd;
pSCIP->bDriveNumber = bDriveNum;
pSCIP->cBufferSize = IDENTIFY_BUFFER_SIZE;
return DeviceIoControl( hPhysicalDriveIOCTL, DFP_RECEIVE_DRIVE_DATA,
( LPVOID ) pSCIP,
sizeof( SENDCMDINPARAMS ) - 1,
( LPVOID ) pSCOP,
sizeof( SENDCMDOUTPARAMS ) + IDENTIFY_BUFFER_SIZE - 1,
lpcbBytesReturned, NULL );
}
BOOL WinNTHDSerialNumAsPhysicalRead( BYTE* dwSerial, UINT* puSerialLen, UINT uMaxSerialLen )
{
#define DFP_GET_VERSION 0x00074080
BOOL bInfoLoaded = FALSE;
for( UINT uDrive = 0; uDrive < 4; ++ uDrive )
{
HANDLE hPhysicalDriveIOCTL = 0;
// Try to get a handle to PhysicalDrive IOCTL, report failure
// and exit if can't.
char szDriveName [256];
sprintf( szDriveName, "\\\\.\\PhysicalDrive%d", uDrive );
// Windows NT, Windows 2000, must have admin rights
hPhysicalDriveIOCTL = CreateFile( szDriveName,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
OPEN_EXISTING, 0, NULL);
if( hPhysicalDriveIOCTL != INVALID_HANDLE_VALUE )
{
GETVERSIONOUTPARAMS VersionParams = { 0 };
DWORD cbBytesReturned = 0;
// Get the version, etc of PhysicalDrive IOCTL
if( DeviceIoControl( hPhysicalDriveIOCTL, DFP_GET_VERSION,
NULL,
0,
&VersionParams,
sizeof( GETVERSIONOUTPARAMS ),
&cbBytesReturned, NULL ) )
{
// If there is a IDE device at number "i" issue commands
// to the device
if( VersionParams.bIDEDeviceMap != 0 )
{
BYTE bIDCmd = 0; // IDE or ATAPI IDENTIFY cmd
SENDCMDINPARAMS scip = { 0 };
// Now, get the ID sector for all IDE devices in the system.
// If the device is ATAPI use the IDE_ATAPI_IDENTIFY command,
// otherwise use the IDE_ATA_IDENTIFY command
bIDCmd = ( VersionParams.bIDEDeviceMap >> uDrive & 0x10 ) ? IDE_ATAPI_IDENTIFY : IDE_ATA_IDENTIFY;
BYTE IdOutCmd[sizeof( SENDCMDOUTPARAMS ) + IDENTIFY_BUFFER_SIZE - 1] = { 0 };
if( DoIdentify( hPhysicalDriveIOCTL,
&scip,
( PSENDCMDOUTPARAMS )&IdOutCmd,
( BYTE )bIDCmd,
( BYTE )uDrive,
&cbBytesReturned ) )
{
if( * puSerialLen + 20U <= uMaxSerialLen )
{
CopyMemory( dwSerial + * puSerialLen, ( ( USHORT* )( ( ( PSENDCMDOUTPARAMS )IdOutCmd )->bBuffer ) ) + 10, 20 ); // 序列号
// Cut off the trailing blanks
UINT i =0;
for( i = 20; i != 0U && ' ' == dwSerial[* puSerialLen + i - 1]; -- i ) {}
* puSerialLen += i;
CopyMemory( dwSerial + * puSerialLen, ( ( USHORT* )( ( ( PSENDCMDOUTPARAMS )IdOutCmd )->bBuffer ) ) + 27, 40 ); // 型号
// Cut off the trailing blanks
for( i = 40; i != 0U && ' ' == dwSerial[* puSerialLen + i - 1]; -- i ) {}
* puSerialLen += i;
bInfoLoaded = TRUE;
}
else
{
::CloseHandle( hPhysicalDriveIOCTL );
return bInfoLoaded;
}
}
}
}
CloseHandle( hPhysicalDriveIOCTL );
}
}
return bInfoLoaded;
}
UINT FindAwardBios( BYTE** ppBiosAddr )
{
BYTE* pBiosAddr = * ppBiosAddr + 0xEC71;
BYTE szBiosData[128];
CopyMemory( szBiosData, pBiosAddr, 127 );
szBiosData[127] = 0;
int iLen = lstrlen( ( char* )szBiosData );
if( iLen > 0 && iLen < 128 )
{
//AWard: 07/08/2002-i845G-ITE8712-JF69VD0CC-00
//Phoenix-Award: 03/12/2002-sis645-p4s333
if( szBiosData[2] == '/' && szBiosData[5] == '/' )
{
BYTE* p = szBiosData;
while( * p )
{
if( * p < ' ' || * p >= 127 )
{
break;
}
++ p;
}
if( * p == 0 )
{
* ppBiosAddr = pBiosAddr;
return ( UINT )iLen;
}
}
}
return 0;
}
UINT FindAmiBios( BYTE** ppBiosAddr )
{
BYTE* pBiosAddr = * ppBiosAddr + 0xF478;
BYTE szBiosData[128];
CopyMemory( szBiosData, pBiosAddr, 127 );
szBiosData[127] = 0;
int iLen = lstrlen( ( char* )szBiosData );
if( iLen > 0 && iLen < 128 )
{
// Example: "AMI: 51-2300-000000-00101111-030199-"
if( szBiosData[2] == '-' && szBiosData[7] == '-' )
{
BYTE* p = szBiosData;
while( * p )
{
if( * p < ' ' || * p >= 127 )
{
break;
}
++ p;
}
if( * p == 0 )
{
* ppBiosAddr = pBiosAddr;
return ( UINT )iLen;
}
}
}
return 0;
}
UINT FindPhoenixBios( BYTE** ppBiosAddr )
{
UINT uOffset[3] = { 0x6577, 0x7196, 0x7550 };
for( UINT i = 0; i < 3; ++ i )
{
BYTE* pBiosAddr = * ppBiosAddr + uOffset[i];
BYTE szBiosData[128];
CopyMemory( szBiosData, pBiosAddr, 127 );
szBiosData[127] = 0;
int iLen = lstrlen( ( char* )szBiosData );
if( iLen > 0 && iLen < 128 )
{
// Example: Phoenix "NITELT0.86B.0044.P11.9910111055"
if( szBiosData[7] == '.' && szBiosData[11] == '.' )
{
BYTE* p = szBiosData;
while( * p )
{
if( * p < ' ' || * p >= 127 )
{
break;
}
++ p;
}
if( * p == 0 )
{
* ppBiosAddr = pBiosAddr;
return ( UINT )iLen;
}
}
}
}
return 0;
}
UINT GetMAC(BYTE * szSystemInfo, UINT uSystemInfoLen) {
UINT uErrorCode = 0;
IP_ADAPTER_INFO iai;
ULONG uSize = 0;
DWORD dwResult = GetAdaptersInfo( &iai, &uSize );
if( dwResult == ERROR_BUFFER_OVERFLOW )
{
IP_ADAPTER_INFO* piai = ( IP_ADAPTER_INFO* )HeapAlloc( GetProcessHeap( ), 0, uSize );
if( piai != NULL )
{
dwResult = GetAdaptersInfo( piai, &uSize );
if( ERROR_SUCCESS == dwResult )
{
IP_ADAPTER_INFO* piai2 = piai;
while( piai2 != NULL && ( uSystemInfoLen + piai2->AddressLength ) < 4096U )
{
CopyMemory( szSystemInfo + uSystemInfoLen, piai2->Address, piai2->AddressLength );
uSystemInfoLen += piai2->AddressLength;
piai2 = piai2->Next;
}
}
else
{
uErrorCode = 0xF0000000U + dwResult;
}
( HeapFree( GetProcessHeap( ), 0, piai ) );
}
else
{
return FALSE;
}
}
else
{
uErrorCode = 0xE0000000U + dwResult;
}
if( uErrorCode != 0U )
{
return FALSE;
} else {
return TRUE;
}
}
UINT GetHarddiskSeria(BYTE * info, UINT bufLen) {
OSVERSIONINFO ovi = { 0 };
ovi.dwOSVersionInfoSize = sizeof( OSVERSIONINFO );
GetVersionEx( &ovi );
if( ovi.dwPlatformId != VER_PLATFORM_WIN32_NT )
{
// Only Windows 2000, Windows XP, Windows Server 2003...
return 0;
}
else
{
if( !WinNTHDSerialNumAsPhysicalRead( info, &bufLen, 1024 ) )
{
WinNTHDSerialNumAsScsiRead( info, &bufLen, 1024 );
}
}
return bufLen;
}
// BIOS 编号，支持 AMI, AWARD, PHOENIX
UINT GetBIOSInof(BYTE * szSystemInfo, UINT uSystemInfoLen)
{
SIZE_T ssize;
LARGE_INTEGER so;
so.LowPart=0x000f0000;
so.HighPart=0x00000000;
ssize=0xffff;
wchar_t strPH[30]=L"\\device\\physicalmemory";
DWORD ba=0;
UNICODE_STRING struniph;
struniph.Buffer=strPH;
struniph.Length=0x2c;
struniph.MaximumLength =0x2e;
OBJECT_ATTRIBUTES obj_ar;
obj_ar.Attributes =64;
obj_ar.Length =24;
obj_ar.ObjectName=&struniph;
obj_ar.RootDirectory=0;
obj_ar.SecurityDescriptor=0;
obj_ar.SecurityQualityOfService =0;
HMODULE hinstLib = LoadLibrary("ntdll.dll");
ZWOS ZWopenS=(ZWOS)GetProcAddress(hinstLib,"ZwOpenSection");
ZWMV ZWmapV=(ZWMV)GetProcAddress(hinstLib,"ZwMapViewOfSection");
ZWUMV ZWunmapV=(ZWUMV)GetProcAddress(hinstLib,"ZwUnmapViewOfSection");
//调用函数，对物理内存进行映射
HANDLE hSection;
if( 0 == ZWopenS(&hSection,4,&obj_ar) &&
0 == ZWmapV(
( HANDLE )hSection, //打开Section时得到的句柄
( HANDLE )0xFFFFFFFF, //将要映射进程的句柄，
&ba, //映射的基址
0,
0xFFFF, //分配的大小
&so, //物理内存的地址
&ssize, //指向读取内存块大小的指针
1, //子进程的可继承性设定
0, //分配类型
2 //保护类型
) )
//执行后会在当前进程的空间开辟一段64k的空间，并把f000:0000到f000:ffff处的内容映射到这里
//映射的基址由ba返回,如果映射不再有用,应该用ZwUnmapViewOfSection断开映射
{
BYTE* pBiosSerial = ( BYTE* )ba;
UINT uBiosSerialLen = FindAwardBios( &pBiosSerial );
if( uBiosSerialLen == 0U )
{
uBiosSerialLen = FindAmiBios( &pBiosSerial );
if( uBiosSerialLen == 0U )
{
uBiosSerialLen = FindPhoenixBios( &pBiosSerial );
}
}
if( uBiosSerialLen != 0U )
{
CopyMemory( szSystemInfo + uSystemInfoLen, pBiosSerial, uBiosSerialLen );
uSystemInfoLen += uBiosSerialLen;
}
ZWunmapV( ( HANDLE )0xFFFFFFFF, ( void* )ba );
}
return uSystemInfoLen;
}
UINT GetCPUID(BYTE * info, UINT bufLen) {
BOOL bException = FALSE;
BYTE szCpu[16] = { 0 };
UINT uCpuID = 0U;
__try
{
_asm
{
mov eax, 0
cpuid
mov dword ptr szCpu[0], ebx
mov dword ptr szCpu[4], edx
mov dword ptr szCpu[8], ecx
mov eax, 1
cpuid
mov uCpuID, edx
}
}
__except( EXCEPTION_EXECUTE_HANDLER )
{
bException = TRUE;
}
if( !bException )
{
CopyMemory( info + bufLen, &uCpuID, sizeof( UINT ) );
bufLen += sizeof( UINT );
uCpuID = strlen( ( char* )szCpu );
CopyMemory( info + bufLen, szCpu, uCpuID );
bufLen += uCpuID;
}
return 0;
} | [
"[email protected]"
]
| [
[
[
1,
618
]
]
]
|
e2bec00a3dfe589ca4deaf61111b9cc15b48a060 | f304b2f54319a444f8798bca884139b785c63026 | /trunk/CPUInfo.hpp | edb340f9200d0c83b2c1e9a722b4d6f7d516b70c | []
| no_license | BackupTheBerlios/zcplusplus-svn | 4387877a71405be331e78bec6d792da5f8fe6737 | ef85b9e4a78a52618014f501c9c1400c9d4f4a42 | refs/heads/master | 2016-08-05T18:34:41.051270 | 2011-10-08T10:15:31 | 2011-10-08T10:15:31 | 40,805,219 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,801 | hpp | // CPUInfo.hpp
// (C)2009,2010 Kenneth Boyd, license: MIT.txt
#ifndef CPUINFO_HPP
#define CPUINFO_HPP
#include "unsigned_var_int.hpp"
namespace virtual_machine {
enum signed_int_rep // signed int representation; cf. C99 6.2.6.2 p2
{
twos_complement = 0, // sign bit is -2^N
ones_complement, // sign bit is -2^N+1
sign_and_magnitude // sign bit simply negates corresponding value
};
enum std_int_enum
{
std_int_char = 1,
std_int_short,
std_int_int,
std_int_long,
std_int_long_long
};
enum maxima
{
std_int_enum_max = std_int_long_long
};
// helper struct for type-promotions; derive from this non-virtually
struct promotion_info
{
virtual_machine::std_int_enum machine_type;
unsigned short bitcount;
bool is_signed; // as in std::numeric_limits
};
// as the implementation, we are free to not provide a larger type than
// C long long. Yhis macro doesn't work so well outside of the language
// support files, which are expected to declare a CPUInfo* target_machine
#define VM_MAX_BIT_PLATFORM target_machine->C_bit<virtual_machine::std_int_long_long>()
// leave this typedef, just in case we have to change this around again
typedef unsigned_var_int umaxint;
// names of macro parameters match names of constructor variables
// target wchar_t is assumed to be an unsigned integral type
// we first try to choose the smallest type that can represent a 32-bit UNICODE point
// if that fails, we try to choose the smallest type that can represent plane 16
// align with std_in_enum above
#define SELECT_TARGET_WCHAR_T(char_bit,sizeof_short,sizeof_int,sizeof_long,sizeof_long_long) \
((32U<=char_bit) ? 1 : \
(32<=char_bit*sizeof_short) ? 2 : \
(32<=char_bit*sizeof_int) ? 3 : \
(32<=char_bit*sizeof_long) ? 4 : \
(32<=char_bit*sizeof_long_long) ? 5 : \
(21U<=char_bit) ? 1+8 : \
(21<=char_bit*sizeof_short) ? 2+8 : \
(21<=char_bit*sizeof_int) ? 3+8 : \
(21<=char_bit*sizeof_long) ? 4+8 : \
(21<=char_bit*sizeof_long_long) ? 5+8 : \
0)
// models an idealized CPU
class CPUInfo
{
CPUInfo(); // disable default-construction
CPUInfo(const CPUInfo& src); // disable copy-construction
void operator=(const CPUInfo& src);
umaxint unsigned_maxima[std_int_enum_max];
umaxint signed_maxima[std_int_enum_max];
const unsigned short char_bit;
const unsigned short sizeof_short;
const unsigned short sizeof_int;
const unsigned short sizeof_long;
const unsigned short sizeof_long_long;
const unsigned short signed_int_representation;
void _init();
public:
CPUInfo(unsigned short _char_bit, unsigned short _sizeof_short, unsigned short _sizeof_int, unsigned short _sizeof_long, unsigned short _sizeof_long_long, signed_int_rep _signed_int_representation, bool _char_is_signed_char,std_int_enum _ptrdiff_type)
: char_bit(_char_bit),
sizeof_short(_sizeof_short),
sizeof_int(_sizeof_int),
sizeof_long(_sizeof_long),
sizeof_long_long(_sizeof_long_long),
signed_int_representation(_signed_int_representation+4*_char_is_signed_char+8*SELECT_TARGET_WCHAR_T(char_bit,sizeof_short,sizeof_int,sizeof_long,sizeof_long_long)+128*_ptrdiff_type)
{_init();};
// assembly/disassembly support
virtual size_t encode_asm_length(const char* const src, size_t src_len, unsigned int target_bit) const {return 0;};
virtual size_t decode_asm_length(const unsigned char* const src_asm, size_t src_asm_len, unsigned int target_bit) const {return 0;};
virtual bool encode_asm(const char*& src,size_t& src_len,unsigned char*& dest_asm, size_t& dest_asm_len, unsigned int target_bit) const {return false;};
virtual bool decode_asm(const unsigned char*& src_asm, size_t& src_asm_len,char*& dest, size_t& dest_len, unsigned int target_bit) const {return false;};
// recognition is not the same thing as actually being able to encode the assembly source
virtual bool recognize_asm_src(const char* const src, size_t src_len) const {return false;};
// C support
unsigned short C_char_bit() const {return char_bit;};
unsigned short C_sizeof_short() const {return sizeof_short;};
unsigned short C_sizeof_int() const {return sizeof_int;};
unsigned short C_sizeof_long() const {return sizeof_long;};
unsigned short C_sizeof_long_long() const {return sizeof_long_long;};
unsigned short C_sizeof(std_int_enum x) const {return (std_int_char==x) ? 1 :
(std_int_short==x) ? C_sizeof_short() :
(std_int_int==x) ? C_sizeof_int() :
(std_int_long==x) ? C_sizeof_long() : C_sizeof_long_long() ;};
unsigned short C_bit(std_int_enum x) const {return (std_int_char==x) ? C_char_bit() :
(std_int_short==x) ? C_char_bit()*C_sizeof_short() :
(std_int_int==x) ? C_char_bit()*C_sizeof_int() :
(std_int_long==x) ? C_char_bit()*C_sizeof_long() : C_char_bit()*C_sizeof_long_long() ;};
template<std_int_enum x> unsigned short C_bit() const {return (std_int_char==x) ? C_char_bit() :
(std_int_short==x) ? C_char_bit()*C_sizeof_short() :
(std_int_int==x) ? C_char_bit()*C_sizeof_int() :
(std_int_long==x) ? C_char_bit()*C_sizeof_long() : C_char_bit()*C_sizeof_long_long() ;}
signed_int_rep C_signed_int_representation() const {return (signed_int_rep)(signed_int_representation & 3U);};
bool trap_int(const umaxint& src_int,std_int_enum machine_type) const;
void signed_additive_inverse(umaxint& src_int,std_int_enum machine_type) const;
void unsigned_additive_inverse(umaxint& src_int,std_int_enum machine_type) const;
bool is_zero(const unsigned char* x, size_t x_len, const promotion_info& targettype) const;
void sign_extend(umaxint& src_int,std_int_enum machine_type_from,std_int_enum machine_type_to) const
{
signed_additive_inverse(src_int,machine_type_from);
signed_additive_inverse(src_int,machine_type_to);
};
void C_cast_signed_to_unsigned(umaxint& src_int,std_int_enum machine_type) const
{ // C99 6.3.1.3p2 dictates modulo conversion to unsigned
if (twos_complement!=C_signed_int_representation() && src_int.test(C_bit(machine_type)-1))
{
signed_additive_inverse(src_int,machine_type);
unsigned_additive_inverse(src_int,machine_type);
}
};
bool char_is_signed_char() const {return (signed_int_representation & 4U);};
std_int_enum UNICODE_wchar_t() const {return (std_int_enum)((signed_int_representation>>3) & 7U);};
bool UNICODE_crippled() const {return (signed_int_representation & 64U);};
// use different functions for ptrdiff_t and size_t to future-proof (e.g., DOS has ptrdiff 2 bytes but can go larger than that in object size in some memory models)
std_int_enum ptrdiff_t_type() const {return (std_int_enum)((signed_int_representation>>7) & 7U);};
std_int_enum size_t_type() const {return (std_int_enum)((signed_int_representation>>7) & 7U);};
const umaxint& unsigned_max(std_int_enum x) const {return unsigned_maxima[x-1];};
template<std_int_enum x> const umaxint& unsigned_max() const {return unsigned_maxima[x-1];}
const umaxint& signed_max(std_int_enum x) const {return signed_maxima[x-1];};
template<std_int_enum x> const umaxint& signed_max() const {return signed_maxima[x-1];}
// we'll eventually want to make this independently specified, also
// until then, we're targeting a really flat memory space
unsigned short C_sizeof_data_ptr() const {return C_sizeof(ptrdiff_t_type());};
unsigned short C_sizeof_function_ptr() const {return C_sizeof(ptrdiff_t_type());};
// return value is weird...it's true iff the promoted x is a negative numeral
bool C_promote_integer(umaxint& x,const promotion_info& src_type, const promotion_info& dest_type) const;
};
#undef SELECT_TARGET_WCHAR_T
}
#endif
| [
"zaimoni@b4372a03-5d62-0410-814a-8f46757a0b64"
]
| [
[
[
1,
164
]
]
]
|
ec57f29bd5df2bf93bc619b1267019b441c7bde9 | bf19f77fdef85e76a7ebdedfa04a207ba7afcada | /NewAlpha/TMNT Tactics Tech Demo/Source/WinMain.cpp | f6db8a8dadb34edddb0fce489137f0bfca4dec83 | []
| no_license | marvelman610/tmntactis | 2aa3176d913a72ed985709843634933b80d7cb4a | a4e290960510e5f23ff7dbc1e805e130ee9bb57d | refs/heads/master | 2020-12-24T13:36:54.332385 | 2010-07-12T08:08:12 | 2010-07-12T08:08:12 | 39,046,976 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 11,202 | cpp | //////////////////////////////////////////////////////////////////////////////////////////////
// File : "WinMain.cpp"
//
// Author : David Brown (DB), modified by Ramon Johannessen(RJ)
// Based in part on:
// -Window code from the book: "Physics for Game Developers" by David M. Bourg.
// -The previous WinMain.cpp by Jensen Rivera.
//
// Last Modified : 3/31/2009
//
// Purpose : To provide a basic window framework for student games.
//
//////////////////////////////////////////////////////////////////////////////////////////////
#include <windows.h> // Needed for Windows Applications.
//#define VLD_AGGREGATE_DUPLICATES
//#define VLD_MAX_DATA_DUMP 0
#include <vld.h>
#include "Game.h"
#include "GamePlayState.h"
#include "../resource.h"
void ToggleFullscreenMode(HWND hWnd,
int iWidth, int iHeight, int iBpp, int iRefreshRate);
void SetDisplayMode(int iWidth, int iHeight, int iBpp, int iRefreshRate);
const char* g_szWINDOW_CLASS_NAME = "TMNTWINDOWCLASS"; // Window Class Name.
const char* g_szWINDOW_TITLE = "TMNT Tactics"; // Window Title.
const int g_nWINDOW_WIDTH = 1024; // Window Width.
const int g_nWINDOW_HEIGHT = 768; // Window Height.
POINT mouse;
HCURSOR hcPointer;
HCURSOR hcGrab;
// Windowed or Full screen depending on project setting
#ifdef _DEBUG
const BOOL g_bIS_WINDOWED = TRUE;
#else
const BOOL g_bIS_WINDOWED = FALSE;
#endif
LRESULT CALLBACK WindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
// This is the main message handler of the system.
PAINTSTRUCT ps; // Used in WM_PAINT.
HDC hdc; // Handle to a device context.
// What is the message
switch(msg)
{
// To skip ALT pop up menu (system menu)
case WM_SYSKEYUP:
case WM_SYSCHAR:
return(0);
break;
// Handle ALT+F4
case WM_CLOSE:
{
// Sends us a WM_DESTROY
DestroyWindow(hWnd);
}
break;
case WM_MOUSEMOVE:
{
//GetCursorPos()
mouse.x = LOWORD(lParam);
mouse.y = HIWORD(lParam);
}
break;
// and lose/gain focus
case WM_ACTIVATE:
{
// gaining focus
if (LOWORD(wParam) != WA_INACTIVE)
{
// unpause game code here
CGamePlayState::GetInstance()->SetPaused(false);
CGamePlayState::GetInstance()->SetPaused(false);
}
else // losing focus
{
// pause game code here
CGamePlayState::GetInstance()->SetPaused(true);
}
break;
}
case WM_SETCURSOR:
{
if (LOWORD(lParam) == HTCAPTION || LOWORD(lParam) == HTCLIENT)
{
ShowCursor(FALSE);
}
}
break;
case WM_CREATE:
{
// Do initialization here
return(0);
}
break;
case WM_PAINT:
{
// Start painting
hdc = BeginPaint(hWnd,&ps);
// End painting
EndPaint(hWnd,&ps);
return(0);
}
break;
case WM_DESTROY:
{
// Kill the application
PostQuitMessage(0);
return(0);
}
break;
default:
break;
}
// Process any messages that we didn't take care of
return (DefWindowProc(hWnd, msg, wParam, lParam));
}
// Checks to see if the game was already running in another window.
//
// NOTE: Don't call this function if your game needs to have more
// than one instance running on the same computer (i.e. client/server)
BOOL CheckIfAlreadyRunning(void)
{
// Find a window of the same window class name and window title
HWND hWnd = FindWindow(g_szWINDOW_CLASS_NAME, g_szWINDOW_TITLE);
// If one was found
if (hWnd)
{
// If it was minimized
if (IsIconic(hWnd))
// restore it
ShowWindow(hWnd, SW_RESTORE);
// Bring it to the front
SetForegroundWindow(hWnd);
return TRUE;
}
// No other copies found running
return FALSE;
}
BOOL RegisterWindowClass(HINSTANCE hInstance)
{
WNDCLASSEX winClassEx; // This will describe the window class we will create.
// First fill in the window class structure
winClassEx.cbSize = sizeof(winClassEx);
winClassEx.style = CS_DBLCLKS | CS_OWNDC | CS_HREDRAW | CS_VREDRAW;
winClassEx.lpfnWndProc = WindowProc;
winClassEx.cbClsExtra = 0;
winClassEx.cbWndExtra = 0;
winClassEx.hInstance = hInstance;
winClassEx.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ICON1));
winClassEx.hIconSm = NULL;
winClassEx.hCursor = LoadCursor(NULL, IDC_ARROW);
winClassEx.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
winClassEx.lpszMenuName = NULL;
winClassEx.lpszClassName = g_szWINDOW_CLASS_NAME;
ShowCursor(FALSE);
mouse.x = 0;
mouse.y = 0;
// Register the window class
return RegisterClassEx(&winClassEx);
}
// Creates and sizes the window appropriately depending on if
// the application is windowed or full screen.
HWND MakeWindow(HINSTANCE hInstance)
{
// Setup window style flags
DWORD dwWindowStyleFlags = WS_VISIBLE;
if (g_bIS_WINDOWED)
{
dwWindowStyleFlags |= WS_OVERLAPPEDWINDOW;
}
else
{
dwWindowStyleFlags |= WS_POPUP;
//ShowCursor(FALSE); // Stop showing the mouse cursor
}
// Setup the desired client area size
RECT rWindow;
rWindow.left = 0;
rWindow.top = 0;
rWindow.right = g_nWINDOW_WIDTH;
rWindow.bottom = g_nWINDOW_HEIGHT;
// Get the dimensions of a window that will have a client rect that
// will really be the resolution we're looking for.
AdjustWindowRectEx(&rWindow,
dwWindowStyleFlags,
FALSE,
WS_EX_APPWINDOW);
// Calculate the width/height of that window's dimensions
int nWindowWidth = rWindow.right - rWindow.left;
int nWindowHeight = rWindow.bottom - rWindow.top;
// Create the window
return CreateWindowEx(WS_EX_APPWINDOW, // Extended Style flags.
g_szWINDOW_CLASS_NAME, // Window Class Name.
g_szWINDOW_TITLE, // Title of the Window.
dwWindowStyleFlags, // Window Style Flags.
(GetSystemMetrics(SM_CXSCREEN)/2) - (nWindowWidth/2), // Window Start Point (x, y).
(GetSystemMetrics(SM_CYSCREEN)/2) - (nWindowHeight/2), // -Does the math to center the window over the desktop.
nWindowWidth, // Width of Window.
nWindowHeight, // Height of Window.
NULL, // Handle to parent window.
NULL, // Handle to menu.
hInstance, // Application Instance.
NULL); // Creation parameters.
}
//////////////////////////
// WinMain //
//////////////////////////
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
MSG msg; // Generic message.
HWND hWnd; // Main Window Handle.
// Don't let more than one instance of the application exist
//
// NOTE: Comment out the following section of code if your game needs to have more
// than one instance running on the same computer (i.e. client/server)
////////////////////////////////////////////////////////////////////////
if (!hPrevInstance)
{
if (CheckIfAlreadyRunning())
return FALSE;
}
////////////////////////////////////////////////////////////////////////
// Register the window class
if (!RegisterWindowClass(hInstance))
return 0;
// Create the window
hWnd = MakeWindow(hInstance);
if (!hWnd)
return 0;
ShowWindow(hWnd, nCmdShow);
UpdateWindow(hWnd);
//////////////////////////////////////////
// Initialize Game here
//////////////////////////////////////////
CGame* pGame = CGame::GetInstance();
pGame->Initialize(hWnd, hInstance, g_nWINDOW_WIDTH, g_nWINDOW_HEIGHT, g_bIS_WINDOWED);
//////////////////////////////////////////
// Enter main event loop
while (TRUE)
{
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
// Test if this is a quit
if (msg.message == WM_QUIT)
break;
// Translate any accelerator keys
TranslateMessage(&msg);
// Send the message to the window proc
DispatchMessage(&msg);
}
//if(GetAsyncKeyState(VK_MENU) && GetAsyncKeyState(VK_RETURN))
// ToggleFullscreenMode(hWnd, g_nWINDOW_WIDTH, g_nWINDOW_HEIGHT, 32, 60);
//////////////////////////////////
// Put Game Logic Here
//////////////////////////////////
if(pGame->Main(mouse) == false)
break;
//////////////////////////////////
}
/////////////////////////////////////////
// Shutdown Game Here
/////////////////////////////////////////
pGame->Shutdown();
/////////////////////////////////////////
// Unregister the window class
UnregisterClass(g_szWINDOW_CLASS_NAME, hInstance);
// Return to Windows like this.
return (int)(msg.wParam);
}
void ToggleFullscreenMode(HWND hWnd,
int iWidth, int iHeight, int iBpp, int iRefreshRate)
{
static bool bFullScreen = true;
static RECT rWindow = {0,0,g_nWINDOW_WIDTH,g_nWINDOW_HEIGHT};
static HMENU hMenu = NULL;
if(bFullScreen)
{
// Remember the window position.
GetWindowRect(hWnd, &rWindow);
// Switch to the requested display mode.
SetDisplayMode(iWidth, iHeight, iBpp, iRefreshRate);
// Remember the menu, then remove it.
hMenu = GetMenu(hWnd);
SetMenu(hWnd, NULL);
// Remove the window's title bar.
SetWindowLongPtr(hWnd, GWL_STYLE, WS_POPUP);
// Put the changes to the window into effect.
SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, 0, 0,
SWP_FRAMECHANGED | SWP_SHOWWINDOW | SWP_NOMOVE | SWP_NOSIZE);
// Size the window to cover the entire screen.
SetWindowPos(hWnd, 0,
0, 0,
GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN),
SWP_NOZORDER);
// Remove the cursor.
//ShowCursor(FALSE);
}
else
{
// Restore the display mode.
SetDisplayMode(0, 0, 0, 0);
// Restore the window's menu.
SetMenu(hWnd, hMenu);
// Restore the window's title bar.
SetWindowLongPtr(hWnd, GWL_STYLE, WS_OVERLAPPEDWINDOW);
// Put the changes to the window into effect.
SetWindowPos(hWnd, HWND_NOTOPMOST, 0, 0, 0, 0,
SWP_FRAMECHANGED | SWP_SHOWWINDOW | SWP_NOMOVE | SWP_NOSIZE);
// Size the window to its original position.
int iWindowWidth = rWindow.right - rWindow.left;
int iWindowHeight = rWindow.bottom - rWindow.top;
SetWindowPos(hWnd, 0,
rWindow.left,
rWindow.top,
iWindowWidth, iWindowHeight,
SWP_NOZORDER);
// Restore the cursor.
ShowCursor(TRUE);
}
bFullScreen = !bFullScreen;
}
void SetDisplayMode(int iWidth, int iHeight, int iBpp, int iRefreshRate)
{
if(iWidth == 0 && iHeight == 0 && iBpp == 0 && iRefreshRate == 0)
{
// Restore display settings to those stored in the registry.
ChangeDisplaySettings(NULL, 0);
return;
}
DEVMODE dm;
dm.dmSize = sizeof(DEVMODE);
int i = 0;
while(EnumDisplaySettings(NULL, i++, &dm))
{
// Iterate through the display settings until a match is found.
if(dm.dmPelsWidth == iWidth && dm.dmPelsHeight == iHeight &&
dm.dmBitsPerPel == iBpp && dm.dmDisplayFrequency == iRefreshRate)
{
if(ChangeDisplaySettings(&dm, CDS_TEST) == DISP_CHANGE_SUCCESSFUL)
{
// Put the new settings into effect.
ChangeDisplaySettings(&dm, CDS_FULLSCREEN);
return;
}
}
}
} | [
"AllThingsCandid@7dc79cba-3e6d-11de-b8bc-ddcf2599578a",
"jsierra099@7dc79cba-3e6d-11de-b8bc-ddcf2599578a",
"marvelman610@7dc79cba-3e6d-11de-b8bc-ddcf2599578a"
]
| [
[
[
1,
16
],
[
20,
20
],
[
22,
71
],
[
73,
76
],
[
78,
79
],
[
81,
85
],
[
87,
87
],
[
89,
296
],
[
299,
404
]
],
[
[
17,
18
]
],
[
[
19,
19
],
[
21,
21
],
[
72,
72
],
[
77,
77
],
[
80,
80
],
[
86,
86
],
[
88,
88
],
[
297,
298
]
]
]
|
b730efe2feeb173e5127ae7cf8153364d5d2bc85 | daa67e21cc615348ba166d31eb25ced40fba9dc7 | /GameCode/DXUT/Optional/SDKmisc.cpp | 33ed9786cc21057e8b8867ee8acfe3c2b2e7e4c8 | []
| no_license | gearsin/geartesttroject | 443d48b7211f706ab2c5104204bad7228458c3f2 | f86f255f5e9d1d34a00a4095f601a8235e39aa5a | refs/heads/master | 2020-05-19T14:27:35.821340 | 2008-09-02T19:51:16 | 2008-09-02T19:51:16 | 32,342,555 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 62,322 | cpp | //--------------------------------------------------------------------------------------
// File: SDKmisc.cpp
//
// Various helper functionality that is shared between SDK samples
//
// Copyright (c) Microsoft Corporation. All rights reserved
//--------------------------------------------------------------------------------------
#include "dxut.h"
#include "SDKmisc.h"
#include "DXUTres.h"
#undef min // use __min instead
#undef max // use __max instead
//--------------------------------------------------------------------------------------
// Global/Static Members
//--------------------------------------------------------------------------------------
CDXUTResourceCache& WINAPI DXUTGetGlobalResourceCache()
{
// Using an accessor function gives control of the construction order
static CDXUTResourceCache cache;
return cache;
}
//--------------------------------------------------------------------------------------
// Internal functions forward declarations
//--------------------------------------------------------------------------------------
bool DXUTFindMediaSearchTypicalDirs( WCHAR* strSearchPath, int cchSearch, LPCWSTR strLeaf, WCHAR* strExePath, WCHAR* strExeName );
bool DXUTFindMediaSearchParentDirs( WCHAR* strSearchPath, int cchSearch, WCHAR* strStartAt, WCHAR* strLeafName );
INT_PTR CALLBACK DisplaySwitchToREFWarningProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
//--------------------------------------------------------------------------------------
// Shared code for samples to ask user if they want to use a REF device or quit
//--------------------------------------------------------------------------------------
void WINAPI DXUTDisplaySwitchingToREFWarning( DXUTDeviceVersion ver )
{
if( DXUTGetShowMsgBoxOnError() )
{
DWORD dwSkipWarning = 0, dwRead = 0, dwWritten = 0;
HANDLE hFile = NULL;
// Read previous user settings
WCHAR strPath[MAX_PATH];
SHGetFolderPath( DXUTGetHWND(), CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, strPath );
StringCchCat( strPath, MAX_PATH, L"\\DXUT\\SkipRefWarning.dat" );
if( (hFile = CreateFile( strPath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL )) != INVALID_HANDLE_VALUE )
{
ReadFile( hFile, &dwSkipWarning, sizeof(DWORD), &dwRead, NULL );
CloseHandle( hFile );
}
if( dwSkipWarning == 0 )
{
// Compact code to create a custom dialog box without using a template in a resource file.
// If this dialog were in a .rc file, this would be a lot simpler but every sample calling this function would
// need a copy of the dialog in its own .rc file. Also MessageBox API could be used here instead, but
// the MessageBox API is simpler to call but it can't provide a "Don't show again" checkbox
typedef struct { DLGITEMTEMPLATE a; WORD b; WORD c; WORD d; WORD e; WORD f; } DXUT_DLG_ITEM;
typedef struct { DLGTEMPLATE a; WORD b; WORD c; WCHAR d[2]; WORD e; WCHAR f[16]; DXUT_DLG_ITEM i1; DXUT_DLG_ITEM i2; DXUT_DLG_ITEM i3; DXUT_DLG_ITEM i4; DXUT_DLG_ITEM i5; } DXUT_DLG_DATA;
DXUT_DLG_DATA dtp =
{
{WS_CAPTION|WS_POPUP|WS_VISIBLE|WS_SYSMENU|DS_ABSALIGN|DS_3DLOOK|DS_SETFONT|DS_MODALFRAME|DS_CENTER,0,5,0,0,269,82},0,0,L" ",8,L"MS Shell Dlg 2",
{{WS_CHILD|WS_VISIBLE|SS_ICON|SS_CENTERIMAGE,0,7,7,24,24,0x100},0xFFFF,0x0082,0,0,0}, // icon
{{WS_CHILD|WS_VISIBLE,0,40,7,230,25,0x101},0xFFFF,0x0082,0,0,0}, // static text
{{WS_CHILD|WS_VISIBLE|WS_TABSTOP|BS_DEFPUSHBUTTON,0,80,39,50,14,IDYES},0xFFFF,0x0080,0,0,0}, // Yes button
{{WS_CHILD|WS_VISIBLE|WS_TABSTOP,0,133,39,50,14,IDNO},0xFFFF,0x0080,0,0,0}, // No button
{{WS_CHILD|WS_VISIBLE|WS_TABSTOP|BS_CHECKBOX,0,7,59,70,16,IDIGNORE},0xFFFF,0x0080,0,0,0}, // checkbox
};
int nResult = (int) DialogBoxIndirectParam( DXUTGetHINSTANCE(), (DLGTEMPLATE*)&dtp, DXUTGetHWND(), DisplaySwitchToREFWarningProc, (LPARAM) (ver==DXUT_D3D9_DEVICE) ? 9 : 10 );
if( (nResult & 0x80) == 0x80 ) // "Don't show again" checkbox was checked
{
// Save user settings
dwSkipWarning = 1;
SHGetFolderPath( DXUTGetHWND(), CSIDL_LOCAL_APPDATA, NULL, SHGFP_TYPE_CURRENT, strPath );
StringCchCat( strPath, MAX_PATH, L"\\DXUT" );
CreateDirectory( strPath, NULL );
StringCchCat( strPath, MAX_PATH, L"\\SkipRefWarning.dat" );
if( (hFile = CreateFile( strPath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL )) != INVALID_HANDLE_VALUE )
{
WriteFile( hFile, &dwSkipWarning, sizeof(DWORD), &dwWritten, NULL );
CloseHandle( hFile );
}
}
// User choose not to continue
if( (nResult & 0x0F) == IDNO )
DXUTShutdown(1);
}
}
}
//--------------------------------------------------------------------------------------
// MsgProc for DXUTDisplaySwitchingToREFWarning() dialog box
//--------------------------------------------------------------------------------------
INT_PTR CALLBACK DisplaySwitchToREFWarningProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_INITDIALOG:
// Easier to set text here than in the DLGITEMTEMPLATE
SetWindowText( hDlg, DXUTGetWindowTitle() );
SendMessage( GetDlgItem(hDlg, 0x100), STM_SETIMAGE, IMAGE_ICON, (LPARAM)LoadIcon(0, IDI_QUESTION));
WCHAR sz[512]; StringCchPrintf( sz, 512, L"This program needs to use the Direct3D %d reference device. This device implements the entire Direct3D %d feature set, but runs very slowly. Do you wish to continue?", lParam, lParam );
SetDlgItemText( hDlg, 0x101, sz );
SetDlgItemText( hDlg, IDYES, L"&Yes" );
SetDlgItemText( hDlg, IDNO, L"&No" );
SetDlgItemText( hDlg, IDIGNORE, L"&Don't show again" );
break;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case IDIGNORE: CheckDlgButton( hDlg, IDIGNORE, (IsDlgButtonChecked( hDlg, IDIGNORE ) == BST_CHECKED) ? BST_UNCHECKED : BST_CHECKED ); EnableWindow( GetDlgItem( hDlg, IDNO ), (IsDlgButtonChecked( hDlg, IDIGNORE ) != BST_CHECKED) ); break;
case IDNO: EndDialog(hDlg, (IsDlgButtonChecked( hDlg, IDIGNORE ) == BST_CHECKED) ? IDNO|0x80 : IDNO|0x00 ); return TRUE;
case IDCANCEL:
case IDYES: EndDialog(hDlg, (IsDlgButtonChecked( hDlg, IDIGNORE ) == BST_CHECKED) ? IDYES|0x80 : IDYES|0x00 ); return TRUE;
}
break;
}
return FALSE;
}
//--------------------------------------------------------------------------------------
// Returns pointer to static media search buffer
//--------------------------------------------------------------------------------------
WCHAR* DXUTMediaSearchPath()
{
static WCHAR s_strMediaSearchPath[MAX_PATH] = {0};
return s_strMediaSearchPath;
}
//--------------------------------------------------------------------------------------
LPCWSTR WINAPI DXUTGetMediaSearchPath()
{
return DXUTMediaSearchPath();
}
//--------------------------------------------------------------------------------------
HRESULT WINAPI DXUTSetMediaSearchPath( LPCWSTR strPath )
{
HRESULT hr;
WCHAR* s_strSearchPath = DXUTMediaSearchPath();
hr = StringCchCopy( s_strSearchPath, MAX_PATH, strPath );
if( SUCCEEDED(hr) )
{
// append slash if needed
size_t ch;
hr = StringCchLength( s_strSearchPath, MAX_PATH, &ch );
if( SUCCEEDED(hr) && s_strSearchPath[ch-1] != L'\\')
{
hr = StringCchCat( s_strSearchPath, MAX_PATH, L"\\" );
}
}
return hr;
}
//--------------------------------------------------------------------------------------
// Tries to find the location of a SDK media file
// cchDest is the size in WCHARs of strDestPath. Be careful not to
// pass in sizeof(strDest) on UNICODE builds.
//--------------------------------------------------------------------------------------
HRESULT WINAPI DXUTFindDXSDKMediaFileCch( WCHAR* strDestPath, int cchDest, LPCWSTR strFilename )
{
bool bFound;
WCHAR strSearchFor[MAX_PATH];
if( NULL==strFilename || strFilename[0] == 0 || NULL==strDestPath || cchDest < 10 )
return E_INVALIDARG;
// Get the exe name, and exe path
WCHAR strExePath[MAX_PATH] = {0};
WCHAR strExeName[MAX_PATH] = {0};
WCHAR* strLastSlash = NULL;
GetModuleFileName( NULL, strExePath, MAX_PATH );
strExePath[MAX_PATH-1]=0;
strLastSlash = wcsrchr( strExePath, TEXT('\\') );
if( strLastSlash )
{
StringCchCopy( strExeName, MAX_PATH, &strLastSlash[1] );
// Chop the exe name from the exe path
*strLastSlash = 0;
// Chop the .exe from the exe name
strLastSlash = wcsrchr( strExeName, TEXT('.') );
if( strLastSlash )
*strLastSlash = 0;
}
// Typical directories:
// .\
// ..\
// ..\..\
// %EXE_DIR%\
// %EXE_DIR%\..\
// %EXE_DIR%\..\..\
// %EXE_DIR%\..\%EXE_NAME%
// %EXE_DIR%\..\..\%EXE_NAME%
// Typical directory search
bFound = DXUTFindMediaSearchTypicalDirs( strDestPath, cchDest, strFilename, strExePath, strExeName );
if( bFound )
return S_OK;
// Typical directory search again, but also look in a subdir called "\media\"
StringCchPrintf( strSearchFor, MAX_PATH, L"media\\%s", strFilename );
bFound = DXUTFindMediaSearchTypicalDirs( strDestPath, cchDest, strSearchFor, strExePath, strExeName );
if( bFound )
return S_OK;
WCHAR strLeafName[MAX_PATH] = {0};
// Search all parent directories starting at .\ and using strFilename as the leaf name
StringCchCopy( strLeafName, MAX_PATH, strFilename );
bFound = DXUTFindMediaSearchParentDirs( strDestPath, cchDest, L".", strLeafName );
if( bFound )
return S_OK;
// Search all parent directories starting at the exe's dir and using strFilename as the leaf name
bFound = DXUTFindMediaSearchParentDirs( strDestPath, cchDest, strExePath, strLeafName );
if( bFound )
return S_OK;
// Search all parent directories starting at .\ and using "media\strFilename" as the leaf name
StringCchPrintf( strLeafName, MAX_PATH, L"media\\%s", strFilename );
bFound = DXUTFindMediaSearchParentDirs( strDestPath, cchDest, L".", strLeafName );
if( bFound )
return S_OK;
// Search all parent directories starting at the exe's dir and using "media\strFilename" as the leaf name
bFound = DXUTFindMediaSearchParentDirs( strDestPath, cchDest, strExePath, strLeafName );
if( bFound )
return S_OK;
// On failure, return the file as the path but also return an error code
StringCchCopy( strDestPath, cchDest, strFilename );
return DXUTERR_MEDIANOTFOUND;
}
//--------------------------------------------------------------------------------------
// Search a set of typical directories
//--------------------------------------------------------------------------------------
bool DXUTFindMediaSearchTypicalDirs( WCHAR* strSearchPath, int cchSearch, LPCWSTR strLeaf,
WCHAR* strExePath, WCHAR* strExeName )
{
// Typical directories:
// .\
// ..\
// ..\..\
// %EXE_DIR%\
// %EXE_DIR%\..\
// %EXE_DIR%\..\..\
// %EXE_DIR%\..\%EXE_NAME%
// %EXE_DIR%\..\..\%EXE_NAME%
// DXSDK media path
// Search in .\
StringCchCopy( strSearchPath, cchSearch, strLeaf );
if( GetFileAttributes( strSearchPath ) != 0xFFFFFFFF )
return true;
// Search in ..\
StringCchPrintf( strSearchPath, cchSearch, L"..\\%s", strLeaf );
if( GetFileAttributes( strSearchPath ) != 0xFFFFFFFF )
return true;
// Search in ..\..\
StringCchPrintf( strSearchPath, cchSearch, L"..\\..\\%s", strLeaf );
if( GetFileAttributes( strSearchPath ) != 0xFFFFFFFF )
return true;
// Search in ..\..\
StringCchPrintf( strSearchPath, cchSearch, L"..\\..\\%s", strLeaf );
if( GetFileAttributes( strSearchPath ) != 0xFFFFFFFF )
return true;
// Search in the %EXE_DIR%\
StringCchPrintf( strSearchPath, cchSearch, L"%s\\%s", strExePath, strLeaf );
if( GetFileAttributes( strSearchPath ) != 0xFFFFFFFF )
return true;
// Search in the %EXE_DIR%\..\
StringCchPrintf( strSearchPath, cchSearch, L"%s\\..\\%s", strExePath, strLeaf );
if( GetFileAttributes( strSearchPath ) != 0xFFFFFFFF )
return true;
// Search in the %EXE_DIR%\..\..\
StringCchPrintf( strSearchPath, cchSearch, L"%s\\..\\..\\%s", strExePath, strLeaf );
if( GetFileAttributes( strSearchPath ) != 0xFFFFFFFF )
return true;
// Search in "%EXE_DIR%\..\%EXE_NAME%\". This matches the DirectX SDK layout
StringCchPrintf( strSearchPath, cchSearch, L"%s\\..\\%s\\%s", strExePath, strExeName, strLeaf );
if( GetFileAttributes( strSearchPath ) != 0xFFFFFFFF )
return true;
// Search in "%EXE_DIR%\..\..\%EXE_NAME%\". This matches the DirectX SDK layout
StringCchPrintf( strSearchPath, cchSearch, L"%s\\..\\..\\%s\\%s", strExePath, strExeName, strLeaf );
if( GetFileAttributes( strSearchPath ) != 0xFFFFFFFF )
return true;
// Search in media search dir
WCHAR* s_strSearchPath = DXUTMediaSearchPath();
if( s_strSearchPath[0] != 0 )
{
StringCchPrintf( strSearchPath, cchSearch, L"%s%s", s_strSearchPath, strLeaf );
if( GetFileAttributes( strSearchPath ) != 0xFFFFFFFF )
return true;
}
return false;
}
//--------------------------------------------------------------------------------------
// Search parent directories starting at strStartAt, and appending strLeafName
// at each parent directory. It stops at the root directory.
//--------------------------------------------------------------------------------------
bool DXUTFindMediaSearchParentDirs( WCHAR* strSearchPath, int cchSearch, WCHAR* strStartAt, WCHAR* strLeafName )
{
WCHAR strFullPath[MAX_PATH] = {0};
WCHAR strFullFileName[MAX_PATH] = {0};
WCHAR strSearch[MAX_PATH] = {0};
WCHAR* strFilePart = NULL;
GetFullPathName( strStartAt, MAX_PATH, strFullPath, &strFilePart );
if( strFilePart == NULL )
return false;
while( strFilePart != NULL && *strFilePart != '\0' )
{
StringCchPrintf( strFullFileName, MAX_PATH, L"%s\\%s", strFullPath, strLeafName );
if( GetFileAttributes( strFullFileName ) != 0xFFFFFFFF )
{
StringCchCopy( strSearchPath, cchSearch, strFullFileName );
return true;
}
StringCchPrintf( strSearch, MAX_PATH, L"%s\\..", strFullPath );
GetFullPathName( strSearch, MAX_PATH, strFullPath, &strFilePart );
}
return false;
}
//--------------------------------------------------------------------------------------
// CDXUTResourceCache
//--------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------
CDXUTResourceCache::~CDXUTResourceCache()
{
OnDestroyDevice();
m_TextureCache.RemoveAll();
m_EffectCache.RemoveAll();
m_FontCache.RemoveAll();
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTResourceCache::CreateTextureFromFile( LPDIRECT3DDEVICE9 pDevice, LPCTSTR pSrcFile, LPDIRECT3DTEXTURE9 *ppTexture )
{
return CreateTextureFromFileEx( pDevice, pSrcFile, D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT,
0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT,
0, NULL, NULL, ppTexture );
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTResourceCache::CreateTextureFromFile( LPDIRECT3DDEVICE9 pDevice, LPCSTR pSrcFile, LPDIRECT3DTEXTURE9 *ppTexture )
{
WCHAR szSrcFile[MAX_PATH];
MultiByteToWideChar( CP_ACP, 0, pSrcFile, -1, szSrcFile, MAX_PATH );
szSrcFile[MAX_PATH-1] = 0;
return CreateTextureFromFile( pDevice, szSrcFile, ppTexture );
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTResourceCache::CreateTextureFromFile( ID3D10Device* pDevice, LPCTSTR pSrcFile, ID3D10ShaderResourceView** ppOutputRV, bool bSRGB )
{
return CreateTextureFromFileEx( pDevice, pSrcFile, NULL, NULL, ppOutputRV, bSRGB );
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTResourceCache::CreateTextureFromFile( ID3D10Device* pDevice, LPCSTR pSrcFile, ID3D10ShaderResourceView** ppOutputRV, bool bSRGB )
{
WCHAR szSrcFile[MAX_PATH];
MultiByteToWideChar( CP_ACP, 0, pSrcFile, -1, szSrcFile, MAX_PATH );
szSrcFile[MAX_PATH-1] = 0;
return CreateTextureFromFile( pDevice, szSrcFile, ppOutputRV, bSRGB );
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTResourceCache::CreateTextureFromFileEx( LPDIRECT3DDEVICE9 pDevice, LPCTSTR pSrcFile, UINT Width, UINT Height, UINT MipLevels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, DWORD Filter, DWORD MipFilter, D3DCOLOR ColorKey, D3DXIMAGE_INFO *pSrcInfo, PALETTEENTRY *pPalette, LPDIRECT3DTEXTURE9 *ppTexture )
{
// Search the cache for a matching entry.
for( int i = 0; i < m_TextureCache.GetSize(); ++i )
{
DXUTCache_Texture &Entry = m_TextureCache[i];
if( Entry.Location == DXUTCACHE_LOCATION_FILE &&
!lstrcmpW( Entry.wszSource, pSrcFile ) &&
Entry.Width == Width &&
Entry.Height == Height &&
Entry.MipLevels == MipLevels &&
Entry.Usage9 == Usage &&
Entry.Format9 == Format &&
Entry.Pool9 == Pool &&
Entry.Type9 == D3DRTYPE_TEXTURE )
{
// A match is found. Obtain the IDirect3DTexture9 interface and return that.
return Entry.pTexture9->QueryInterface( IID_IDirect3DTexture9, (LPVOID*)ppTexture );
}
}
HRESULT hr;
// No matching entry. Load the resource and create a new entry.
hr = D3DXCreateTextureFromFileEx( pDevice, pSrcFile, Width, Height, MipLevels, Usage, Format,
Pool, Filter, MipFilter, ColorKey, pSrcInfo, pPalette, ppTexture );
if( FAILED( hr ) )
return hr;
DXUTCache_Texture NewEntry;
NewEntry.Location = DXUTCACHE_LOCATION_FILE;
StringCchCopy( NewEntry.wszSource, MAX_PATH, pSrcFile );
NewEntry.Width = Width;
NewEntry.Height = Height;
NewEntry.MipLevels = MipLevels;
NewEntry.Usage9 = Usage;
NewEntry.Format9 = Format;
NewEntry.Pool9 = Pool;
NewEntry.Type9 = D3DRTYPE_TEXTURE;
(*ppTexture)->QueryInterface( IID_IDirect3DBaseTexture9, (LPVOID*)&NewEntry.pTexture9 );
m_TextureCache.Add( NewEntry );
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTResourceCache::CreateTextureFromFileEx( ID3D10Device* pDevice, LPCTSTR pSrcFile, D3DX10_IMAGE_LOAD_INFO* pLoadInfo, ID3DX10ThreadPump* pPump, ID3D10ShaderResourceView** ppOutputRV, bool bSRGB )
{
HRESULT hr = S_OK;
D3DX10_IMAGE_LOAD_INFO ZeroInfo; //D3DX10_IMAGE_LOAD_INFO has a default constructor
D3DX10_IMAGE_INFO SrcInfo;
if( !pLoadInfo )
{
pLoadInfo = &ZeroInfo;
}
if( !pLoadInfo->pSrcInfo )
{
D3DX10GetImageInfoFromFile( pSrcFile, NULL, &SrcInfo, NULL );
pLoadInfo->pSrcInfo = &SrcInfo;
pLoadInfo->Format = pLoadInfo->pSrcInfo->Format;
}
// Search the cache for a matching entry.
for( int i = 0; i < m_TextureCache.GetSize(); ++i )
{
DXUTCache_Texture &Entry = m_TextureCache[i];
if( Entry.Location == DXUTCACHE_LOCATION_FILE &&
!lstrcmpW( Entry.wszSource, pSrcFile ) &&
Entry.Width == pLoadInfo->Width &&
Entry.Height == pLoadInfo->Height &&
Entry.MipLevels == pLoadInfo->MipLevels &&
Entry.Usage10 == pLoadInfo->Usage &&
Entry.Format10 == pLoadInfo->Format &&
Entry.CpuAccessFlags == pLoadInfo->CpuAccessFlags &&
Entry.BindFlags == pLoadInfo->BindFlags &&
Entry.MiscFlags == pLoadInfo->MiscFlags )
{
// A match is found. Obtain the IDirect3DTexture9 interface and return that.
return Entry.pSRV10->QueryInterface( __uuidof( ID3D10ShaderResourceView ), (LPVOID*)ppOutputRV );
}
}
//Ready a new entry to the texture cache
//Do this before creating the texture since pLoadInfo may be volatile
DXUTCache_Texture NewEntry;
NewEntry.Location = DXUTCACHE_LOCATION_FILE;
StringCchCopy( NewEntry.wszSource, MAX_PATH, pSrcFile );
NewEntry.Width = pLoadInfo->Width;
NewEntry.Height = pLoadInfo->Height;
NewEntry.MipLevels = pLoadInfo->MipLevels;
NewEntry.Usage10 = pLoadInfo->Usage;
NewEntry.Format10 = pLoadInfo->Format;
NewEntry.CpuAccessFlags = pLoadInfo->CpuAccessFlags;
NewEntry.BindFlags = pLoadInfo->BindFlags;
NewEntry.MiscFlags = pLoadInfo->MiscFlags;
//Create the rexture
ID3D10Texture2D* pRes = NULL;
hr = D3DX10CreateTextureFromFile( pDevice, pSrcFile, pLoadInfo, pPump, (ID3D10Resource**)&pRes, NULL );
if( FAILED(hr) )
return hr;
if( bSRGB )
{
// This is a workaround so that we can load linearly, but sample in SRGB. Right now, we can't load
// as linear since D3DX will try to do conversion on load. Loading as TYPELESS doesn't work either, and
// loading as typed _UNORM doesn't allow us to create an SRGB view.
if ( pLoadInfo->pSrcInfo->ResourceDimension == D3D10_RESOURCE_DIMENSION_TEXTURE2D )
{
ID3D10Texture2D* pCopyTex = NULL;
D3D10_TEXTURE2D_DESC CopyDesc;
pRes->GetDesc( &CopyDesc );
CopyDesc.Format = MAKE_TYPELESS( CopyDesc.Format );
hr = pDevice->CreateTexture2D( &CopyDesc, NULL, &pCopyTex );
if( FAILED(hr) )
return hr;
pDevice->CopyResource( pCopyTex, pRes );
pRes->Release();
pRes = pCopyTex;
}
else
{
bSRGB = false;
}
}
D3D10_SHADER_RESOURCE_VIEW_DESC SRVDesc;
if( bSRGB )
SRVDesc.Format = MAKE_SRGB( ZeroInfo.Format );
else
SRVDesc.Format = ZeroInfo.Format;
if( pLoadInfo->pSrcInfo->ResourceDimension == D3D10_RESOURCE_DIMENSION_TEXTURE1D )
{
SRVDesc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURE1D;
SRVDesc.Texture1D.MostDetailedMip = 0;
SRVDesc.Texture1D.MipLevels = pLoadInfo->pSrcInfo->MipLevels;
}
else if(pLoadInfo->pSrcInfo->ResourceDimension == D3D10_RESOURCE_DIMENSION_TEXTURE2D )
{
SRVDesc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURE2D;
SRVDesc.Texture2D.MostDetailedMip = 0;
SRVDesc.Texture2D.MipLevels = pLoadInfo->pSrcInfo->MipLevels;
if( pLoadInfo->pSrcInfo->MiscFlags & D3D10_RESOURCE_MISC_TEXTURECUBE )
{
SRVDesc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURECUBE;
SRVDesc.TextureCube.MostDetailedMip = 0;
SRVDesc.TextureCube.MipLevels = pLoadInfo->pSrcInfo->MipLevels;
}
}
else if(pLoadInfo->pSrcInfo->ResourceDimension == D3D10_RESOURCE_DIMENSION_TEXTURE3D )
{
SRVDesc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURE3D;
SRVDesc.Texture3D.MostDetailedMip = 0;
SRVDesc.Texture3D.MipLevels = pLoadInfo->pSrcInfo->MipLevels;
}
hr = pDevice->CreateShaderResourceView( pRes, &SRVDesc, ppOutputRV );
pRes->Release();
if( FAILED(hr) )
return hr;
(*ppOutputRV)->QueryInterface( __uuidof( ID3D10ShaderResourceView ), (LPVOID*)&NewEntry.pSRV10 );
m_TextureCache.Add( NewEntry );
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTResourceCache::CreateTextureFromResource( LPDIRECT3DDEVICE9 pDevice, HMODULE hSrcModule, LPCTSTR pSrcResource, LPDIRECT3DTEXTURE9 *ppTexture )
{
return CreateTextureFromResourceEx( pDevice, hSrcModule, pSrcResource, D3DX_DEFAULT, D3DX_DEFAULT,
D3DX_DEFAULT, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT,
D3DX_DEFAULT, 0, NULL, NULL, ppTexture );
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTResourceCache::CreateTextureFromResourceEx( LPDIRECT3DDEVICE9 pDevice, HMODULE hSrcModule, LPCTSTR pSrcResource, UINT Width, UINT Height, UINT MipLevels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, DWORD Filter, DWORD MipFilter, D3DCOLOR ColorKey, D3DXIMAGE_INFO *pSrcInfo, PALETTEENTRY *pPalette, LPDIRECT3DTEXTURE9 *ppTexture )
{
// Search the cache for a matching entry.
for( int i = 0; i < m_TextureCache.GetSize(); ++i )
{
DXUTCache_Texture &Entry = m_TextureCache[i];
if( Entry.Location == DXUTCACHE_LOCATION_RESOURCE &&
Entry.hSrcModule == hSrcModule &&
!lstrcmpW( Entry.wszSource, pSrcResource ) &&
Entry.Width == Width &&
Entry.Height == Height &&
Entry.MipLevels == MipLevels &&
Entry.Usage9 == Usage &&
Entry.Format9 == Format &&
Entry.Pool9 == Pool &&
Entry.Type9 == D3DRTYPE_TEXTURE )
{
// A match is found. Obtain the IDirect3DTexture9 interface and return that.
return Entry.pTexture9->QueryInterface( IID_IDirect3DTexture9, (LPVOID*)ppTexture );
}
}
HRESULT hr;
// No matching entry. Load the resource and create a new entry.
hr = D3DXCreateTextureFromResourceEx( pDevice, hSrcModule, pSrcResource, Width, Height, MipLevels, Usage,
Format, Pool, Filter, MipFilter, ColorKey, pSrcInfo, pPalette, ppTexture );
if( FAILED( hr ) )
return hr;
DXUTCache_Texture NewEntry;
NewEntry.Location = DXUTCACHE_LOCATION_RESOURCE;
NewEntry.hSrcModule = hSrcModule;
StringCchCopy( NewEntry.wszSource, MAX_PATH, pSrcResource );
NewEntry.Width = Width;
NewEntry.Height = Height;
NewEntry.MipLevels = MipLevels;
NewEntry.Usage9 = Usage;
NewEntry.Format9 = Format;
NewEntry.Pool9 = Pool;
NewEntry.Type9 = D3DRTYPE_TEXTURE;
(*ppTexture)->QueryInterface( IID_IDirect3DBaseTexture9, (LPVOID*)&NewEntry.pTexture9 );
m_TextureCache.Add( NewEntry );
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTResourceCache::CreateCubeTextureFromFile( LPDIRECT3DDEVICE9 pDevice, LPCTSTR pSrcFile, LPDIRECT3DCUBETEXTURE9 *ppCubeTexture )
{
return CreateCubeTextureFromFileEx( pDevice, pSrcFile, D3DX_DEFAULT, D3DX_DEFAULT, 0,
D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT,
0, NULL, NULL, ppCubeTexture );
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTResourceCache::CreateCubeTextureFromFileEx( LPDIRECT3DDEVICE9 pDevice, LPCTSTR pSrcFile, UINT Size, UINT MipLevels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, DWORD Filter, DWORD MipFilter, D3DCOLOR ColorKey, D3DXIMAGE_INFO *pSrcInfo, PALETTEENTRY *pPalette, LPDIRECT3DCUBETEXTURE9 *ppCubeTexture )
{
// Search the cache for a matching entry.
for( int i = 0; i < m_TextureCache.GetSize(); ++i )
{
DXUTCache_Texture &Entry = m_TextureCache[i];
if( Entry.Location == DXUTCACHE_LOCATION_FILE &&
!lstrcmpW( Entry.wszSource, pSrcFile ) &&
Entry.Width == Size &&
Entry.MipLevels == MipLevels &&
Entry.Usage9 == Usage &&
Entry.Format9 == Format &&
Entry.Pool9 == Pool &&
Entry.Type9 == D3DRTYPE_CUBETEXTURE )
{
// A match is found. Obtain the IDirect3DCubeTexture9 interface and return that.
return Entry.pTexture9->QueryInterface( IID_IDirect3DCubeTexture9, (LPVOID*)ppCubeTexture );
}
}
HRESULT hr;
// No matching entry. Load the resource and create a new entry.
hr = D3DXCreateCubeTextureFromFileEx( pDevice, pSrcFile, Size, MipLevels, Usage, Format, Pool, Filter,
MipFilter, ColorKey, pSrcInfo, pPalette, ppCubeTexture );
if( FAILED( hr ) )
return hr;
DXUTCache_Texture NewEntry;
NewEntry.Location = DXUTCACHE_LOCATION_FILE;
StringCchCopy( NewEntry.wszSource, MAX_PATH, pSrcFile );
NewEntry.Width = Size;
NewEntry.MipLevels = MipLevels;
NewEntry.Usage9 = Usage;
NewEntry.Format9 = Format;
NewEntry.Pool9 = Pool;
NewEntry.Type9 = D3DRTYPE_CUBETEXTURE;
(*ppCubeTexture)->QueryInterface( IID_IDirect3DBaseTexture9, (LPVOID*)&NewEntry.pTexture9 );
m_TextureCache.Add( NewEntry );
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTResourceCache::CreateCubeTextureFromResource( LPDIRECT3DDEVICE9 pDevice, HMODULE hSrcModule, LPCTSTR pSrcResource, LPDIRECT3DCUBETEXTURE9 *ppCubeTexture )
{
return CreateCubeTextureFromResourceEx( pDevice, hSrcModule, pSrcResource, D3DX_DEFAULT, D3DX_DEFAULT,
0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT,
0, NULL, NULL, ppCubeTexture );
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTResourceCache::CreateCubeTextureFromResourceEx( LPDIRECT3DDEVICE9 pDevice, HMODULE hSrcModule, LPCTSTR pSrcResource, UINT Size, UINT MipLevels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, DWORD Filter, DWORD MipFilter, D3DCOLOR ColorKey, D3DXIMAGE_INFO *pSrcInfo, PALETTEENTRY *pPalette, LPDIRECT3DCUBETEXTURE9 *ppCubeTexture )
{
// Search the cache for a matching entry.
for( int i = 0; i < m_TextureCache.GetSize(); ++i )
{
DXUTCache_Texture &Entry = m_TextureCache[i];
if( Entry.Location == DXUTCACHE_LOCATION_RESOURCE &&
Entry.hSrcModule == hSrcModule &&
!lstrcmpW( Entry.wszSource, pSrcResource ) &&
Entry.Width == Size &&
Entry.MipLevels == MipLevels &&
Entry.Usage9 == Usage &&
Entry.Format9 == Format &&
Entry.Pool9 == Pool &&
Entry.Type9 == D3DRTYPE_CUBETEXTURE )
{
// A match is found. Obtain the IDirect3DCubeTexture9 interface and return that.
return Entry.pTexture9->QueryInterface( IID_IDirect3DCubeTexture9, (LPVOID*)ppCubeTexture );
}
}
HRESULT hr;
// No matching entry. Load the resource and create a new entry.
hr = D3DXCreateCubeTextureFromResourceEx( pDevice, hSrcModule, pSrcResource, Size, MipLevels, Usage, Format,
Pool, Filter, MipFilter, ColorKey, pSrcInfo, pPalette, ppCubeTexture );
if( FAILED( hr ) )
return hr;
DXUTCache_Texture NewEntry;
NewEntry.Location = DXUTCACHE_LOCATION_RESOURCE;
NewEntry.hSrcModule = hSrcModule;
StringCchCopy( NewEntry.wszSource, MAX_PATH, pSrcResource );
NewEntry.Width = Size;
NewEntry.MipLevels = MipLevels;
NewEntry.Usage9 = Usage;
NewEntry.Format9 = Format;
NewEntry.Pool9 = Pool;
NewEntry.Type9 = D3DRTYPE_CUBETEXTURE;
(*ppCubeTexture)->QueryInterface( IID_IDirect3DBaseTexture9, (LPVOID*)&NewEntry.pTexture9 );
m_TextureCache.Add( NewEntry );
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTResourceCache::CreateVolumeTextureFromFile( LPDIRECT3DDEVICE9 pDevice, LPCTSTR pSrcFile, LPDIRECT3DVOLUMETEXTURE9 *ppVolumeTexture )
{
return CreateVolumeTextureFromFileEx( pDevice, pSrcFile, D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT, D3DX_DEFAULT,
0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT,
0, NULL, NULL, ppVolumeTexture );
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTResourceCache::CreateVolumeTextureFromFileEx( LPDIRECT3DDEVICE9 pDevice, LPCTSTR pSrcFile, UINT Width, UINT Height, UINT Depth, UINT MipLevels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, DWORD Filter, DWORD MipFilter, D3DCOLOR ColorKey, D3DXIMAGE_INFO *pSrcInfo, PALETTEENTRY *pPalette, LPDIRECT3DVOLUMETEXTURE9 *ppTexture )
{
// Search the cache for a matching entry.
for( int i = 0; i < m_TextureCache.GetSize(); ++i )
{
DXUTCache_Texture &Entry = m_TextureCache[i];
if( Entry.Location == DXUTCACHE_LOCATION_FILE &&
!lstrcmpW( Entry.wszSource, pSrcFile ) &&
Entry.Width == Width &&
Entry.Height == Height &&
Entry.Depth == Depth &&
Entry.MipLevels == MipLevels &&
Entry.Usage9 == Usage &&
Entry.Format9 == Format &&
Entry.Pool9 == Pool &&
Entry.Type9 == D3DRTYPE_VOLUMETEXTURE )
{
// A match is found. Obtain the IDirect3DVolumeTexture9 interface and return that.
return Entry.pTexture9->QueryInterface( IID_IDirect3DVolumeTexture9, (LPVOID*)ppTexture );
}
}
HRESULT hr;
// No matching entry. Load the resource and create a new entry.
hr = D3DXCreateVolumeTextureFromFileEx( pDevice, pSrcFile, Width, Height, Depth, MipLevels, Usage, Format,
Pool, Filter, MipFilter, ColorKey, pSrcInfo, pPalette, ppTexture );
if( FAILED( hr ) )
return hr;
DXUTCache_Texture NewEntry;
NewEntry.Location = DXUTCACHE_LOCATION_FILE;
StringCchCopy( NewEntry.wszSource, MAX_PATH, pSrcFile );
NewEntry.Width = Width;
NewEntry.Height = Height;
NewEntry.Depth = Depth;
NewEntry.MipLevels = MipLevels;
NewEntry.Usage9 = Usage;
NewEntry.Format9 = Format;
NewEntry.Pool9 = Pool;
NewEntry.Type9 = D3DRTYPE_VOLUMETEXTURE;
(*ppTexture)->QueryInterface( IID_IDirect3DBaseTexture9, (LPVOID*)&NewEntry.pTexture9 );
m_TextureCache.Add( NewEntry );
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTResourceCache::CreateVolumeTextureFromResource( LPDIRECT3DDEVICE9 pDevice, HMODULE hSrcModule, LPCTSTR pSrcResource, LPDIRECT3DVOLUMETEXTURE9 *ppVolumeTexture )
{
return CreateVolumeTextureFromResourceEx( pDevice, hSrcModule, pSrcResource, D3DX_DEFAULT, D3DX_DEFAULT,
D3DX_DEFAULT, D3DX_DEFAULT, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED,
D3DX_DEFAULT, D3DX_DEFAULT, 0, NULL, NULL, ppVolumeTexture );
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTResourceCache::CreateVolumeTextureFromResourceEx( LPDIRECT3DDEVICE9 pDevice, HMODULE hSrcModule, LPCTSTR pSrcResource, UINT Width, UINT Height, UINT Depth, UINT MipLevels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, DWORD Filter, DWORD MipFilter, D3DCOLOR ColorKey, D3DXIMAGE_INFO *pSrcInfo, PALETTEENTRY *pPalette, LPDIRECT3DVOLUMETEXTURE9 *ppVolumeTexture )
{
// Search the cache for a matching entry.
for( int i = 0; i < m_TextureCache.GetSize(); ++i )
{
DXUTCache_Texture &Entry = m_TextureCache[i];
if( Entry.Location == DXUTCACHE_LOCATION_RESOURCE &&
Entry.hSrcModule == hSrcModule &&
!lstrcmpW( Entry.wszSource, pSrcResource ) &&
Entry.Width == Width &&
Entry.Height == Height &&
Entry.Depth == Depth &&
Entry.MipLevels == MipLevels &&
Entry.Usage9 == Usage &&
Entry.Format9 == Format &&
Entry.Pool9 == Pool &&
Entry.Type9 == D3DRTYPE_VOLUMETEXTURE )
{
// A match is found. Obtain the IDirect3DVolumeTexture9 interface and return that.
return Entry.pTexture9->QueryInterface( IID_IDirect3DVolumeTexture9, (LPVOID*)ppVolumeTexture );
}
}
HRESULT hr;
// No matching entry. Load the resource and create a new entry.
hr = D3DXCreateVolumeTextureFromResourceEx( pDevice, hSrcModule, pSrcResource, Width, Height, Depth, MipLevels, Usage,
Format, Pool, Filter, MipFilter, ColorKey, pSrcInfo, pPalette, ppVolumeTexture );
if( FAILED( hr ) )
return hr;
DXUTCache_Texture NewEntry;
NewEntry.Location = DXUTCACHE_LOCATION_RESOURCE;
NewEntry.hSrcModule = hSrcModule;
StringCchCopy( NewEntry.wszSource, MAX_PATH, pSrcResource );
NewEntry.Width = Width;
NewEntry.Height = Height;
NewEntry.Depth = Depth;
NewEntry.MipLevels = MipLevels;
NewEntry.Usage9 = Usage;
NewEntry.Format9 = Format;
NewEntry.Pool9 = Pool;
NewEntry.Type9 = D3DRTYPE_VOLUMETEXTURE;
(*ppVolumeTexture)->QueryInterface( IID_IDirect3DBaseTexture9, (LPVOID*)&NewEntry.pTexture9 );
m_TextureCache.Add( NewEntry );
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTResourceCache::CreateFont( LPDIRECT3DDEVICE9 pDevice, UINT Height, UINT Width, UINT Weight, UINT MipLevels, BOOL Italic, DWORD CharSet, DWORD OutputPrecision, DWORD Quality, DWORD PitchAndFamily, LPCTSTR pFacename, LPD3DXFONT *ppFont )
{
D3DXFONT_DESCW Desc;
Desc.Height = Height;
Desc.Width = Width;
Desc.Weight = Weight;
Desc.MipLevels = MipLevels;
Desc.Italic = Italic;
Desc.CharSet = (BYTE)CharSet;
Desc.OutputPrecision = (BYTE)OutputPrecision;
Desc.Quality = (BYTE)Quality;
Desc.PitchAndFamily = (BYTE)PitchAndFamily;
StringCchCopy( Desc.FaceName, LF_FACESIZE, pFacename );
return CreateFontIndirect( pDevice, &Desc, ppFont );
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTResourceCache::CreateFontIndirect( LPDIRECT3DDEVICE9 pDevice, CONST D3DXFONT_DESC *pDesc, LPD3DXFONT *ppFont )
{
// Search the cache for a matching entry.
for( int i = 0; i < m_FontCache.GetSize(); ++i )
{
DXUTCache_Font &Entry = m_FontCache[i];
if( Entry.Width == pDesc->Width &&
Entry.Height == pDesc->Height &&
Entry.Weight == pDesc->Weight &&
Entry.MipLevels == pDesc->MipLevels &&
Entry.Italic == pDesc->Italic &&
Entry.CharSet == pDesc->CharSet &&
Entry.OutputPrecision == pDesc->OutputPrecision &&
Entry.Quality == pDesc->Quality &&
Entry.PitchAndFamily == pDesc->PitchAndFamily &&
CompareString( LOCALE_USER_DEFAULT, NORM_IGNORECASE,
Entry.FaceName, -1,
pDesc->FaceName, -1 ) == CSTR_EQUAL )
{
// A match is found. Increment the reference and return the ID3DXFont object.
Entry.pFont->AddRef();
*ppFont = Entry.pFont;
return S_OK;
}
}
HRESULT hr;
// No matching entry. Load the resource and create a new entry.
hr = D3DXCreateFontIndirect( pDevice, pDesc, ppFont );
if( FAILED( hr ) )
return hr;
DXUTCache_Font NewEntry;
(D3DXFONT_DESC &)NewEntry = *pDesc;
NewEntry.pFont = *ppFont;
NewEntry.pFont->AddRef();
m_FontCache.Add( NewEntry );
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTResourceCache::CreateEffectFromFile( LPDIRECT3DDEVICE9 pDevice, LPCTSTR pSrcFile, const D3DXMACRO *pDefines, LPD3DXINCLUDE pInclude, DWORD Flags, LPD3DXEFFECTPOOL pPool, LPD3DXEFFECT *ppEffect, LPD3DXBUFFER *ppCompilationErrors )
{
// Search the cache for a matching entry.
for( int i = 0; i < m_EffectCache.GetSize(); ++i )
{
DXUTCache_Effect &Entry = m_EffectCache[i];
if( Entry.Location == DXUTCACHE_LOCATION_FILE &&
!lstrcmpW( Entry.wszSource, pSrcFile ) &&
Entry.dwFlags == Flags )
{
// A match is found. Increment the ref coutn and return the ID3DXEffect object.
*ppEffect = Entry.pEffect;
(*ppEffect)->AddRef();
return S_OK;
}
}
HRESULT hr;
// No matching entry. Load the resource and create a new entry.
hr = D3DXCreateEffectFromFile( pDevice, pSrcFile, pDefines, pInclude, Flags, pPool, ppEffect, ppCompilationErrors );
if( FAILED( hr ) )
return hr;
DXUTCache_Effect NewEntry;
NewEntry.Location = DXUTCACHE_LOCATION_FILE;
StringCchCopy( NewEntry.wszSource, MAX_PATH, pSrcFile );
NewEntry.dwFlags = Flags;
NewEntry.pEffect = *ppEffect;
NewEntry.pEffect->AddRef();
m_EffectCache.Add( NewEntry );
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTResourceCache::CreateEffectFromResource( LPDIRECT3DDEVICE9 pDevice, HMODULE hSrcModule, LPCTSTR pSrcResource, const D3DXMACRO *pDefines, LPD3DXINCLUDE pInclude, DWORD Flags, LPD3DXEFFECTPOOL pPool, LPD3DXEFFECT *ppEffect, LPD3DXBUFFER *ppCompilationErrors )
{
// Search the cache for a matching entry.
for( int i = 0; i < m_EffectCache.GetSize(); ++i )
{
DXUTCache_Effect &Entry = m_EffectCache[i];
if( Entry.Location == DXUTCACHE_LOCATION_RESOURCE &&
Entry.hSrcModule == hSrcModule &&
!lstrcmpW( Entry.wszSource, pSrcResource ) &&
Entry.dwFlags == Flags )
{
// A match is found. Increment the ref coutn and return the ID3DXEffect object.
*ppEffect = Entry.pEffect;
(*ppEffect)->AddRef();
return S_OK;
}
}
HRESULT hr;
// No matching entry. Load the resource and create a new entry.
hr = D3DXCreateEffectFromResource( pDevice, hSrcModule, pSrcResource, pDefines, pInclude, Flags,
pPool, ppEffect, ppCompilationErrors );
if( FAILED( hr ) )
return hr;
DXUTCache_Effect NewEntry;
NewEntry.Location = DXUTCACHE_LOCATION_RESOURCE;
NewEntry.hSrcModule = hSrcModule;
StringCchCopy( NewEntry.wszSource, MAX_PATH, pSrcResource );
NewEntry.dwFlags = Flags;
NewEntry.pEffect = *ppEffect;
NewEntry.pEffect->AddRef();
m_EffectCache.Add( NewEntry );
return S_OK;
}
//--------------------------------------------------------------------------------------
// Device event callbacks
//--------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------
HRESULT CDXUTResourceCache::OnCreateDevice( IDirect3DDevice9 *pd3dDevice )
{
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTResourceCache::OnResetDevice( IDirect3DDevice9 *pd3dDevice )
{
// Call OnResetDevice on all effect and font objects
for( int i = 0; i < m_EffectCache.GetSize(); ++i )
m_EffectCache[i].pEffect->OnResetDevice();
for( int i = 0; i < m_FontCache.GetSize(); ++i )
m_FontCache[i].pFont->OnResetDevice();
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTResourceCache::OnLostDevice()
{
// Call OnLostDevice on all effect and font objects
for( int i = 0; i < m_EffectCache.GetSize(); ++i )
m_EffectCache[i].pEffect->OnLostDevice();
for( int i = 0; i < m_FontCache.GetSize(); ++i )
m_FontCache[i].pFont->OnLostDevice();
// Release all the default pool textures
for( int i = m_TextureCache.GetSize() - 1; i >= 0; --i )
if( m_TextureCache[i].Pool9 == D3DPOOL_DEFAULT )
{
SAFE_RELEASE( m_TextureCache[i].pTexture9 );
m_TextureCache.Remove( i ); // Remove the entry
}
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTResourceCache::OnDestroyDevice()
{
// Release all resources
for( int i = m_EffectCache.GetSize() - 1; i >= 0; --i )
{
SAFE_RELEASE( m_EffectCache[i].pEffect );
m_EffectCache.Remove( i );
}
for( int i = m_FontCache.GetSize() - 1; i >= 0; --i )
{
SAFE_RELEASE( m_FontCache[i].pFont );
m_FontCache.Remove( i );
}
for( int i = m_TextureCache.GetSize() - 1; i >= 0; --i )
{
SAFE_RELEASE( m_TextureCache[i].pTexture9 );
SAFE_RELEASE( m_TextureCache[i].pSRV10 );
m_TextureCache.Remove( i );
}
return S_OK;
}
//--------------------------------------------------------------------------------------
// Desc: Returns a view matrix for rendering to a face of a cubemap.
//--------------------------------------------------------------------------------------
D3DXMATRIX WINAPI DXUTGetCubeMapViewMatrix( DWORD dwFace )
{
D3DXVECTOR3 vEyePt = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
D3DXVECTOR3 vLookDir;
D3DXVECTOR3 vUpDir;
switch( dwFace )
{
case D3DCUBEMAP_FACE_POSITIVE_X:
vLookDir = D3DXVECTOR3( 1.0f, 0.0f, 0.0f );
vUpDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
break;
case D3DCUBEMAP_FACE_NEGATIVE_X:
vLookDir = D3DXVECTOR3(-1.0f, 0.0f, 0.0f );
vUpDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
break;
case D3DCUBEMAP_FACE_POSITIVE_Y:
vLookDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
vUpDir = D3DXVECTOR3( 0.0f, 0.0f,-1.0f );
break;
case D3DCUBEMAP_FACE_NEGATIVE_Y:
vLookDir = D3DXVECTOR3( 0.0f,-1.0f, 0.0f );
vUpDir = D3DXVECTOR3( 0.0f, 0.0f, 1.0f );
break;
case D3DCUBEMAP_FACE_POSITIVE_Z:
vLookDir = D3DXVECTOR3( 0.0f, 0.0f, 1.0f );
vUpDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
break;
case D3DCUBEMAP_FACE_NEGATIVE_Z:
vLookDir = D3DXVECTOR3( 0.0f, 0.0f,-1.0f );
vUpDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
break;
}
// Set the view transform for this cubemap surface
D3DXMATRIXA16 mView;
D3DXMatrixLookAtLH( &mView, &vEyePt, &vLookDir, &vUpDir );
return mView;
}
//--------------------------------------------------------------------------------------
CDXUTLineManager::CDXUTLineManager()
{
m_pd3dDevice = NULL;
m_pD3DXLine = NULL;
}
//--------------------------------------------------------------------------------------
CDXUTLineManager::~CDXUTLineManager()
{
OnDeletedDevice();
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTLineManager::OnCreatedDevice( IDirect3DDevice9* pd3dDevice )
{
m_pd3dDevice = pd3dDevice;
HRESULT hr;
hr = D3DXCreateLine( m_pd3dDevice, &m_pD3DXLine );
if( FAILED(hr) )
return hr;
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTLineManager::OnResetDevice()
{
if( m_pD3DXLine )
m_pD3DXLine->OnResetDevice();
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTLineManager::OnRender()
{
HRESULT hr;
if( NULL == m_pD3DXLine )
return E_INVALIDARG;
bool bDrawingHasBegun = false;
float fLastWidth = 0.0f;
bool bLastAntiAlias = false;
for( int i=0; i<m_LinesList.GetSize(); i++ )
{
LINE_NODE* pLineNode = m_LinesList.GetAt(i);
if( pLineNode )
{
if( !bDrawingHasBegun ||
fLastWidth != pLineNode->fWidth ||
bLastAntiAlias != pLineNode->bAntiAlias )
{
if( bDrawingHasBegun )
{
hr = m_pD3DXLine->End();
if( FAILED(hr) )
return hr;
}
m_pD3DXLine->SetWidth( pLineNode->fWidth );
m_pD3DXLine->SetAntialias( pLineNode->bAntiAlias );
fLastWidth = pLineNode->fWidth;
bLastAntiAlias = pLineNode->bAntiAlias;
hr = m_pD3DXLine->Begin();
if( FAILED(hr) )
return hr;
bDrawingHasBegun = true;
}
hr = m_pD3DXLine->Draw( pLineNode->pVertexList, pLineNode->dwVertexListCount, pLineNode->Color );
if( FAILED(hr) )
return hr;
}
}
if( bDrawingHasBegun )
{
hr = m_pD3DXLine->End();
if( FAILED(hr) )
return hr;
}
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTLineManager::OnLostDevice()
{
if( m_pD3DXLine )
m_pD3DXLine->OnLostDevice();
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTLineManager::OnDeletedDevice()
{
RemoveAllLines();
SAFE_RELEASE( m_pD3DXLine );
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTLineManager::AddLine( int* pnLineID, D3DXVECTOR2* pVertexList, DWORD dwVertexListCount, D3DCOLOR Color, float fWidth, float fScaleRatio, bool bAntiAlias )
{
if( pVertexList == NULL || dwVertexListCount == 0 )
return E_INVALIDARG;
LINE_NODE* pLineNode = new LINE_NODE;
if( pLineNode == NULL )
return E_OUTOFMEMORY;
ZeroMemory( pLineNode, sizeof(LINE_NODE) );
pLineNode->nLineID = m_LinesList.GetSize();
pLineNode->Color = Color;
pLineNode->fWidth = fWidth;
pLineNode->bAntiAlias = bAntiAlias;
pLineNode->dwVertexListCount = dwVertexListCount;
if( pnLineID )
*pnLineID = pLineNode->nLineID;
pLineNode->pVertexList = new D3DXVECTOR2[dwVertexListCount];
if( pLineNode->pVertexList == NULL )
{
delete pLineNode;
return E_OUTOFMEMORY;
}
for( DWORD i=0; i<dwVertexListCount; i++ )
{
pLineNode->pVertexList[i] = pVertexList[i] * fScaleRatio;
}
m_LinesList.Add( pLineNode );
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTLineManager::AddRect( int* pnLineID, RECT rc, D3DCOLOR Color, float fWidth, float fScaleRatio, bool bAntiAlias )
{
if( fWidth > 2.0f )
{
D3DXVECTOR2 vertexList[8];
vertexList[0].x = (float)rc.left;
vertexList[0].y = (float)rc.top - (fWidth/2.0f);
vertexList[1].x = (float)rc.left;
vertexList[1].y = (float)rc.bottom + (fWidth/2.0f);
vertexList[2].x = (float)rc.left;
vertexList[2].y = (float)rc.bottom - 0.5f;
vertexList[3].x = (float)rc.right;
vertexList[3].y = (float)rc.bottom - 0.5f;
vertexList[4].x = (float)rc.right;
vertexList[4].y = (float)rc.bottom + (fWidth/2.0f);
vertexList[5].x = (float)rc.right;
vertexList[5].y = (float)rc.top - (fWidth/2.0f);
vertexList[6].x = (float)rc.right;
vertexList[6].y = (float)rc.top;
vertexList[7].x = (float)rc.left;
vertexList[7].y = (float)rc.top;
return AddLine( pnLineID, vertexList, 8, Color, fWidth, fScaleRatio, bAntiAlias );
}
else
{
D3DXVECTOR2 vertexList[5];
vertexList[0].x = (float)rc.left;
vertexList[0].y = (float)rc.top;
vertexList[1].x = (float)rc.left;
vertexList[1].y = (float)rc.bottom;
vertexList[2].x = (float)rc.right;
vertexList[2].y = (float)rc.bottom;
vertexList[3].x = (float)rc.right;
vertexList[3].y = (float)rc.top;
vertexList[4].x = (float)rc.left;
vertexList[4].y = (float)rc.top;
return AddLine( pnLineID, vertexList, 5, Color, fWidth, fScaleRatio, bAntiAlias );
}
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTLineManager::RemoveLine( int nLineID )
{
for( int i=0; i<m_LinesList.GetSize(); i++ )
{
LINE_NODE* pLineNode = m_LinesList.GetAt(i);
if( pLineNode && pLineNode->nLineID == nLineID )
{
SAFE_DELETE_ARRAY( pLineNode->pVertexList );
delete pLineNode;
m_LinesList.SetAt(i, NULL);
}
}
return S_OK;
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTLineManager::RemoveAllLines()
{
for( int i=0; i<m_LinesList.GetSize(); i++ )
{
LINE_NODE* pLineNode = m_LinesList.GetAt(i);
if( pLineNode )
{
SAFE_DELETE_ARRAY( pLineNode->pVertexList );
delete pLineNode;
}
}
m_LinesList.RemoveAll();
return S_OK;
}
//--------------------------------------------------------------------------------------
CDXUTTextHelper::CDXUTTextHelper( ID3DXFont* pFont9, ID3DXSprite* pSprite9, ID3DX10Font* pFont10, ID3DX10Sprite* pSprite10, int nLineHeight ) { Init( pFont9, pSprite9, pFont10, pSprite10, nLineHeight ); }
CDXUTTextHelper::CDXUTTextHelper( ID3DXFont* pFont, ID3DXSprite* pSprite, int nLineHeight ) { Init( pFont, pSprite, NULL, NULL, nLineHeight ); }
CDXUTTextHelper::CDXUTTextHelper( ID3DX10Font* pFont, ID3DX10Sprite* pSprite, int nLineHeight ) { Init( NULL, NULL, pFont, pSprite, nLineHeight ); }
CDXUTTextHelper::~CDXUTTextHelper()
{
SAFE_RELEASE( m_pFontBlendState10 );
}
//--------------------------------------------------------------------------------------
void CDXUTTextHelper::Init( ID3DXFont* pFont9, ID3DXSprite* pSprite9, ID3DX10Font* pFont10, ID3DX10Sprite* pSprite10, int nLineHeight )
{
m_pFont9 = pFont9;
m_pSprite9 = pSprite9;
m_pFont10 = pFont10;
m_pSprite10 = pSprite10;
m_clr = D3DXCOLOR(1,1,1,1);
m_pt.x = 0;
m_pt.y = 0;
m_nLineHeight = nLineHeight;
m_pFontBlendState10 = NULL;
// Create a blend state if a sprite is passed in
if( pSprite10 )
{
ID3D10Device* pDev = NULL;
pSprite10->GetDevice( &pDev );
if( pDev )
{
D3D10_BLEND_DESC StateDesc;
ZeroMemory( &StateDesc, sizeof(D3D10_BLEND_DESC) );
StateDesc.AlphaToCoverageEnable = FALSE;
StateDesc.BlendEnable[0] = TRUE;
StateDesc.SrcBlend = D3D10_BLEND_SRC_ALPHA;
StateDesc.DestBlend = D3D10_BLEND_INV_SRC_ALPHA;
StateDesc.BlendOp = D3D10_BLEND_OP_ADD;
StateDesc.SrcBlendAlpha = D3D10_BLEND_ZERO;
StateDesc.DestBlendAlpha = D3D10_BLEND_ZERO;
StateDesc.BlendOpAlpha = D3D10_BLEND_OP_ADD;
StateDesc.RenderTargetWriteMask[0] = 0xf;
pDev->CreateBlendState( &StateDesc, &m_pFontBlendState10 );
pDev->Release();
}
}
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTTextHelper::DrawFormattedTextLine( const WCHAR* strMsg, ... )
{
WCHAR strBuffer[512];
va_list args;
va_start(args, strMsg);
StringCchVPrintf( strBuffer, 512, strMsg, args );
strBuffer[511] = L'\0';
va_end(args);
return DrawTextLine( strBuffer );
}
//--------------------------------------------------------------------------------------
HRESULT CDXUTTextHelper::DrawTextLine( const WCHAR* strMsg )
{
if( NULL == m_pFont9 && NULL == m_pFont10 )
return DXUT_ERR_MSGBOX( L"DrawTextLine", E_INVALIDARG );
HRESULT hr;
RECT rc;
SetRect( &rc, m_pt.x, m_pt.y, 0, 0 );
if( m_pFont9 )
hr = m_pFont9->DrawText( m_pSprite9, strMsg, -1, &rc, DT_NOCLIP, m_clr );
else
hr = m_pFont10->DrawText( m_pSprite10, strMsg, -1, &rc, DT_NOCLIP, m_clr );
if( FAILED(hr) )
return DXTRACE_ERR_MSGBOX( L"DrawText", hr );
m_pt.y += m_nLineHeight;
return S_OK;
}
HRESULT CDXUTTextHelper::DrawFormattedTextLine( RECT &rc, DWORD dwFlags, const WCHAR* strMsg, ... )
{
WCHAR strBuffer[512];
va_list args;
va_start(args, strMsg);
StringCchVPrintf( strBuffer, 512, strMsg, args );
strBuffer[511] = L'\0';
va_end(args);
return DrawTextLine( rc, dwFlags, strBuffer );
}
HRESULT CDXUTTextHelper::DrawTextLine( RECT &rc, DWORD dwFlags, const WCHAR* strMsg )
{
if( NULL == m_pFont9 && NULL == m_pFont10 )
return DXUT_ERR_MSGBOX( L"DrawTextLine", E_INVALIDARG );
HRESULT hr;
if( m_pFont9 )
hr = m_pFont9->DrawText( m_pSprite9, strMsg, -1, &rc, dwFlags, m_clr );
else
hr = m_pFont10->DrawText( m_pSprite10, strMsg, -1, &rc, dwFlags, m_clr );
if( FAILED(hr) )
return DXTRACE_ERR_MSGBOX( L"DrawText", hr );
m_pt.y += m_nLineHeight;
return S_OK;
}
//--------------------------------------------------------------------------------------
void CDXUTTextHelper::Begin()
{
if( m_pSprite9 )
m_pSprite9->Begin( D3DXSPRITE_ALPHABLEND | D3DXSPRITE_SORT_TEXTURE );
if( m_pSprite10 )
{
D3D10_VIEWPORT VPs[D3D10_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE];
UINT cVPs = 1;
ID3D10Device* pd3dDevice = NULL;
m_pSprite10->GetDevice( &pd3dDevice );
if( pd3dDevice )
{
// Set projection
pd3dDevice->RSGetViewports(&cVPs, VPs);
D3DXMATRIXA16 matProjection;
D3DXMatrixOrthoOffCenterLH(&matProjection, (FLOAT)VPs[0].TopLeftX, (FLOAT)(VPs[0].TopLeftX + VPs[0].Width), (FLOAT)VPs[0].TopLeftY, (FLOAT)(VPs[0].TopLeftY + VPs[0].Height), 0.1f, 10);
m_pSprite10->SetProjectionTransform(&matProjection);
m_pSprite10->Begin( D3DX10_SPRITE_SORT_TEXTURE );
SAFE_RELEASE( pd3dDevice );
}
}
}
void CDXUTTextHelper::End()
{
if( m_pSprite9 )
m_pSprite9->End();
if( m_pSprite10 )
{
FLOAT OriginalBlendFactor[4];
UINT OriginalSampleMask = 0;
ID3D10BlendState* pOriginalBlendState10 = NULL;
ID3D10Device* pd3dDevice = NULL;
m_pSprite10->GetDevice( &pd3dDevice );
if( pd3dDevice )
{
// Get the old blend state and set the new one
pd3dDevice->OMGetBlendState( &pOriginalBlendState10, OriginalBlendFactor, &OriginalSampleMask );
if( m_pFontBlendState10 )
{
FLOAT NewBlendFactor[4] = {0,0,0,0};
pd3dDevice->OMSetBlendState( m_pFontBlendState10, NewBlendFactor, 0xffffffff );
}
}
m_pSprite10->End();
// Reset the original blend state
if( pd3dDevice && pOriginalBlendState10 )
{
pd3dDevice->OMSetBlendState( pOriginalBlendState10, OriginalBlendFactor, OriginalSampleMask );
}
SAFE_RELEASE( pOriginalBlendState10 );
SAFE_RELEASE( pd3dDevice );
}
}
//--------------------------------------------------------------------------------------
HRESULT DXUTSnapD3D9Screenshot( LPCTSTR szFileName )
{
HRESULT hr = S_OK;
IDirect3DDevice9* pDev = DXUTGetD3D9Device();
if( !pDev )
return E_FAIL;
IDirect3DSurface9* pBackBuffer = NULL;
V_RETURN( pDev->GetBackBuffer( 0, 0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer ) );
hr = D3DXSaveSurfaceToFile( szFileName, D3DXIFF_PNG, pBackBuffer, NULL, NULL );
pBackBuffer->Release();
//return D3DXSaveSurfaceToFile( szFileName, D3DXIFF_BMP, pBackBuffer, NULL, NULL );
return hr;
}
//--------------------------------------------------------------------------------------
HRESULT DXUTSnapD3D10Screenshot( LPCTSTR szFileName )
{
return E_FAIL;
}
| [
"sunil.ssingh@592c7993-d951-0410-8115-35849596357c"
]
| [
[
[
1,
1577
]
]
]
|
81d22769c49bb987bedb75395f08fc2777c7c78e | 11c5e387a64d7b58117e8d3551e5749a5ba89368 | /character.h | 82a030339cb97a0384e014f30060ab961af2a027 | []
| no_license | a711960/sb-rpg-game-engine | 68e4ccd76b3dc612b9e2f4e4bfa333d1aec19218 | f418b7097a756afd930d54cb54626fa2b92eb1db | refs/heads/master | 2016-08-12T08:44:55.422547 | 2011-02-14T19:47:57 | 2011-02-14T19:47:57 | 51,718,261 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 229 | h | #pragma once
#include <string>
using namespace std;
class character
{
public:
int ID;
int level;
int STR;
int base_atk;
string name;
int HP;
int HP_MAX;
int DEF;
character(void);
~character(void);
}; | [
"bartexsz@8cc52d28-822c-a204-14e7-ae2a17bdcdc8"
]
| [
[
[
1,
19
]
]
]
|
cc7808bed48ebc642c756801f31ad7535642513e | 91b964984762870246a2a71cb32187eb9e85d74e | /SRC/OFFI SRC!/_Network/Mcl/Src/CMclGlobal.cpp | 88da677677981f95bcdc3837da2f352d9c85aa02 | []
| no_license | willrebuild/flyffsf | e5911fb412221e00a20a6867fd00c55afca593c7 | d38cc11790480d617b38bb5fc50729d676aef80d | refs/heads/master | 2021-01-19T20:27:35.200154 | 2011-02-10T12:34:43 | 2011-02-10T12:34:43 | 32,710,780 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 649 | cpp | //
// FILE: CMclGlobal.cpp
//
// Copyright (c) 1997 by Aaron Michael Cohen
//
/////////////////////////////////////////////////////////////////////////
#include "CMclGlobal.h"
void CMclInternalThrowError( DWORD dwStatus, LPCTSTR lpFilename, int line) {
#ifdef _DEBUG
// print the error for debug builds...
TCHAR string[2*MAX_PATH];
wsprintf( string, "CMcl Library Win32 Error 0x%08x(%d) at %s line %d\n",
dwStatus, dwStatus, lpFilename, line);
OutputDebugString(string);
#endif
#if __CMCL_THROW_EXCEPTIONS__
// throw exception for fatal errors...
throw dwStatus;
#endif
}
| [
"[email protected]@e2c90bd7-ee55-cca0-76d2-bbf4e3699278"
]
| [
[
[
1,
24
]
]
]
|
2be68e4199a3d4ab46bed0b6c28a59ec01413d23 | 9b402d093b852a574dccb869fbe4bada1ef069c6 | /libs/mygui/inc/MyGUI_MultiList.h | f5bb8406f67e4b7a091d4391406fb725cf1ab19d | []
| no_license | wangscript007/foundation-engine | adb24d4ccc932d7a8f8238170029de6d2db0cbfb | 2982b06d8f6b69c0654e0c90671aaef9cfc6cc40 | refs/heads/master | 2021-05-27T17:26:15.178095 | 2010-06-30T22:06:45 | 2010-06-30T22:06:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 15,840 | h | /*!
@file
@author Albert Semenov
@date 04/2008
@module
*//*
This file is part of MyGUI.
MyGUI is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MyGUI is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with MyGUI. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __MYGUI_MULTI_LIST_H__
#define __MYGUI_MULTI_LIST_H__
#include "MyGUI_Prerequest.h"
#include "MyGUI_Widget.h"
#include "MyGUI_List.h"
#include "MyGUI_Any.h"
#include "MyGUI_BiIndexBase.h"
#include "MyGUI_EventPair.h"
namespace MyGUI
{
//OBSOLETE
typedef delegates::CDelegate5<WidgetPtr, size_t, const Ogre::UTFString &, const Ogre::UTFString &, bool &> EventHandle_WidgetIntUTFStringUTFStringBool;
typedef delegates::CDelegate5<MultiListPtr, size_t, const Ogre::UTFString &, const Ogre::UTFString &, bool &> EventHandle_MultiListPtrSizeTCUTFStringRefCUTFStringRefBoolRef;
typedef delegates::CDelegate2<MultiListPtr, size_t> EventHandle_MultiListPtrSizeT;
class MYGUI_EXPORT MultiList : public Widget, public BiIndexBase
{
// для вызова закрытого конструктора
friend class factory::BaseWidgetFactory<MultiList>;
MYGUI_RTTI_CHILD_HEADER( MultiList, Widget );
public:
//------------------------------------------------------------------------------//
// Methods for work with columns (RU:методы для работы со столбцами)
//------------------------------------------------------------------------------//
// манипуляции айтемами
//! Get number of columns
size_t getColumnCount() { return mVectorColumnInfo.size(); }
/** Insert new column
@param _column New column will be inserted before _column
@param _name Name of new column
@param _width Width of new column
*/
void insertColumnAt(size_t _column, const Ogre::UTFString & _name, int _width, Any _data = Any::Null);
/** Add new column at last position
@param _width Width of new column
@param _name Name of new column
*/
void addColumn(const Ogre::UTFString & _name, int _width, Any _data = Any::Null) { insertColumnAt(ITEM_NONE, _name, _width, _data); }
/** Delete column */
void removeColumnAt(size_t _column);
/** Delete all columns */
void removeAllColumns();
//------------------------------------------------------------------------------//
// манипуляции отображением
/** Set column name
@param _column Index of column
@param _name New name of column
*/
void setColumnNameAt(size_t _column, const Ogre::UTFString & _name);
/** Set column width
@param _column Index of column
@param _name New width of column
*/
void setColumnWidthAt(size_t _column, int _width);
/** Get _column name */
const Ogre::UTFString & getColumnNameAt(size_t _column);
/** Get _column width */
int getColumnWidthAt(size_t _column);
/** Sort multilist by column */
void sortByColumn(size_t _column, bool _backward = false);
//------------------------------------------------------------------------------//
// манипуляции данными
//! Replace an item data at a specified position
void setColumnDataAt(size_t _index, Any _data)
{
MYGUI_ASSERT_RANGE(_index, mVectorColumnInfo.size(), "MultiList::setColumnDataAt");
mVectorColumnInfo[_index].data = _data;
}
//! Clear an item data at a specified position
void clearColumnDataAt(size_t _index) { setColumnDataAt(_index, Any::Null); }
//! Get item data from specified position
template <typename ValueType>
ValueType * getColumnDataAt(size_t _index, bool _throw = true)
{
MYGUI_ASSERT_RANGE(_index, mVectorColumnInfo.size(), "MultiList::getItemDataAt");
return mVectorColumnInfo[_index].data.castType<ValueType>(_throw);
}
//------------------------------------------------------------------------------//
// Methods for work with lines (RU:методы для работы со строками)
/** @note
All indexes used here is indexes of unsorted Multilist. Even if you sorted
it - all items indexes will be same as before sort.
*/
//------------------------------------------------------------------------------//
// манипуляции айтемами
/** Get number of items (lines) */
size_t getItemCount();
/** Insert new item before _index line */
void insertItemAt(size_t _index, const Ogre::UTFString & _name, Any _data = Any::Null);
/** Add new item at the end */
void addItem(const Ogre::UTFString & _name, Any _data = Any::Null) { insertItemAt(ITEM_NONE, _name, _data); }
//! Remove item at a specified position
void removeItemAt(size_t _index);
/** Delete all items */
void removeAllItems();
//! Swap items at a specified positions
void swapItemsAt(size_t _index1, size_t _index2);
//------------------------------------------------------------------------------//
// манипуляции отображением
//! Replace an item name
void setItemNameAt(size_t _index, const Ogre::UTFString & _name) { setSubItemNameAt(0, _index, _name); }
//! Get item name from specified position
const Ogre::UTFString & getItemNameAt(size_t _index) { return getSubItemNameAt(0, _index); }
//------------------------------------------------------------------------------//
// манипуляции выделениями
/** Get index of selected item (ITEM_NONE if none selected) */
size_t getIndexSelected() { return mItemSelected; }
/** Select specified _index */
void setIndexSelected(size_t _index);
/** Clear item selection */
void clearIndexSelected() { setIndexSelected(ITEM_NONE); }
//------------------------------------------------------------------------------//
// манипуляции данными
//! Replace an item data at a specified position
void setItemDataAt(size_t _index, Any _data) { setSubItemDataAt(0, _index, _data); }
//! Clear an item data at a specified position
void clearItemDataAt(size_t _index) { setItemDataAt(_index, Any::Null); }
//! Get item data from specified position
template <typename ValueType>
ValueType * getItemDataAt(size_t _index, bool _throw = true)
{
return getSubItemDataAt<ValueType>(0, _index, _throw);
}
//------------------------------------------------------------------------------//
// Methods for work with sub lines (RU:методы для работы со саб строками)
//------------------------------------------------------------------------------//
// манипуляции данными
/** Set sub item
@param _column Index of column
@param _index Index of line
@param _name New sub item value
*/
void setSubItemNameAt(size_t _column, size_t _index, const Ogre::UTFString & _name);
/** Get sub item name*/
const Ogre::UTFString & getSubItemNameAt(size_t _column, size_t _index);
/** Search item in specified _column, returns index of the first occurrence in column or ITEM_NONE if item not found */
size_t findSubItemWith(size_t _column, const Ogre::UTFString & _name);
//------------------------------------------------------------------------------//
// манипуляции данными
//! Replace an item data at a specified position
void setSubItemDataAt(size_t _column, size_t _index, Any _data)
{
MYGUI_ASSERT_RANGE(_column, mVectorColumnInfo.size(), "MultiList::setSubItemDataAt");
MYGUI_ASSERT_RANGE(_index, mVectorColumnInfo.begin()->list->getItemCount(), "MultiList::setSubItemDataAt");
size_t index = BiIndexBase::convertToBack(_index);
mVectorColumnInfo[_column].list->setItemDataAt(index, _data);
}
//! Clear an item data at a specified position
void clearSubItemDataAt(size_t _column, size_t _index) { setSubItemDataAt(_column, _index, Any::Null); }
//! Get item data from specified position
template <typename ValueType>
ValueType * getSubItemDataAt(size_t _column, size_t _index, bool _throw = true)
{
MYGUI_ASSERT_RANGE(_column, mVectorColumnInfo.size(), "MultiList::getSubItemDataAt");
MYGUI_ASSERT_RANGE(_index, mVectorColumnInfo.begin()->list->getItemCount(), "MultiList::getSubItemDataAt");
size_t index = BiIndexBase::convertToBack(_index);
return mVectorColumnInfo[_column].list->getItemDataAt<ValueType>(index, _throw);
}
/*event:*/
/** Event : Enter pressed or double click.\n
signature : void method(MyGUI::MultiListPtr _sender, size_t _index)\n
@param _sender widget that called this event
@param _index of selected item
*/
EventPair<EventHandle_WidgetSizeT, EventHandle_MultiListPtrSizeT> eventListSelectAccept;
/** Event : Selected item position changed.\n
signature : void method(MyGUI::MultiListPtr _sender, size_t _index)\n
@param _sender widget that called this event
@param _index of new item
*/
EventPair<EventHandle_WidgetSizeT, EventHandle_MultiListPtrSizeT> eventListChangePosition;
/** Event : Less than operator for sort multilist by columns.\n
signature : void method(MyGUI::MultiListPtr _sender, size_t _column, const Ogre::UTFString & _firstItem, const Ogre::UTFString & _secondItem, bool & _less)\n
@param _sender widget that called this event
@param _column Index of column
@param _firstItem Strings for compare
@param _secondItem Strings for compare
@param _less Comparsion result (write your value here)
*/
EventHandle_MultiListPtrSizeTCUTFStringRefCUTFStringRefBoolRef requestOperatorLess;
/*obsolete:*/
#ifndef MYGUI_DONT_USE_OBSOLETE
MYGUI_OBSOLETE("use : size_t MultiList::getIndexSelected()")
size_t getItemIndexSelected() { return getIndexSelected(); }
MYGUI_OBSOLETE("use : void MultiList::setIndexSelected(size_t _index)")
void setItemSelectedAt(size_t _index) { setIndexSelected(_index); }
MYGUI_OBSOLETE("use : void MultiList::clearIndexSelected()")
void clearItemSelected() { clearIndexSelected(); }
MYGUI_OBSOLETE("use : size_t MultiList::findSubItemWith(size_t _column, const Ogre::UTFString & _name)")
size_t findItem(size_t _column, const Ogre::UTFString & _name) { return findSubItemWith(_column, _name); }
MYGUI_OBSOLETE("use : const Ogre::UTFString & MultiList::getSubItemNameAt(size_t _column, size_t _index)")
const Ogre::UTFString & getSubItem(size_t _column, size_t _index) { return getSubItemNameAt(_column, _index); }
MYGUI_OBSOLETE("use : void MultiList::setSubItemNameAt(size_t _column, size_t _index, const Ogre::UTFString & _name)")
void setSubItem(size_t _column, size_t _index, const Ogre::UTFString & _name) { setSubItemNameAt(_column, _index, _name); }
MYGUI_OBSOLETE("use : void MultiList::removeColumnAt(size_t _column)")
void deleteColumn(size_t _column) { removeColumnAt(_column); }
MYGUI_OBSOLETE("use : void MultiList::removeAllColumns()")
void deleteAllColumns() { removeAllColumns(); }
MYGUI_OBSOLETE("use : int MultiList::getColumnWidthAt(size_t _column)")
int getColumnWidth(size_t _column) { return getColumnWidthAt(_column); }
MYGUI_OBSOLETE("use : const Ogre::UTFString & MultiList::getColumnNameAt(size_t _column)")
const Ogre::UTFString & getColumnName(size_t _column) { return getColumnNameAt(_column); }
MYGUI_OBSOLETE("use : void MultiList::setColumnWidthAt(size_t _column, int _width)")
void setColumnWidth(size_t _column, int _width) { setColumnWidthAt(_column, _width); }
MYGUI_OBSOLETE("use : void MultiList::addColumn(const Ogre::UTFString & _name, int _width, Any _data)")
void addColumn(int _width, const Ogre::UTFString & _name) { addColumn(_name, _width); }
MYGUI_OBSOLETE("use : void MultiList::setColumnNameAt(size_t _column, const Ogre::UTFString & _name)")
void setColumnName(size_t _column, const Ogre::UTFString & _name) { setColumnNameAt(_column, _name); }
MYGUI_OBSOLETE("use : void MultiList::insertColumnAt(size_t _column, const Ogre::UTFString & _name, int _width, Any _data)")
void insertColumn(size_t _column, int _width, const Ogre::UTFString & _name) { insertColumnAt(_column, _name, _width); }
MYGUI_OBSOLETE("use : size_t MultiList::getIndexSelected()")
size_t getItemSelect() { return getIndexSelected(); }
MYGUI_OBSOLETE("use : void MultiList::clearIndexSelected()")
void resetItemSelect() { clearIndexSelected(); }
MYGUI_OBSOLETE("use : void MultiList::setIndexSelected(size_t _index)")
void setItemSelect(size_t _index) { setIndexSelected(_index); }
MYGUI_OBSOLETE("use : void MultiList::insertItemAt(size_t _index, const Ogre::UTFString & _name, Any _data)")
void insertItem(size_t _index, const Ogre::UTFString & _name) { insertItemAt(_index, _name); }
MYGUI_OBSOLETE("use : void MultiList::setItemNameAt(size_t _index, const Ogre::UTFString & _name)")
void setItem(size_t _index, const Ogre::UTFString & _name) { setItemNameAt(_index, _name); }
MYGUI_OBSOLETE("use : const Ogre::UTFString & MultiList::getItemNameAt(size_t _index)")
const Ogre::UTFString & getItem(size_t _index) { return getItemNameAt(_index); }
MYGUI_OBSOLETE("use : void MultiList::removeItemAt(size_t _index)")
void deleteItem(size_t _index) { removeItemAt(_index); }
MYGUI_OBSOLETE("use : void MultiList::removeAllItems()")
void deleteAllItems() { removeAllItems(); }
#endif // MYGUI_DONT_USE_OBSOLETE
protected:
MultiList(WidgetStyle _style, const IntCoord& _coord, Align _align, const WidgetSkinInfoPtr _info, WidgetPtr _parent, ICroppedRectangle * _croppedParent, IWidgetCreator * _creator, const std::string & _name);
virtual ~MultiList();
void baseChangeWidgetSkin(WidgetSkinInfoPtr _info);
void notifyListChangePosition(ListPtr _sender, size_t _position);
void notifyListChangeFocus(ListPtr _sender, size_t _position);
void notifyListChangeScrollPosition(ListPtr _sender, size_t _position);
void notifyButtonClick(WidgetPtr _sender);
void notifyListSelectAccept(ListPtr _sender, size_t _position);
void updateColumns();
void redrawButtons();
void updateOnlyEmpty();
bool compare(ListPtr _list, size_t _left, size_t _right);
void sortList();
void flipList();
void setDirtySort();
WidgetPtr getSeparator(size_t _index);
void setButtonImageIndex(ButtonPtr _button, size_t _index);
void updateBackSelected(size_t _index);
private:
void initialiseWidgetSkin(WidgetSkinInfoPtr _info);
void shutdownWidgetSkin();
void frameEntered(float _frame);
private:
struct ColumnInfo
{
ListPtr list;
ButtonPtr button;
int width;
Ogre::UTFString name;
Any data;
};
typedef std::vector<ColumnInfo> VectorColumnInfo;
enum ImageSort
{
SORT_NONE,
SORT_UP,
SORT_DOWN
};
private:
int mHeightButton;
int mWidthBar;
std::string mSkinButton, mSkinList;
ButtonPtr mButtonMain;
VectorColumnInfo mVectorColumnInfo;
VectorWidgetPtr mSeparators;
size_t mLastMouseFocusIndex;
bool mSortUp;
size_t mSortColumnIndex;
bool mIsDirtySort;
int mWidthSeparator;
std::string mSkinSeparator;
int mOffsetButtonSeparator;
size_t mItemSelected;
};
} // namespace MyGUI
#endif // __MYGUI_MULTI_LIST_H__
| [
"drivehappy@a5d1a9aa-f497-11dd-9d1a-b59b2e1864b6"
]
| [
[
[
1,
393
]
]
]
|
44d4facf72e36f59928e570d3964cb3c8abcf908 | b67d58bd5bfe13b32bebe83dec22904243a52223 | /FlashDBSimDll_Sample/NativeTrivalDeviceWrapper.h | d495ae1af0686c5930b4a4b4108b00b462e05da8 | []
| no_license | maheshdharhari/flash-sim | b8929efc83a65ee6d5e782b835106ca36228c6c8 | d04eb0e34bb44e7356f5c1b0e1f1af6097339225 | refs/heads/master | 2021-01-10T07:48:37.820361 | 2010-05-22T09:19:20 | 2010-05-22T09:19:20 | 43,440,579 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 789 | h | #ifndef _NATIVE_TRIVAL_DEVICE_WRAPPER_H_
#define _NATIVE_TRIVAL_DEVICE_WRAPPER_H_
namespace Buffers {
namespace Devices {
namespace FromNative {
public ref class TrivalBlockDevice : Buffers::IBlockDevice
{
private:
::TrivalBlockDevice* pdev;
public:
TrivalBlockDevice(::TrivalBlockDevice* pdev);
virtual property System::String^ Name { System::String^ get(); }
virtual property System::String^ Description { System::String^ get(); }
virtual property size_t PageSize { size_t get(); }
virtual property int ReadCount { int get(); }
virtual property int WriteCount { int get(); }
virtual void Read(size_t pageid, cli::array<unsigned char>^ result);
virtual void Write(size_t pageid, cli::array<unsigned char>^ data);
};
};
};
};
#endif
| [
"hiYoungCat@9895585c-9ddb-11de-bf4a-bd5be0e2b6d7"
]
| [
[
[
1,
32
]
]
]
|
79cacccd42585232cf41b22ca6b67709035bfc41 | b8ac0bb1d1731d074b7a3cbebccc283529b750d4 | /Code/controllers/RecollectionBenchmark/protocol/handlers/TrashBinBoardPacketHandler.cpp | f3146278b1440a669353f9bb14450e51f690deb3 | []
| no_license | dh-04/tpf-robotica | 5efbac38d59fda0271ac4639ea7b3b4129c28d82 | 10a7f4113d5a38dc0568996edebba91f672786e9 | refs/heads/master | 2022-12-10T18:19:22.428435 | 2010-11-05T02:42:29 | 2010-11-05T02:42:29 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,223 | cpp | // Class automatically generated by Dev-C++ New Class wizard
#include <protocol/handlers/TrashBinBoardPacketHandler.h> // class's header file
#include <protocol/packets/TrashBinPacket.h>
#include <math.h>
namespace protocol {
namespace handlers {
// class constructor
TrashBinBoardPacketHandler::TrashBinBoardPacketHandler(PacketServer * ps, char groupid, char boardid)
{
this->groupid = groupid;
this->boardid = boardid;
this->ps = ps;
this->currentValue = 0;
this->full = false;
#ifdef LINUX
this->currentValueMutex = new Mutex();
this->fullMutex = new Mutex();
#endif
}
// class destructor
TrashBinBoardPacketHandler::~TrashBinBoardPacketHandler()
{
// insert your code here
}
void TrashBinBoardPacketHandler::handlePacket(Packet * p){
packets::TrashBinPacket * tbp = new packets::TrashBinPacket(groupid,boardid);
tbp->analysePacket(p);
if ( tbp->getCommand() == CMD_TRASHBIN_VALUE ){
short value = tbp->getTrashBinValue();
// TODO convert from short to int
// Lock Mutex
#ifdef LINUX
this->currentMutex->enterMutex();
#endif
this->currentValue = value;
// Release Mutex
#ifdef LINUX
this->currentMutex->leaveMutex();
#endif
}
if ( tbp->getCommand() == CMD_FULL_TRASHBIN_ALARM ){
// Lock Mutex
#ifdef LINUX
this->fullMutex->enterMutex();
#endif
this->full = true;
// Release Mutex
#ifdef LINUX
this->fullMutex->leaveMutex();
#endif
}
}
int TrashBinBoardPacketHandler::getValue(){
packets::TrashBinPacket * p = new packets::TrashBinPacket(groupid,boardid);
p->senseTrashBin();
p->prepareToSend();
this->ps->sendPacket(p);
return this->currentValue;
}
bool TrashBinBoardPacketHandler::isFull(){
// Lock Mutex
#ifdef LINUX
this->fullMutex->enterMutex();
#endif
bool full = this->full;
// Release mutex
#ifdef LINUX
this->fullMutex->leaveMutex();
#endif
return full;
}
void TrashBinBoardPacketHandler::setFullBias(double bias){
packets::TrashBinPacket * p = new packets::TrashBinPacket(groupid,boardid);
// TODO convert from double to char
p->setTrashBinFullThreshold(bias);
p->prepareToSend();
this->ps->sendPacket(p);
}
}
}
| [
"guicamest@d69ea68a-f96b-11de-8cdf-e97ad7d0f28a"
]
| [
[
[
1,
99
]
]
]
|
c9f666dd3daea30a2473280af0799c7cdb5d099d | 27d5670a7739a866c3ad97a71c0fc9334f6875f2 | /CPP/Targets/GlobeLib/shared/src/gbFont.cpp | b3eb60c25318d6bf8594ca988231ad4536bfd200 | [
"BSD-3-Clause"
]
| permissive | ravustaja/Wayfinder-S60-Navigator | ef506c418b8c2e6498ece6dcae67e583fb8a4a95 | 14d1b729b2cea52f726874687e78f17492949585 | refs/heads/master | 2021-01-16T20:53:37.630909 | 2010-06-28T09:51:10 | 2010-06-28T09:51:10 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,308 | cpp | /*
Copyright (c) 1999 - 2010, Vodafone Group Services Ltd
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* Neither the name of the Vodafone Group Services Ltd nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "gbFont.h"
#include <stdlib.h>
#include <string.h>
//--------------------------------------------------------------------------//
//
//--------------------------------------------------------------------------//
#define GB_FONT_CHAR_BEGIN 32
#define GB_FONT_CHAR_END 128
#define GB_FONT_CHAR_COUNT (GB_FONT_CHAR_END - GB_FONT_CHAR_BEGIN)
struct GBFont_s
{
GBBitmap* bitmap;
GBuint16* charStart;
GBuint16* charWidths;
};
//--------------------------------------------------------------------------//
//
//--------------------------------------------------------------------------//
static GBbool GBFont_init (GBFont* font);
static void GBFont_drawChar (GBFont* font, GBuint8 ind, GBint32* pos, const GBDisplayParams* displayParams);
//--------------------------------------------------------------------------//
//
//--------------------------------------------------------------------------//
GBFont* GBFont_create (GBBitmap* bitmap)
{
GBFont* font;
GB_ASSERT(bitmap);
font = (GBFont*)malloc(sizeof(GBFont));
if (!font)
return NULL;
font->bitmap = bitmap;
font->charStart = NULL;
font->charWidths = NULL;
if (!GBFont_init(font))
{
GBFont_destroy(font);
return NULL;
}
return font;
}
//--------------------------------------------------------------------------//
//
//--------------------------------------------------------------------------//
GBbool GBFont_init (GBFont* font)
{
GB_ASSERT(font);
font->charStart = (GBuint16*)malloc(sizeof(GBuint16) * GB_FONT_CHAR_COUNT);
if (!font->charStart)
return GB_FALSE;
font->charWidths = (GBuint16*)malloc(sizeof(GBuint16) * GB_FONT_CHAR_COUNT);
if (!font->charWidths)
return GB_FALSE;
{
GBuint16 i = 0;
GBuint16 x = 0;
GBuint16 width = 0;
GBuint16 start = 0;
GBuint16 count = GB_FONT_CHAR_COUNT;
while (count--)
{
GBuint8 c = 0;
do
{
x++;
width++;
c = font->bitmap->data[x * 3];
}
while (c == 0);
font->charStart[i] = start;
font->charWidths[i] = width;
start = x;
width = 0;
i++;
}
}
return GB_TRUE;
}
//--------------------------------------------------------------------------//
//
//--------------------------------------------------------------------------//
void GBFont_destroy (GBFont* font)
{
GB_ASSERT(font);
free(font->charWidths);
free(font->charStart);
free(font);
}
//--------------------------------------------------------------------------//
//
//--------------------------------------------------------------------------//
void GBFont_drawChar (GBFont* font, GBuint8 ind, GBint32* pos, const GBDisplayParams* displayParams)
{
GBuint32 y;
GBuint32 height;
GB_ASSERT(font && pos && displayParams);
if (ind == 0)
return;
height = font->bitmap->height - 1;
for (y = 0; y < height; y++)
{
if (y + pos[1] >= 0 && y + pos[1] < displayParams->height)
{
GBuint8* src;
GBOutputFormat* tgt = (GBOutputFormat*)displayParams->buffer + (pos[0] + displayParams->x + (y + pos[1] + displayParams->y) * displayParams->bufferWidth);
GBuint16 x;
GBuint16 width;
width = font->charWidths[ind];
src = font->bitmap->data + ((y + 1) * font->bitmap->width + font->charStart[ind]) * 3;
for (x = 0; x < width; x++)
{
if (x + pos[0] >= (GBint32)displayParams->width)
break;
if (x + pos[0] >= 0)
{
GBuint8 l = src[0];
if (l != 0)
{
#if defined(GB_PIXELFORMAT_888)
*tgt = (l << 16) | (l << 8) | l;
#elif defined(GB_PIXELFORMAT_444)
l >>= 4;
*tgt = (l << 8) | (l << 4) | l;
#elif defined(GB_PIXELFORMAT_565)
*tgt = ((l << 8) & 0xf800) | ((l << 3) & 0x7e0) | (l >> 3);
#endif
}
}
src += 3;
tgt++;
}
}
}
}
//--------------------------------------------------------------------------//
//
//--------------------------------------------------------------------------//
void GBFont_drawText (GBFont* font, const char* text, GBint32 x, GBint32 y, const GBDisplayParams* displayParams)
{
GBuint32 i;
GBuint32 len;
GBint32 p[2];
GB_ASSERT(font && text && displayParams);
len = gbStrLength(text);
p[0] = x;
p[1] = y;
for (i = 0; i < len; i++)
{
GBuint8 c = text[i];
if (c >= GB_FONT_CHAR_BEGIN && c < GB_FONT_CHAR_END)
{
GBFont_drawChar(font, c - GB_FONT_CHAR_BEGIN, p, displayParams);
p[0] += font->charWidths[c - GB_FONT_CHAR_BEGIN];
}
}
}
//--------------------------------------------------------------------------//
//
//--------------------------------------------------------------------------//
void GBFont_drawClippedText (GBFont* font, const char* text, GBint32 x, GBint32 y, const GBDisplayParams* displayParams)
{
GBint32 maxWidth;
GBint32 dotWidth;
GBuint32 i;
GBuint32 len;
GBint32 p[2];
GB_ASSERT(font && text && displayParams);
len = gbStrLength(text);
p[0] = x;
p[1] = y;
maxWidth = displayParams->width - x;
dotWidth = font->charWidths['.' - GB_FONT_CHAR_BEGIN];
maxWidth -= dotWidth * 3;
for (i = 0; i < len; i++)
{
GBuint8 c = text[i];
if (c >= GB_FONT_CHAR_BEGIN && c < GB_FONT_CHAR_END)
{
GBint32 w = font->charWidths[c - GB_FONT_CHAR_BEGIN];
maxWidth -= w;
if (maxWidth <= 0)
break;
GBFont_drawChar(font, c - GB_FONT_CHAR_BEGIN, p, displayParams);
p[0] += w;
}
}
if (maxWidth <= 0)
{
GBFont_drawChar(font, '.' - GB_FONT_CHAR_BEGIN, p, displayParams);
p[0] += dotWidth;
GBFont_drawChar(font, '.' - GB_FONT_CHAR_BEGIN, p, displayParams);
p[0] += dotWidth;
GBFont_drawChar(font, '.' - GB_FONT_CHAR_BEGIN, p, displayParams);
}
}
//--------------------------------------------------------------------------//
//
//--------------------------------------------------------------------------//
GBuint32 GBFont_getTextWidth (GBFont* font, const char* text)
{
GBuint32 i;
GBuint32 len;
GBuint32 width = 0;
GB_ASSERT(font && text);
len = gbStrLength(text);
for (i = 0; i < len; i++)
{
GBuint8 c = text[i];
if (c >= GB_FONT_CHAR_BEGIN && c < GB_FONT_CHAR_END)
width += font->charWidths[c - GB_FONT_CHAR_BEGIN];
}
return width;
}
//--------------------------------------------------------------------------//
//
//--------------------------------------------------------------------------//
GBuint32 GBFont_getHeight (GBFont* font)
{
GB_ASSERT(font);
return font->bitmap->height;
}
//--------------------------------------------------------------------------//
//
//--------------------------------------------------------------------------//
| [
"[email protected]"
]
| [
[
[
1,
288
]
]
]
|
a333af1d585320af0c6ddc93f036e7f936c40d8d | 5d36f6102c8cadcf1a124b366ae189d6a2609c59 | /src/Qt/psx4cute/viewcontroller.cpp | 9916e75f49cee0ce0dde1a743264e5426be82c2f | []
| no_license | Devil084/psx4all | 336f2861246367c8d397ef5acfc0b7972085c21b | 04c02bf8840007792d23d15ca42a572035a1d703 | refs/heads/master | 2020-02-26T15:18:04.554046 | 2010-08-11T13:49:24 | 2010-08-11T13:49:24 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,265 | cpp | /* psx4cute
*
* Copyright (C) 2010 Summeli <[email protected]>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "viewcontroller.h"
#include "cuteDebug.h"
// Needed Symbian specific headers
#ifdef Q_OS_SYMBIAN
#include <eikenv.h>
#include <eikappui.h>
#include <aknenv.h>
#include <aknappui.h>
#include <e32keys.h>
#endif
ViewController::ViewController()
{
#if defined(Q_OS_SYMBIAN)
CAknAppUi* appUi = dynamic_cast<CAknAppUi*> (CEikonEnv::Static()->AppUi());
TRAPD(error,
if (appUi) {
// Lock application orientation into landscape
appUi->SetOrientationL(CAknAppUi::EAppUiOrientationLandscape);
appUi->SetKeyEventFlags(CAknAppUi::EDisableSendKeyShort|CAknAppUi::EDisableSendKeyLong);
}
);
iMenuKeyHandle = CEikonEnv::Static()->RootWin().CaptureKeyUpAndDowns(EStdKeyMenu, 0, 0);
iMenuKeyHandle2 = CEikonEnv::Static()->RootWin().CaptureKeyUpAndDowns(EStdKeyApplication0, 0, 0);
iNoKeyHandle = CEikonEnv::Static()->RootWin().CaptureKeyUpAndDowns(EStdKeyNo, 0, 0);
iNoKeyHandle2 = CEikonEnv::Static()->RootWin().CaptureKey( EKeyNo, 0, 0 );
iCameraKeyHandle = CEikonEnv::Static()->RootWin().CaptureKey( EKeyDevice7, 0, 0 );
#endif
remotekeys = new QRemoteControlKeys();
emuView = new psx4Qt();
emuView->setRemoteControl( remotekeys );
emuView->hide();
settingsView = new EmuSettings();
settingsView->setRemoteControl( remotekeys );
settingsView->show();
connect(settingsView, SIGNAL(LoadROM( QString,TPsxSettings)), this, SLOT(loadROM( QString,TPsxSettings)));
connect(settingsView, SIGNAL(LoadState( int )), this, SLOT(LoadState( int )));
connect(settingsView, SIGNAL(SaveState( int )), this, SLOT(SaveState( int )));
connect(settingsView, SIGNAL(resetGame()), this, SLOT(reset()));
connect(settingsView, SIGNAL(continueGame()), this, SLOT(continueGame()));
connect(settingsView, SIGNAL(updateSettings(TPsxSettings)), emuView, SLOT(updateSettings(TPsxSettings)));
connect(emuView, SIGNAL(showmenu()), this, SLOT(showSettings()));
}
ViewController::~ViewController()
{
delete remotekeys;
delete settingsView;
delete emuView;
#if defined(Q_OS_SYMBIAN)
CEikonEnv::Static()->RootWin().CancelCaptureKeyUpAndDowns(iMenuKeyHandle);
CEikonEnv::Static()->RootWin().CancelCaptureKeyUpAndDowns(iMenuKeyHandle2);
CEikonEnv::Static()->RootWin().CancelCaptureKeyUpAndDowns(iNoKeyHandle);
CEikonEnv::Static()->RootWin().CancelCaptureKey(iCameraKeyHandle);
CEikonEnv::Static()->RootWin().CancelCaptureKey(iNoKeyHandle2);
#endif
}
void ViewController::loadROM( QString rom, TPsxSettings antSettings )
{
__DEBUG_IN
settingsView->hide();
emuView->show();
emuView->LoadROM( rom, antSettings );
__DEBUG_OUT
}
void ViewController::showSettings()
{
emuView->hide();
settingsView->show();
}
void ViewController::LoadState( int state )
{
__DEBUG_IN
settingsView->hide();
emuView->show();
emuView->LoadState( state );
__DEBUG_OUT
}
void ViewController::SaveState( int state )
{
__DEBUG_IN
settingsView->hide();
emuView->show();
emuView->SaveState( state );
__DEBUG_OUT
}
void ViewController::reset()
{
__DEBUG_IN
settingsView->hide();
emuView->show();
emuView->reset();
__DEBUG_OUT
}
void ViewController::continueGame()
{
__DEBUG_IN
settingsView->hide();
emuView->show();
emuView->continueGame();
__DEBUG_OUT
}
| [
"[email protected]"
]
| [
[
[
1,
147
]
]
]
|
9d51e49b5f79e79781ba86c9dc0830d398863c93 | 25fd79ea3a1f2c552388420c5a02433d9cdf855d | /Pool/Billiards/Billiards.h | 672615e299ddc9ba13e26b703b52a97593254b3e | []
| no_license | k-l-lambda/klspool | 084cbe99a1dc3b9703233fccea3f2f6570df9d63 | b57703169828f9d406e7d0a6cd326063832b12c6 | refs/heads/master | 2021-01-23T07:03:59.086914 | 2009-09-06T09:14:51 | 2009-09-06T09:14:51 | 32,123,777 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,080 | h | /*
** This source file is part of Pool.
**
** Copyright (c) 2009 K.L.<[email protected]>, Lazy<[email protected]>
** This program is free software without any warranty.
*/
#ifndef __BILLIARDS_H__
#define __BILLIARDS_H__
// compiling options
#define ENABLE_LUASYMBOLS_EXPORT
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4710) // 'function' : function not inlined
# pragma warning(disable: 4711) // function 'function' selected for inline expansion
#endif
/*#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable: 4820) // 'bytes' bytes padding added after construct 'member_name'
# include <wchar.h>
# pragma warning(pop)
#endif*/
#include <vector>
#if _MSC_VER == 1400 // tolerant warnings
# pragma warning(push)
# pragma warning(disable: 4510) // 'class' : default constructor could not be generated
# pragma warning(disable: 4571) // Informational: catch(...) semantics changed since Visual C++ 7.1; structured exceptions (SEH) are no longer caught
# pragma warning(disable: 4610) // object 'class' can never be instantiated - user-defined constructor required
# pragma warning(disable: 4820) // 'bytes' bytes padding added after construct 'member_name'
#endif // _MSC_VER == 1400
#include <list>
#if _MSC_VER == 1400
# pragma warning(pop)
#endif // _MSC_VER == 1400
#include <set>
#include <map>
#include <stack>
#include <fstream>
#include <sstream>
#include <iostream>
#ifdef _MSC_VER
# pragma warning(push, 1)
#endif
#include <boost\shared_ptr.hpp>
#include <boost\function.hpp>
#ifdef _MSC_VER
# pragma warning(pop)
#endif
#ifdef _MSC_VER
# pragma warning(pop)
#endif
// Havok declarations
class hkpPhysicsContext;
class hkpRigidBody;
class hkpWorld;
class hkJobThreadPool;
class hkJobQueue;
class hkPoolMemory;
class hkThreadMemory;
class hkVisualDebugger;
template <typename T> class hkArray;
typedef boost::shared_ptr<hkpRigidBody> hkpRigidBodyPtr;
#ifdef _BILLIARDSDLL
# define BILLIARDS_API __declspec(dllexport)
#else
# define BILLIARDS_API __declspec(dllimport)
#endif // defined(_BILLIARDSDLL)
#include "MathDef.h"
#ifdef ENABLE_LUASYMBOLS_EXPORT
struct lua_State;
#endif // defined(ENABLE_LUASYMBOLS_EXPORT)
namespace Billiards
{
class Ball;
class Game;
class HavokSystem;
class HolePhantom;
struct BallConfig;
struct BallConfigSet;
struct GameLayout;
struct IVisualObject;
struct VisualObjectParameters;
typedef boost::shared_ptr<const Ball> ConstBallPtr;
typedef boost::shared_ptr<Ball> BallPtr;
typedef boost::shared_ptr<IVisualObject> VisualObjectPtr;
typedef boost::shared_ptr<HolePhantom> HolePhantomPtr;
typedef boost::function<VisualObjectPtr (const VisualObjectParameters&)> VisualObjectCreationFunctor;
#ifdef ENABLE_LUASYMBOLS_EXPORT
extern "C" BILLIARDS_API int registerLuaSymbols(lua_State* L);
#endif // defined(ENABLE_LUASYMBOLS_EXPORT)
}
#endif // !defined(__BILLIARDS_H__)
| [
"xxxK.L.xxx@64c72148-2b1e-11de-874f-bb9810f3bc79",
"[email protected]@64c72148-2b1e-11de-874f-bb9810f3bc79"
]
| [
[
[
1,
28
],
[
31,
44
],
[
50,
97
],
[
99,
106
],
[
108,
108
],
[
110,
116
],
[
118,
120
]
],
[
[
29,
30
],
[
45,
49
],
[
98,
98
],
[
107,
107
],
[
109,
109
],
[
117,
117
]
]
]
|
07f56c888b80c957fb621b78edf3c48548a5d473 | c95a83e1a741b8c0eb810dd018d91060e5872dd8 | /Game/ObjectDLL/ObjectShared/AIGoalAbstractUseObject.cpp | 761d6372e82cd0a4a0a5f55b526ca0c2a79fd3e6 | []
| no_license | rickyharis39/nolf2 | ba0b56e2abb076e60d97fc7a2a8ee7be4394266c | 0da0603dc961e73ac734ff365bfbfb8abb9b9b04 | refs/heads/master | 2021-01-01T17:21:00.678517 | 2011-07-23T12:11:19 | 2011-07-23T12:11:19 | 38,495,312 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 17,810 | cpp | // ----------------------------------------------------------------------- //
//
// MODULE : AIGoalAbstractUseObject.cpp
//
// PURPOSE : AIGoalAbstractUseObject implementation
//
// CREATED : 10/26/01
//
// (c) 2001 Monolith Productions, Inc. All Rights Reserved
// ----------------------------------------------------------------------- //
#include "stdafx.h"
#include "AIGoalAbstractUseObject.h"
#include "AISenseRecorderAbstract.h"
#include "AIHumanState.h"
#include "AINode.h"
#include "AINodeMgr.h"
#include "AIGoalMgr.h"
#include "AIGoalButeMgr.h"
#include "AIHuman.h"
#include "AIUtils.h"
// ----------------------------------------------------------------------- //
//
// ROUTINE: CAIGoalAbstractUseObject::Con/destructor
//
// PURPOSE: Factory Con/destructor
//
// ----------------------------------------------------------------------- //
CAIGoalAbstractUseObject::CAIGoalAbstractUseObject()
{
m_fStimTime = LTNULL;
m_bRequireBareHands = LTFALSE;
m_bAllowDialogue = LTFALSE;
m_bTurnOnLights = LTFALSE;
m_bTurnOffLights = LTFALSE;
m_bHolstered = LTFALSE;
m_bLockedNode = LTFALSE;
m_bPlayedSpecialDeathAnim = LTFALSE;
m_eWeaponPosition = kAP_Down;
}
//----------------------------------------------------------------------------
//
// ROUTINE: CAIGoalAbstractUseObject::~CAIGoalAbstractUseObject()
//
// PURPOSE: Clean up any node locks still left active.
//
//----------------------------------------------------------------------------
/*virtual*/ CAIGoalAbstractUseObject::~CAIGoalAbstractUseObject()
{
if ( m_hNodeUseObject && m_bLockedNode )
{
AINodeUseObject* pNodeUseObject = (AINodeUseObject*)g_pLTServer->HandleToObject(m_hNodeUseObject);
AIASSERT( pNodeUseObject && pNodeUseObject->IsLocked(), m_pAI->m_hObject, "CAIGoalAbstractUseObject::DeactivateGoal: Node is NULL or not locked" );
if( pNodeUseObject )
{
pNodeUseObject->Unlock( m_pAI->m_hObject );
}
}
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CAIGoalAbstractUseObject::Save / Load
//
// PURPOSE: Save / Load
//
// ----------------------------------------------------------------------- //
void CAIGoalAbstractUseObject::Save(ILTMessage_Write *pMsg)
{
super::Save(pMsg);
SAVE_HOBJECT(m_hNodeUseObject);
SAVE_HOBJECT(m_hLastNodeUseObject);
SAVE_TIME(m_fStimTime);
SAVE_DWORD(m_eWeaponPosition);
SAVE_BOOL(m_bRequireBareHands);
SAVE_BOOL(m_bAllowDialogue);
SAVE_BOOL(m_bTurnOnLights);
SAVE_BOOL(m_bTurnOffLights);
SAVE_BOOL(m_bHolstered);
SAVE_BOOL(m_bLockedNode);
SAVE_BOOL(m_bPlayedSpecialDeathAnim);
}
void CAIGoalAbstractUseObject::Load(ILTMessage_Read *pMsg)
{
super::Load(pMsg);
LOAD_HOBJECT(m_hNodeUseObject);
LOAD_HOBJECT(m_hLastNodeUseObject);
LOAD_TIME(m_fStimTime);
LOAD_DWORD_CAST(m_eWeaponPosition, EnumAnimProp);
LOAD_BOOL(m_bRequireBareHands);
LOAD_BOOL(m_bAllowDialogue);
LOAD_BOOL(m_bTurnOnLights);
LOAD_BOOL(m_bTurnOffLights);
LOAD_BOOL(m_bHolstered);
LOAD_BOOL(m_bLockedNode);
LOAD_BOOL(m_bPlayedSpecialDeathAnim);
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CAIGoalAbstractUseObject::ActivateGoal
//
// PURPOSE: Activate goal.
//
// ----------------------------------------------------------------------- //
void CAIGoalAbstractUseObject::ActivateGoal()
{
super::ActivateGoal();
AIASSERT(m_hNodeUseObject != LTNULL, m_pAI->m_hObject, "CAIGoalAbstractUseObject::ActivateGoal: AINodeUseObject is NULL.");
m_bHolstered = LTFALSE;
AINodeUseObject* pNodeUseObject = (AINodeUseObject*)g_pLTServer->HandleToObject(m_hNodeUseObject);
AIASSERT( pNodeUseObject, m_pAI->m_hObject, "CAIGoalAbstractUseObject::ActivateGoal: AINodeUseObject is NULL.");
// If the node was locked by someone else, bail.
if( ( !pNodeUseObject ) || ( pNodeUseObject->IsLockedDisabledOrTimedOut() ) )
{
CompleteUseObject();
return;
}
// Lock the node during the entire duration of the goal.
// This includes time spent holstering and drawing weapons.
if( pNodeUseObject )
{
pNodeUseObject->Lock( m_pAI->m_hObject );
m_bLockedNode = LTTRUE;
}
m_pGoalMgr->LockGoal(this);
SetStateUseObject();
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CAIGoalAbstractUseObject::SetStateUseObject
//
// PURPOSE: Set state to UseObject.
//
// ----------------------------------------------------------------------- //
EnumAIStateType CAIGoalAbstractUseObject::GetUseObjectState()
{
return kState_HumanUseObject;
}
void CAIGoalAbstractUseObject::SetStateUseObject()
{
m_pAI->SetState( GetUseObjectState() );
AINodeUseObject* pNodeUseObject = (AINodeUseObject*)g_pLTServer->HandleToObject(m_hNodeUseObject);
if( !pNodeUseObject )
{
AIASSERT( NULL, m_pAI->m_hObject, "CAIGoalAbstractUseObject::SetStateUseObject: AINodeUseObject is NULL.");
return;
}
CAIHumanStateUseObject* pStateUseObject = (CAIHumanStateUseObject*)(m_pAI->GetState());
pStateUseObject->StateHandlesNodeLocking( LTFALSE );
// Bail if there is any problem setting the node.
if( !pStateUseObject->SetNode(pNodeUseObject) )
{
AITRACE(AIShowGoals, ( m_pAI->m_hObject, "Unable to set UseObject node %s.", ::ToString( pNodeUseObject->GetName() ) ) );
m_hLastNodeUseObject = pNodeUseObject->m_hObject;
CompleteUseObject();
return;
}
pStateUseObject->SetWeaponPosition(m_eWeaponPosition);
pStateUseObject->SetRequireBareHands( m_bRequireBareHands );
pStateUseObject->SetAllowDialogue(m_bAllowDialogue);
pStateUseObject->TurnOnLights( m_bTurnOnLights );
pStateUseObject->TurnOffLights( m_bTurnOffLights );
// Find command string for AINodeType matching UseObject.
AIGBM_GoalTemplate* pTemplate = g_pAIGoalButeMgr->GetTemplate( GetGoalType() );
AIASSERT(pTemplate->cAttractors > 0, m_pAI->m_hObject, "CAIGoalAbstractUseObject::ActivateGoal: Goal has no attractors.");
HSTRING hstrCmd;
for(uint32 iAttractor=0; iAttractor < pTemplate->cAttractors; ++iAttractor)
{
hstrCmd = pNodeUseObject->GetSmartObjectCommand(pTemplate->aAttractors[iAttractor]);
if(hstrCmd != LTNULL)
{
pStateUseObject->SetSmartObjectCommand(hstrCmd);
break;
}
}
// Ensure that node is setup to be requested type of attractor.
if( !hstrCmd )
{
AIASSERT( 0, m_pAI->m_hObject, "CAIGoalAbstractUseObject::ActivateGoal: No command string found for attractors.");
m_fCurImportance = 0.f;
}
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CAIGoalAbstractUseObject::DeactivateGoal
//
// PURPOSE: Deactivate goal.
//
// ----------------------------------------------------------------------- //
void CAIGoalAbstractUseObject::DeactivateGoal()
{
super::DeactivateGoal();
// Unlock the node after the entire duration of the goal.
// This includes time spent holstering and drawing weapons.
AINodeUseObject* pNodeUseObject = (AINodeUseObject*)g_pLTServer->HandleToObject(m_hNodeUseObject);
AIASSERT( pNodeUseObject && pNodeUseObject->IsLocked(), m_pAI->m_hObject, "CAIGoalAbstractUseObject::DeactivateGoal: Node is NULL or not locked" );
if( m_bLockedNode && pNodeUseObject )
{
pNodeUseObject->Unlock( m_pAI->m_hObject );
m_bLockedNode = LTFALSE;
}
// If we get drawn away to do something else, forget about
// the node, so that we will search again from where ever we
// end up.
// Do not set m_hLastNodeUseObject, because we may not
// have finished using the object.
ClearUseObjectNode();
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CAIGoalAbstractUseObject::DeactivateGoal
//
// PURPOSE: Deactivate goal.
//
// ----------------------------------------------------------------------- //
void CAIGoalAbstractUseObject::ClearUseObjectNode()
{
// If there is no node, then importance MUST be zero.
m_hNodeUseObject = LTNULL;
m_fCurImportance = 0.f;
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CAIGoalAbstractUseObject::UpdateGoal
//
// PURPOSE: Update goal.
//
// ----------------------------------------------------------------------- //
void CAIGoalAbstractUseObject::UpdateGoal()
{
CAIState* pState = m_pAI->GetState();
switch(pState->GetStateType())
{
case kState_HumanHolster:
HandleStateHolster();
break;
case kState_HumanUseObject:
HandleStateUseObject();
break;
case kState_HumanIdle:
if( !m_pAI->GetAnimationContext()->IsTransitioning() )
{
/*
if( m_bHolstered )
{
m_pAI->SetState( kState_HumanDraw );
m_pAI->GetState()->PlayFirstSound( LTFALSE );
}
else {
CompleteUseObject();
}
*/
CompleteUseObject();
}
break;
case kState_HumanDraw:
HandleStateDraw();
break;
// Unexpected State.
default: ASSERT(!"CAIGoalAbstractUseObject::UpdateGoal: Unexpected State.");
}
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CAIGoalAbstractUseObject::HandleStateHolster
//
// PURPOSE: Determine what to do when in state Holster.
//
// ----------------------------------------------------------------------- //
void CAIGoalAbstractUseObject::HandleStateHolster()
{
switch( m_pAI->GetState()->GetStateStatus() )
{
case kSStat_Initialized:
break;
case kSStat_FailedComplete:
AIASSERT( 0, m_pAI->m_hObject, "CAIGoalAbstractUseObject::HandleStateHolster: Failed to holster weapon." );
m_fCurImportance = 0.f;
break;
case kSStat_StateComplete:
SetStateUseObject();
break;
// Unexpected StateStatus.
default: ASSERT(!"CAIGoalAbstractUseObject::HandleStateHolster: Unexpected State Status.");
}
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CAIGoalAbstractUseObject::HandleStateDraw
//
// PURPOSE: Determine what to do when in state Draw.
//
// ----------------------------------------------------------------------- //
void CAIGoalAbstractUseObject::HandleStateDraw()
{
switch( m_pAI->GetState()->GetStateStatus() )
{
case kSStat_Initialized:
break;
case kSStat_FailedComplete:
CompleteUseObject();
break;
case kSStat_StateComplete:
CompleteUseObject();
break;
// Unexpected StateStatus.
default: AIASSERT(0, m_pAI->m_hObject, "CAIGoalAbstractUseObject::HandleStateDraw: Unexpected State Status.");
}
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CAIGoalAbstractUseObject::HandleStateUseObject
//
// PURPOSE: Determine what to do when in state UseObject.
//
// ----------------------------------------------------------------------- //
void CAIGoalAbstractUseObject::HandleStateUseObject()
{
switch( m_pAI->GetState()->GetStateStatus() )
{
case kSStat_Initialized:
break;
case kSStat_Waiting:
break;
case kSStat_Moving:
break;
case kSStat_HolsterWeapon:
m_bHolstered = LTTRUE;
m_pAI->SetState( kState_HumanHolster );
break;
case kSStat_PathComplete:
break;
case kSStat_StateComplete:
{
// Stand up.
CAIHumanState* pState = (CAIHumanState*)(m_pAI->GetState());
pState->SetPose( kAP_Stand );
// Go to idle, to ensure playing a xxx_out transition animation.
// (Transitions are not played for locked animations).
m_pAI->SetState( kState_HumanIdle );
}
break;
// Unexpected StateStatus.
default: ASSERT(!"CAIGoalAbstractUseObject::HandleStateAbstractUseObject: Unexpected State Status.");
}
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CAIGoalAbstractUseObject::CompleteUseObject
//
// PURPOSE: Wrap up the goal.
//
// ----------------------------------------------------------------------- //
void CAIGoalAbstractUseObject::CompleteUseObject()
{
// Do not allow the AI to immediately start using the same
// node again, if the node does not have a reactivation time.
AINodeUseObject* pNodeUseObject = (AINodeUseObject*)g_pLTServer->HandleToObject(m_hNodeUseObject);
if( pNodeUseObject && ( pNodeUseObject->GetNodeReactivationTime() == 0.f ) )
{
m_hLastNodeUseObject = m_hNodeUseObject;
}
m_fCurImportance = 0.f;
m_pGoalMgr->UnlockGoal(this);
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CAIGoalAbstractUseObject::GetAlternateDeathAnimation
//
// PURPOSE: Give goal a chance to choose an appropriate death animation.
//
// ----------------------------------------------------------------------- //
HMODELANIM CAIGoalAbstractUseObject::GetAlternateDeathAnimation()
{
// Were killed in the middle of an activity?
// jrg - 7/29/02 - don't count the activity if we haven't fully transitioned yet.
if( ( m_pAI->GetState()->GetStateType() == kState_HumanUseObject ) &&
( m_pAI->GetState()->GetStateStatus() == kSStat_PathComplete ) &&
(!m_pAI->GetAnimationContext()->IsTransitioning()) )
{
CAIHumanStateUseObject* pStateUseObject = (CAIHumanStateUseObject*)m_pAI->GetState();
EnumAnimProp eActivity = pStateUseObject->GetActivity();
CAIHuman* pAIHuman = (CAIHuman*)m_pAI;
CAnimationProps animProps;
animProps.Set( kAPG_Posture, pStateUseObject->GetPose() );
animProps.Set( kAPG_Weapon, pAIHuman->GetCurrentWeaponProp() );
animProps.Set( kAPG_WeaponPosition, kAP_Lower );
animProps.Set( kAPG_Awareness, eActivity );
animProps.Set( kAPG_Action, kAP_Death );
// Find a death animation for this activity.
if( m_pAI->GetAnimationContext()->AnimationExists( animProps ))
{
m_bPlayedSpecialDeathAnim = LTTRUE;
return m_pAI->GetAnimationContext()->GetAni( animProps );
}
}
// No alternate.
return INVALID_ANI;
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CAIGoalAbstractUseObject::HandleGoalAttractors
//
// PURPOSE: React to an attractor.
//
// ----------------------------------------------------------------------- //
AINode* CAIGoalAbstractUseObject::HandleGoalAttractors()
{
// Do not search for attractors if goal is already active.
// Do not search on first update, to allow commands a chance to disable nodes.
// Do not search if AI has any damage flags set (e.g. sleeping damage).
if( m_pGoalMgr->IsCurGoal(this) ||
m_pAI->IsFirstUpdate() ||
m_pAI->GetDamageFlags() )
{
return LTNULL;
}
// If this goal reacts to stimulus, check if it has been too
// long since stimulation.
AIGBM_GoalTemplate* pTemplate = g_pAIGoalButeMgr->GetTemplate( GetGoalType() );
if( ( pTemplate->flagSenseTriggers != kSense_None )
&& ( !m_hStimulusSource ) )
{
return LTNULL;
}
// Lock the last UseObject node, so that we don't try to use it again.
BlockAttractorNodeFromSearch( m_hLastNodeUseObject );
// Find the nearest attractor.
AINode* pNode = FindNearestAttractorNode();
if(pNode != LTNULL)
{
AIASSERT(pNode->GetType() == kNode_UseObject, m_pAI->m_hObject, "CAIGoalAbstractUseObject::HandleGoalAttractors: AINode is not of type UseObject.");
AINodeUseObject* pNodeUseObject = (AINodeUseObject*)pNode;
if( pNodeUseObject->HasObject() && !pNodeUseObject->GetHObject() )
{
pNode = LTNULL;
m_fCurImportance = 0.f;
AIASSERT( 0, pNodeUseObject->m_hObject, "CAIGoalAbstractUseObject::HandleGoalAttractors: AINodeUseObject points to invalid object" );
}
else if( pNodeUseObject->IsOneWay() && ( pNodeUseObject->GetForward().Dot( m_pAI->GetForwardVector() ) < 0.0f ) )
{
pNode = LTNULL;
m_fCurImportance = 0.f;
}
else {
AITRACE(AIShowGoals, ( m_pAI->m_hObject, "Setting node: %s", ::ToString( pNode->GetName() ) ) );
m_hNodeUseObject = pNode->m_hObject;
SetCurToBaseImportance();
}
}
if( !pNode )
{
ClearUseObjectNode();
m_hStimulusSource = LTNULL;
}
// If we locked a node prior to the search, unlock it.
UnblockAttractorNodeFromSearch( m_hLastNodeUseObject );
return pNode;
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CAIGoalAbstractUseObject::FindNearestAttractorNode
//
// PURPOSE: Find attractor node.
//
// ----------------------------------------------------------------------- //
AINode* CAIGoalAbstractUseObject::FindNearestAttractorNode()
{
// Do not use UseObject nodes while AI owns a talk node (and has a Talk goal).
if( g_pAINodeMgr->FindOwnedNode( kNode_Talk, m_pAI->m_hObject ) )
{
return LTNULL;
}
// Find a guard node owned by this AI.
AINode* pGuardNode = g_pAINodeMgr->FindOwnedNode( kNode_Guard, m_pAI->m_hObject );
if( pGuardNode )
{
// Only find attractor nodes owned by the owner node.
return FindGoalAttractors( LTTRUE, pGuardNode->m_hObject );
}
// Find an unowned node.
return FindGoalAttractors( LTFALSE, LTNULL );
}
// ----------------------------------------------------------------------- //
//
// ROUTINE: CAIGoalAbstractUseObject::HandleSense
//
// PURPOSE: React to a sense.
//
// ----------------------------------------------------------------------- //
LTBOOL CAIGoalAbstractUseObject::HandleGoalSenseTrigger(AISenseRecord* pSenseRecord)
{
if( super::HandleGoalSenseTrigger(pSenseRecord) )
{
m_fStimTime = g_pLTServer->GetTime();
}
// Always return false, and let the attractor handle activation.
return LTFALSE;
}
| [
"[email protected]"
]
| [
[
[
1,
605
]
]
]
|
c6c76e5f66c43094e2edcd18845bb4f360a694c0 | bdec684af41a89175c2dffe95dda9ab565913118 | /CNP-digger/DlgCreatePatient.h | 2705c40ed93a71439994ca2be284b518532a052d | []
| no_license | laurdimana/cnp-digger | 3608afd24b5e8d2cffefd5c9766696a3ea5ea506 | f15c89b0734a803ddaa7956abe501a2324070399 | refs/heads/master | 2020-05-04T14:37:10.774333 | 2011-08-21T14:40:18 | 2011-08-21T14:40:18 | 33,174,630 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 690 | h | #pragma once
#include "resource.h"
class CDlgCreatePatient : public CDialogEx
{
public:
CDlgCreatePatient( CString strCNP = L"" );
virtual ~CDlgCreatePatient();
// Dialog Data
enum { IDD = IDD_CREATE_PATIENT };
protected:
virtual void DoDataExchange( CDataExchange* pDX ); // DDX/DDV support
virtual BOOL OnInitDialog();
public:
CString GetCNP();
CString GetLastName();
CString GetFirstName();
CString GetCity();
protected:
CButton m_btnOK,
m_btnCancel;
CComboBox m_cmbCity;
CString m_strCNP,
m_strLastName,
m_strFirstName,
m_strCity;
// Implementation
protected:
afx_msg void OnBtnOK();
DECLARE_MESSAGE_MAP()
}; | [
"[email protected]@e5df85e2-01b0-9024-d18a-d63b7c2566ab"
]
| [
[
[
1,
40
]
]
]
|
00bf3e3bb6f09471878f0cb732712e8651938797 | 971b000b9e6c4bf91d28f3723923a678520f5bcf | /PaperSizeScroll/_snip_pieces/xsl-fo_open/srcm/scene/GraphicsScene.h | ef7b230b7a896d80d6df5641b4567fa483c1eec2 | []
| no_license | google-code-export/fop-miniscribus | 14ce53d21893ce1821386a94d42485ee0465121f | 966a9ca7097268c18e690aa0ea4b24b308475af9 | refs/heads/master | 2020-12-24T17:08:51.551987 | 2011-09-02T07:55:05 | 2011-09-02T07:55:05 | 32,133,292 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,050 | h | #ifndef GRAPHICSSCENE_H
#define GRAPHICSSCENE_H
static const int ObjectNameEditor = 400; /* normal layer div */
static const int InitTopPosition = 22; /* scene initfrom top Y*/
static const int RectoSceneBottomFooterSpace = 70; /* border bottom footer */
static const int InterSpacingFromAutoFloatLayerElements = 5;
static const int ObjectNameController = 300; /* element button on scene */
static const int HeaderAndFooterHightSpace = RectoSceneBottomFooterSpace + InitTopPosition;
static const int ObyektSortingTimeline = 500; /* display page order... */
#define _DEBUGRANGE_WI_ 10 /* begin draw on scene X position */
static const int DefaultPrintBorder = 1; /* default printer border noprint 1% */
#include <QRectF>
#include <QGraphicsScene>
#include <QLabel>
#include <QPixmap>
#include <QSize>
#include <QPrinter>
#include <QtCore>
#include <QDebug>
#include <QCoreApplication>
#include <QObject>
#include <QApplication>
#include <QPainter>
#include <QGraphicsItem>
#include "SessionManager.h"
static inline QRectF Reduce( QRectF rect , const int percentual )
{
if (percentual < 1) {
return rect;
}
const int leave_wi = rect.width() * percentual / 100;
const int leave_hi = rect.height() * percentual / 100;
return QRectF(0,0,rect.width() - leave_wi, rect.height() - leave_hi);
/* use CenterRectSlaveFromMaster to fill on rect target */
}
static inline QRectF CenterRectSlaveFromMaster( const QRectF Master ,
QRectF Slave )
{
/* check if slave is to large for master? */
QRectF SlaveOnline = Slave.translated(Master.center());
const qreal wi = Slave.width() / 2;
const qreal hi = Slave.height() / 2;
SlaveOnline.translate( 0 - wi , 0 - hi );
return SlaveOnline;
}
class GraphicsScene : public QGraphicsScene
{
Q_OBJECT
public:
GraphicsScene( QObject * parent = 0 );
inline QGraphicsItem *Active() { return bridge; }
void clear();
int PrintPageSumm( QPrinter * printer );
void storno();
GraphicsScene( const QRectF & sceneRect, QObject * parent = 0 );
GraphicsScene( qreal x, qreal y, qreal width, qreal height, QObject * parent = 0 );
void setSceneRect( qreal x, qreal y, qreal w, qreal h );
void setSceneRect( const QRectF & rect );
void clearSelection();
void paste( bool cloneornot = false );
qreal zmax();
qreal zmin();
void printPage(int index, int percentual , QPainter &painter, QPrinter * printer ); /* Preview and printer */
signals:
void SelectOn(QGraphicsItem*);
void LayerPaste(bool);
public slots:
void reload();
protected:
bool WakeUp( const QPointF incomming );
void mouseReleaseEvent( QGraphicsSceneMouseEvent * e );
void mousePressEvent( QGraphicsSceneMouseEvent * e );
void mouseDoubleClickEvent ( QGraphicsSceneMouseEvent * event );
QGraphicsItem *bridge;
};
//
#endif // GRAPHICSSCENE_H
| [
"ppkciz@9af58faf-7e3e-0410-b956-55d145112073"
]
| [
[
[
1,
129
]
]
]
|
7b4b6503e21e27ec92e6a369a5f9115cf0b92f83 | af96c6474835be2cc34ef21b0c2a45e950bb9148 | /media/libdrm/mobile2/include/util/domcore/ElementImpl.h | 2b0bc45a949fa07fc36aeb91641d33223f4d0a2a | [
"Apache-2.0",
"LicenseRef-scancode-unicode"
]
| permissive | zsol/android_frameworks_base | 86abe37fcd4136923cab2d6677e558826f087cf9 | 8d18426076382edaaea68392a0298d2c32cfa52e | refs/heads/donut | 2021-07-04T17:24:05.847586 | 2010-01-13T19:24:55 | 2010-01-13T19:24:55 | 469,422 | 14 | 12 | NOASSERTION | 2020-10-01T18:05:31 | 2010-01-12T21:20:20 | Java | UTF-8 | C++ | false | false | 6,394 | h | /*
* Copyright (C) 2007 The Android Open Source Project
*
* 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 __DOM_ELEMENT_IMPL__
#define __DOM_ELEMENT_IMPL__
#include "NodeImpl.h"
#include "NodeListImpl.h"
#include "NodeType.h"
class ElementImpl : public NodeImpl
{
public:
/**
* The name of the element. For example, in:
* <pre> <elementExample
* id="demo"> ... </elementExample> , </pre>
* <code>tagName</code> has
* the value <code>"elementExample"</code>. Note that this is
* case-preserving in XML, as are all of the operations of the DOM. The
* HTML DOM returns the <code>tagName</code> of an HTML element in the
* canonical uppercase form, regardless of the case in the source HTML
* document.
* @return the element's tag name.
*/
virtual const DOMString* getTagName() const;
/**
* Retrieves an attribute value by name.
* @param name The name of the attribute to retrieve.
* @return The <code>Attr</code> value as a string, or the empty string
* if that attribute does not have a specified or default value.
*/
virtual const DOMString* getAttribute(const DOMString* name) const;
/**
* Adds a new attribute. If an attribute with that name is already present
* in the element, its value is changed to be that of the value
* parameter. This value is a simple string; it is not parsed as it is
* being set. So any markup (such as syntax to be recognized as an
* entity reference) is treated as literal text, and needs to be
* appropriately escaped by the implementation when it is written out.
* In order to assign an attribute value that contains entity
* references, the user must create an <code>Attr</code> node plus any
* <code>Text</code> and <code>EntityReference</code> nodes, build the
* appropriate subtree, and use <code>setAttributeNode</code> to assign
* it as the value of an attribute.
* <br>To set an attribute with a qualified name and namespace URI, use
* the <code>setAttributeNS</code> method.
* @param name The name of the attribute to create or alter.
* @param value Value to set in string form.
* @exception DOMException
* INVALID_CHARACTER_ERR: Raised if the specified name contains an
* illegal character.
* <br>NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
*/
virtual void setAttribute(const DOMString* name, const DOMString* value) throw (DOMException);
/**
* Removes an attribute by name. If the removed attribute is known to have
* a default value, an attribute immediately appears containing the
* default value as well as the corresponding namespace URI, local name,
* and prefix when applicable.
* <br>To remove an attribute by local name and namespace URI, use the
* <code>removeAttributeNS</code> method.
* @param name The name of the attribute to remove.
* @exception DOMException
* NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
*/
virtual void removeAttribute(const DOMString* name) throw (DOMException);
/**
* Returns a <code>NodeList</code> of all descendant <code>Elements</code>
* with a given tag name, in the order in which they are encountered in
* a preorder traversal of this <code>Element</code> tree.
* @param name The name of the tag to match on. The special value "*"
* matches all tags.
* @return A list of matching <code>Element</code> nodes.
*/
NodeListImpl* getElementsByTagName(const DOMString* name) const;
/** Override getNodeType() method in NodeImpl.h.*/
virtual bool hasAttributes() const;
/** Override getNodeName() method in NodeImpl.h.*/
const DOMString* getNodeName() const;
/** Override getNodeType() method in NodeImpl.h.*/
NodeType getNodeType() const;
/** Defining "click()" method*/
virtual void click(){}
/** Defining "blur()" method,*/
virtual void blur(){}
/** Defining "focus()" method*/
virtual void focus(){}
/** Defining "change()" method*/
virtual void change(){}
/** Defining "select()" method*/
virtual void select(){}
/** Defining "onClick()" event input,textarea,button, and anchor*/
virtual bool onClick(){return true;}
/** Defining "onBlur()" event,for input,textarea,button,anchor and select */
virtual bool onBlur(){return true;}
/** Defining "onFocus()" event,for input,textarea,button,anchor and select*/
virtual bool onFocus(){return true;}
/** Defining "onChange()" event,for input,textarea and select tag*/
virtual bool onChange(){return true;}
/** Defining "onSelect()" event,for textarea and input*/
virtual bool onSelect(){return true;}
/**
* when the end tag of one element is found,this method would be called.The basic action is call seCompleted().
**/
virtual void endElement() {}
private:
/**
* Get elements whose name match on <code>name</code>,than keep they into <code>nodeList</code>.
* @param name The tag name of the elements to match on.
* @param nodeList keep all the matched element.
*/
void getElementsByTagName(const DOMString* name,NodeListImpl* nodeList) const;
};
#endif /*__DOM_ELEMENT_IMPL__*/
| [
"[email protected]"
]
| [
[
[
1,
147
]
]
]
|
111e20978add7b45c86f006711f33e26bb85995a | 5ed707de9f3de6044543886ea91bde39879bfae6 | /ASFootball/Shared/Source/ASFootballType.h | 82885c318ba68e94d8c598410de2a972bf93aabb | []
| no_license | grtvd/asifantasysports | 9e472632bedeec0f2d734aa798b7ff00148e7f19 | 76df32c77c76a76078152c77e582faa097f127a8 | refs/heads/master | 2020-03-19T02:25:23.901618 | 1999-12-31T16:00:00 | 2018-05-31T19:48:19 | 135,627,290 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 18,444 | h | /* ASFootballType.h */
/******************************************************************************/
/******************************************************************************/
#ifndef ASFootballTypeH
#define ASFootballTypeH
#include "ASFantasyType.h"
using namespace asfantasy;
namespace asfootball
{
/******************************************************************************/
#define MaxPassingTDBucs (6)
#define MaxRushingTDBucs (6)
#define MaxReceivingTDBucs (6)
#define MaxKickReturnTDBucs (6)
#define MaxMiscTDBucs (6)
#define MaxFieldGoalBucs (6)
#define MaxNFLGamesPerDay (15)
/******************************************************************************/
/* ID classes */
/* Field classes */
DefineFixStrClass(TCollegeName,26);
enum TFootballPositionEnum
{
pos_Undefined,
pos_Quarterback,
pos_WideReceiver,
pos_RunningBack,
pos_TightEnd,
pos_Kicker,
pos_Defense, // Defensive Team
// Non-Participating Player Positions
pos_Center, // C
pos_NoseTackle, // NT
pos_Punter, // P
pos_Cornerback, // CB
pos_Linebacker, // LB
pos_DefEnd, // DE
pos_DefTackle, // DT
pos_DefBack, // DB
pos_Saftey, // S
pos_Tackle, // T
pos_Guard // G
};
#define pos_LastKeyPos pos_Defense
#define pos_Last pos_Guard
class TFootballPosition : public EnumType<TFootballPositionEnum,pos_Undefined,pos_Last>
{
public:
TFootballPosition(int t = pos_Undefined) :
EnumType<TFootballPositionEnum,pos_Undefined,pos_Last>(t) {}
TFootballPosition(const char* str);
const char* c_str() const;
bool isKey() const;
bool isOffensive() const;
};
enum TFootballLineupEnum
{
lut_Undefined,
lut_Starting
};
#define lut_Last lut_Starting
class TFootballLineup : public EnumType<TFootballLineupEnum,lut_Undefined,lut_Last>
{
public:
TFootballLineup(int t = lut_Undefined) :
EnumType<TFootballLineupEnum,lut_Undefined,lut_Last>(t) {}
};
/******************************************************************************/
enum TRosterStatusEnum
{
rst_Undefined,
rst_Active,
rst_Inactive
};
#define rst_Last rst_Inactive
class TRosterStatus : public EnumType<TRosterStatusEnum,rst_Undefined,rst_Last>
{
public:
TRosterStatus(int t = rst_Undefined) :
EnumType<TRosterStatusEnum,rst_Undefined,rst_Last>(t) {}
TRosterStatus(const char* str);
const char* c_str() const;
};
/******************************************************************************/
enum TInjuryStatusEnum
{
ist_Undefined,
ist_NoInjury,
ist_Probable,
ist_Questionable,
ist_Doubtful,
ist_Out
};
#define ist_Last ist_Out
class TInjuryStatus : public EnumType<TInjuryStatusEnum,ist_Undefined,ist_Last>
{
public:
TInjuryStatus(int t = ist_Undefined) :
EnumType<TInjuryStatusEnum,ist_Undefined,ist_Last>(t) {}
TInjuryStatus(const char* str);
const char* c_str() const;
};
/******************************************************************************/
/*
Undefined
TotalPoints
PassingYards
PassingTDs
Interceptions
TwoPointPasses
RushingYards
RushingTDs
Fumbles
TwoPointRushes
ReceivingYards
ReceivingTDs
TwoPointReceptions
KickReturnTDs
MiscTDs
PATsMade
PATsMissed
FieldGoalsMade
FieldGoalsMissed
YardsAllowed
Safeties
Sacks
BlockedKicks
FumblesRecovered
DefInterceptions
DefensiveTDs
*/
enum FootballPlayerStatEnum
{
pst_Undefined = 0,
//Both
pst_TotalPoints,
// Offense
pst_PassingYards,
pst_PassingTDs,
pst_Interceptions,
pst_TwoPointPasses,
pst_RushingYards,
pst_RushingTDs,
pst_Fumbles,
pst_TwoPointRushes,
pst_ReceivingYards,
pst_ReceivingTDs,
pst_TwoPointReceptions,
pst_KickReturnTDs,
pst_MiscTDs,
pst_PATsMade,
pst_PATsMissed,
pst_FieldGoalsMade,
pst_FieldGoalsMissed,
// Defense
pst_YardsAllowed,
pst_Safeties,
pst_Sacks,
pst_BlockedKicks,
pst_FumblesRecovered,
pst_DefInterceptions,
pst_DefensiveTDs
};
#define pst_Last pst_DefensiveTDs
class FootballPlayerStatType : public EnumType<FootballPlayerStatEnum,
pst_Undefined,pst_Last>
{
public:
FootballPlayerStatType(int t = pst_Undefined) :
EnumType<FootballPlayerStatEnum,pst_Undefined,pst_Last>(t) {}
bool isOffensive() const { return(fT < pst_YardsAllowed); }
};
/******************************************************************************/
TPlayerID ConvertProfTeamIDtoPlayerID(TProfTeamID profTeamID);
TProfTeamID ConvertPlayerIDtoProfTeamID(TPlayerID playerID);
/******************************************************************************/
class TFootballTeam : public TTeam
{
protected:
TPlayerIDVector fLineup; // Starting Lineup
protected:
TFootballTeam() {}
virtual ~TFootballTeam() {}
public:
virtual void clear();
virtual const TPlayerIDVector& lineupConst(TLineup lineup) const;
virtual TPlayerIDVector& lineup(TLineup lineup);
protected:
/* DataSetRecord methods */
virtual void readFromDataSet(TDataSet& dataSet);
virtual void writeToDataSet(TDataSet& dataSet);
public:
friend class RefCountPtr<TFootballTeam>;
friend class ASFootballObjectBuilder;
};
class TFootballTeamPtr : public TDataSetRecordPtr<TFootballTeam,TTeamID>
{
public:
TFootballTeamPtr(TTeamPtr teamPtr = TTeamPtr()) :
TDataSetRecordPtr<TFootballTeam,TTeamID>(
teamPtr.isNull() ? NULL :
&dynamic_cast<TFootballTeam&>(*teamPtr)) {}
operator TTeamPtr() { return(TTeamPtr(fT)); }
};
/******************************************************************************/
class TFootballProfPlayer : public TProfPlayer
{
protected:
TFootballPosition fPosition;
TRosterStatus fRosterStatus;
TInjuryStatus fInjuryStatus;
TCollegeName fCollegeName;
short fYearsPro;
protected:
TFootballProfPlayer() { fYearsPro = 0; }
virtual ~TFootballProfPlayer() {}
public:
virtual void clear();
virtual int getPosition() const { return(fPosition); }
virtual void setPosition(int position)
{ fPosition = position; setHasChanged(); }
void setRosterStatus(TRosterStatus rosterStatus)
{ fRosterStatus = rosterStatus; setHasChanged(); }
TRosterStatus getRosterStatus(void) const { return (fRosterStatus); }
virtual const char* getRosterStatusString() const
{ return(fRosterStatus.c_str()); }
void setInjuryStatus(TInjuryStatus injuryStatus)
{ fInjuryStatus = injuryStatus; setHasChanged(); }
TInjuryStatus getInjuryStatus(void) const { return (fInjuryStatus); }
virtual const char* getInjuryStatusString() const
{ return(fInjuryStatus.c_str()); }
const char* getCollegeName() const { return(fCollegeName); }
void setCollegeName(const char* collegeName)
{ fCollegeName.Copy(collegeName); setHasChanged(); }
virtual short getYearsPro() const { return(fYearsPro); }
virtual void setYearsPro(short yearsPro)
{ fYearsPro = yearsPro; setHasChanged(); }
protected:
/* DataSetRecord methods */
virtual void readFromDataSet(TDataSet& dataSet);
virtual void writeToDataSet(TDataSet& dataSet);
virtual void validateForUpdate();
friend class RefCountPtr<TFootballProfPlayer>;
friend class ASFootballObjectBuilder;
};
class TFootballProfPlayerPtr : public TDataSetRecordPtr<TFootballProfPlayer,TPlayerID>
{
public:
TFootballProfPlayerPtr(TProfPlayerPtr profPlayerPtr = TProfPlayerPtr()) :
TDataSetRecordPtr<TFootballProfPlayer,TPlayerID>(
profPlayerPtr.isNull() ? NULL :
&dynamic_cast<TFootballProfPlayer&>(*profPlayerPtr)) {}
operator TProfPlayerPtr() { return(TProfPlayerPtr(fT)); }
};
/******************************************************************************/
/* Yardage Buckets Distance */
enum YardageBucketsDistanceEnum
{
ybd_00_to_09 = 0,
ybd_10_to_19 = 1,
ybd_20_to_29 = 2,
ybd_30_to_39 = 3,
ybd_40_to_49 = 4,
ybd_50_plus = 5,
};
class YardageBucketsDistance : public EnumType<YardageBucketsDistanceEnum,
ybd_00_to_09,ybd_50_plus>
{
public:
YardageBucketsDistance(int t = ybd_00_to_09) :
EnumType<YardageBucketsDistanceEnum,ybd_00_to_09,ybd_50_plus>(t) {}
};
class YardageBuckets
{
protected:
typedef byte ItemType;
vector<ItemType> fBuckets;
public:
void clear() { fBuckets.erase(fBuckets.begin(),fBuckets.end()); }
void setBucket(YardageBucketsDistance ybd,short count);
byte getBucket(YardageBucketsDistance ybd) const;
int numBuckets() const { return(fBuckets.size()); }
short totalBuckets() const;
void incBucket(YardageBucketsDistance ybd)
{ setBucket(ybd,cast2short(getBucket(ybd) + 1)); }
void addYards(byte yards);
void sumBuckets(const YardageBuckets& yardageBuckets);
};
/******************************************************************************/
class TOffGameStatDetail
{
public:
/* Passing Stats */
short fPassingYards;
byte fInterceptions;
byte fTwoPointPasses;
YardageBuckets fPassingTDYardageBuckets;
/* Rushing Stats */
short fRushingYards;
byte fFumbles;
byte fTwoPointRushes;
YardageBuckets fRushingTDYardageBuckets;
/* Receiving Stats */
short fReceivingYards;
byte fTwoPointReceptions;
YardageBuckets fReceivingTDYardageBuckets;
/* Misc Offense */
YardageBuckets fKickReturnTDYardageBuckets;
YardageBuckets fMiscTDYardageBuckets;
/* Kicking Stats */
byte fPATsAttempted;
byte fPATsMade;
byte fFieldGoalsAttempted;
YardageBuckets fFieldGoalYardageBuckets;
public:
TOffGameStatDetail() { clear(); }
virtual void clear();
short calcTotalPoints() const;
double getStat(int playerStatType);
void sumStats(const TOffGameStatDetail& offGameStatDetail);
protected:
static short calcTouchdowns(const YardageBuckets& yardageBuckets,
short touchdownValue);
static short calcFieldGoals(byte fieldGoalsAttempted,
const YardageBuckets& yardageBuckets);
};
/******************************************************************************/
class TDefGameStatDetail
{
public:
short fPassingYardsAllowed;
short fRushingYardsAllowed;
byte fSafeties;
byte fSacks;
byte fBlockedKicks;
byte fFumblesRecovered;
byte fInterceptions;
byte fDefensiveTDs;
public:
TDefGameStatDetail() { clear(); }
virtual void clear();
short calcTotalPoints() const;
double getStat(int playerStatType);
void sumStats(const TDefGameStatDetail& defGameStatDetail);
};
/******************************************************************************/
class TFootballOffGameStat : public TOffGameStat
{
protected:
TOffGameStatDetail fOffGameStatDetail;
protected:
TFootballOffGameStat() {}
virtual ~TFootballOffGameStat() {}
public:
virtual void clear();
TOffGameStatDetail& offGameStatDetail() { setHasChanged(); return(fOffGameStatDetail); }
const TOffGameStatDetail& offGameStatDetail() const { return(fOffGameStatDetail); }
virtual void calcTotalPoints()
{ fTotalPoints = fOffGameStatDetail.calcTotalPoints(); setHasChanged(); }
virtual double getStat(int playerStatType);
static CStr31 getDefaultStatStr(int playerStatType);
virtual CStr31 getStatStr(int playerStatType);
virtual void sumStats(const TOffGameStatPtr offGameStatPtr);
protected:
/* DataSetRecord methods */
void readYardageFromDataSet(TDataSet& dataSet,YardageBuckets& yardageBuckets,
const char* subFieldName);
virtual void readFromDataSet(TDataSet& dataSet);
void writeYardageToDataSet(TDataSet& dataSet,
const YardageBuckets& yardageBuckets,const char* subFieldName,
int maxItems);
virtual void writeToDataSet(TDataSet& dataSet);
virtual void validateForUpdate();
friend class RefCountPtr<TFootballOffGameStat>;
friend class ASFootballObjectBuilder;
};
class TFootballOffGameStatPtr : public TDataSetRecordPtr<TFootballOffGameStat,
TPlayerDateID>
{
public:
TFootballOffGameStatPtr(TOffGameStatPtr offGameStatPtr = TOffGameStatPtr()) :
TDataSetRecordPtr<TFootballOffGameStat,TPlayerDateID>(
offGameStatPtr.isNull() ? NULL :
&dynamic_cast<TFootballOffGameStat&>(*offGameStatPtr)) {}
operator TOffGameStatPtr() { return(TOffGameStatPtr(fT)); }
};
/******************************************************************************/
class TFootballDefGameStat : public TDefGameStat
{
protected:
TDefGameStatDetail fDefGameStatDetail;
protected:
TFootballDefGameStat() {}
virtual ~TFootballDefGameStat() {}
public:
virtual void clear();
TDefGameStatDetail& defGameStatDetail() { setHasChanged(); return(fDefGameStatDetail); }
const TDefGameStatDetail& defGameStatDetail() const { return(fDefGameStatDetail); }
virtual void calcTotalPoints()
{ fTotalPoints = fDefGameStatDetail.calcTotalPoints(); setHasChanged(); }
virtual double getStat(int playerStatType);
static CStr31 getDefaultStatStr(int playerStatType);
virtual CStr31 getStatStr(int playerStatType);
virtual void sumStats(const TDefGameStatPtr defGameStatPtr);
protected:
/* DataSetRecord methods */
virtual void readFromDataSet(TDataSet& dataSet);
virtual void writeToDataSet(TDataSet& dataSet);
virtual void validateForUpdate();
friend class RefCountPtr<TFootballDefGameStat>;
friend class ASFootballObjectBuilder;
};
class TFootballDefGameStatPtr : public TDataSetRecordPtr<TFootballDefGameStat,
TPlayerDateID>
{
public:
TFootballDefGameStatPtr(TDefGameStatPtr defGameStatPtr = TDefGameStatPtr()) :
TDataSetRecordPtr<TFootballDefGameStat,TPlayerDateID>(
defGameStatPtr.isNull() ? NULL :
&dynamic_cast<TFootballDefGameStat&>(*defGameStatPtr)) {}
operator TDefGameStatPtr() { return(TDefGameStatPtr(fT)); }
};
/******************************************************************************/
class TProfTeamGame
{
protected:
TDateTime fGameDate;
TDateTime fGameTime;
TProfTeamID fVisitTeamID;
TProfTeamID fHomeTeamID;
byte fVisitScore;
byte fHomeScore;
public:
TProfTeamGame() { clear(); }
void clear() { fGameDate = TDateTime(); fGameTime = TDateTime();
fVisitTeamID = TProfTeamID(); fHomeTeamID = TProfTeamID();
fVisitScore = 0; fHomeScore = 0; }
void setGameDate(TDateTime gameDate) { fGameDate = gameDate; }
TDateTime getGameDate() const { return(fGameDate); }
void setGameTime(TDateTime gameTime) { fGameTime = gameTime; }
TDateTime getGameTime() const { return(fGameTime); }
void setVisitTeamID(TProfTeamID visitTeamID) { fVisitTeamID = visitTeamID; }
TProfTeamID getVisitTeamID() const { return(fVisitTeamID); }
void setHomeTeamID(TProfTeamID homeTeamID) { fHomeTeamID = homeTeamID; }
TProfTeamID getHomeTeamID() const { return(fHomeTeamID); }
void setVisitScore(byte visitScore) { fVisitScore = visitScore; }
byte getVisitScore() const { return(fVisitScore); }
void setHomeScore(byte homeScore) { fHomeScore = homeScore; }
byte getHomeScore() const { return(fHomeScore); }
TProfTeamID getOppTeamID(TProfTeamID teamID) const;
};
typedef std::vector<TProfTeamGame> TProfTeamGameVector;
/******************************************************************************/
class TFootballProfTeamSchedule; //forward reference
typedef TDataSetRecordPtr<TFootballProfTeamSchedule,TProfGameWeek> TFootballProfTeamSchedulePtr;
class TFootballProfTeamSchedule : public TQueryDataSetRecord
{
protected:
TProfGameWeek fProfGameWeek;
TProfTeamGameVector fProfTeamGameVector;
protected:
TFootballProfTeamSchedule() {}
virtual ~TFootballProfTeamSchedule() {}
private:
TFootballProfTeamSchedule(const TFootballProfTeamSchedule&); // don't allow copy constructor
const TFootballProfTeamSchedule& operator=(const TFootballProfTeamSchedule&); // or operator=
public:
virtual void clear();
void setProfGameWeek(TProfGameWeek profGameWeek)
{
// Can only change fProfGameWeek if not set or is new record.
if((fProfGameWeek != TProfGameWeek()) && !fIsNewRecord)
throw ASIException("TFootballProfTeamSchedule::setProfGameWeek: can't change");
fProfGameWeek = profGameWeek;
setHasChanged();
}
TProfGameWeek getProfGameWeek(void) const { return(fProfGameWeek); }
const TProfTeamGameVector& profTeamGameVector() const
{ return(fProfTeamGameVector); }
TProfTeamGameVector& profTeamGameVector()
{ setHasChanged(); return(fProfTeamGameVector); }
TDateTime findEarliestGameDate() const;
TDateTime findEarliestGameTime() const;
TDateTime findLatestGameDate() const;
bool anyGamesForDate(const TDateTime gameDate);
bool getProfTeamGameByProfTeamID(TProfTeamID profTeamID,
TProfTeamGame& profTeamGame) const;
// Helper/Template Functions
static TFootballProfTeamSchedulePtr createGet(TProfGameWeek profGameWeek,CommonAccessMode getMode)
{ return(CreateGetRecord<TFootballProfTeamSchedule,TProfGameWeek,
TFootballProfTeamSchedulePtr>(profGameWeek,getMode)); }
static TFootballProfTeamSchedulePtr newInstance();
TProfGameWeek getKey() const { return(getProfGameWeek()); }
void setKey(TProfGameWeek profGameWeek) { setProfGameWeek(profGameWeek); }
protected:
/* DataSetRecord methods */
virtual const char* getDatabaseName() { return(PrimaryDatabaseName()); }
virtual const char* getTableName() { return("ProfTeamSchedule"); }
virtual void readFromDataSet(TDataSet& dataSet);
virtual void writeToDataSet(TDataSet& dataSet);
void validateGameVector();
virtual void validateForUpdate();
virtual CStrVar getWhereStr(void);
friend class RefCountPtr<TFootballProfTeamSchedule>;
friend class ASFootballObjectBuilder;
};
class TFootballProfTeamScheduleVector : public std::vector<TFootballProfTeamSchedulePtr>
{
public:
void sortByProfGameWeek() { std::sort(begin(),end(), profGameWeekLessCompare() ); }
TFootballProfTeamSchedulePtr findByContainsGameDate(TDateTime gameDate,
CommonAccessMode getMode);
TFootballProfTeamSchedulePtr findCurrentAsOfToday(CommonAccessMode getMode);
protected:
struct profGameWeekLessCompare
{
bool operator() (const TFootballProfTeamSchedulePtr& lhs,
const TFootballProfTeamSchedulePtr& rhs) const
{ return(lhs->getProfGameWeek() < rhs->getProfGameWeek()); }
};
};
/******************************************************************************/
}; //namespace asfootball
#endif //ASFootballType
/******************************************************************************/
/******************************************************************************/
| [
"[email protected]"
]
| [
[
[
1,
659
]
]
]
|
90bc9ca57dec6755a8207703bd2344cfe7c1df0a | 138a353006eb1376668037fcdfbafc05450aa413 | /source/ogre/OgreNewt/boost/mpl/aux_/range_c/O1_size.hpp | ae10e9c1eade1ef72ce568cbd2e6a9b72f349e63 | []
| no_license | sonicma7/choreopower | 107ed0a5f2eb5fa9e47378702469b77554e44746 | 1480a8f9512531665695b46dcfdde3f689888053 | refs/heads/master | 2020-05-16T20:53:11.590126 | 2009-11-18T03:10:12 | 2009-11-18T03:10:12 | 32,246,184 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 876 | hpp |
#ifndef BOOST_MPL_AUX_RANGE_C_O1_SIZE_HPP_INCLUDED
#define BOOST_MPL_AUX_RANGE_C_O1_SIZE_HPP_INCLUDED
// Copyright Aleksey Gurtovoy 2000-2004
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/mpl for documentation.
// $Source: /cvsroot/ogre/ogreaddons/ogrenewt/OgreNewt_Main/inc/boost/mpl/aux_/range_c/O1_size.hpp,v $
// $Date: 2006/04/17 23:48:05 $
// $Revision: 1.1 $
#include <boost/mpl/O1_size_fwd.hpp>
#include <boost/mpl/aux_/range_c/size.hpp>
#include <boost/mpl/aux_/range_c/tag.hpp>
namespace boost { namespace mpl {
template<>
struct O1_size_impl< aux::half_open_range_tag >
: size_impl< aux::half_open_range_tag >
{
};
}}
#endif // BOOST_MPL_AUX_RANGE_C_O1_SIZE_HPP_INCLUDED
| [
"Sonicma7@0822fb10-d3c0-11de-a505-35228575a32e"
]
| [
[
[
1,
31
]
]
]
|
7c66ff1a6ac135be53517eab1d05cf1b123a951c | 718dc2ad71e8b39471b5bf0c6d60cbe5f5c183e1 | /soft micros/Codigo/codigo portable/Propiedades/PropiedadIncrementable/PropDescripcionVariable.hpp | 60c7ebac8b51f79c937145db1f4129b4bec04668 | []
| no_license | jonyMarino/microsdhacel | affb7a6b0ea1f4fd96d79a04d1a3ec3eaa917bca | 66d03c6a9d3a2d22b4d7104e2a38a2c9bb4061d3 | refs/heads/master | 2020-05-18T19:53:51.301695 | 2011-05-30T20:40:24 | 2011-05-30T20:40:24 | 34,532,512 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 941 | hpp | #ifndef _PROP_DESCRIPCION_VARIABLE_HPP
#define _PROP_DESCRIPCION_VARIABLE_HPP
#include "PropNumLFPF.hpp"
#include "PropiedadGetter.hpp"
struct ArgumentosPropNumDP{
struct ArgumentosPropNumLFPF super;
const char * (*getDescripcion)(PropGetterVisual &arg);
};
class PropDescripcionVariable :public PropNumLFPF{
public:
PropDescripcionVariable(void*obj,const struct ArgumentosPropNumDP* args,uchar numObjeto);
protected:
virtual const char * getDescripcion();
};
struct PropDescripcionVariableFactory:public PropGetterVisualFactory{
virtual PropiedadGetter& getPropiedad(void*obj,const struct ArgumentosPropiedadGetter* args,uchar numObjeto)const;
};
struct ConstructorPropDescripcionVariable{
const struct PropGetterVisualFactory * factory;
struct ArgumentosPropNumDP args;
};
extern const struct PropDescripcionVariableFactory propDescripcionVariableFactory;
#endif | [
"nicopimen@9fc3b3b2-dce3-11dd-9b7c-b771bf68b549"
]
| [
[
[
1,
35
]
]
]
|
4123f2cd5ae57d98955a5cb41106513b8218f333 | 68d8ddd1f19bcf70c9429f22ff1075c0c6f5479b | /engine/evaluator.h | 396f747261f88dbd10bd962ce4c5238133a36187 | []
| no_license | kusano/Shogi55GUI | 532df08ca2053dedc0b6ac13e0a3ac6e245fc00a | 3b1552ee29578a58929a5c5b9f5a27790fa25d1d | refs/heads/master | 2021-05-14T02:08:21.126449 | 2008-12-18T03:56:58 | 2008-12-18T03:56:58 | 116,587,616 | 0 | 0 | null | null | null | null | ISO-8859-7 | C++ | false | false | 1,560 | h |
#pragma once
class CBoard;
// ]ΏΦΜvf
struct CHARACTER
{
char x1, y1, x2, y2;
int value;
};
class CEvaluator
{
public:
static const int NW = 2; // ΞΏlπvZ·ι
static const int NH = 2; // ΞΏlπvZ·ι³
static const int ELEMNUM = 10 + 6*2 + 10*25 + 100*(NW+1)*(2*NH+1); // ]ΏvfΜΒ
private:
static bool Initialized;
static int ValuePiece[22]; // ξΏl
static int ValueHand[14][2]; // ξΏl
static int ValuePosition[22][49]; // ΚuΏl
static int ValueRelative[22][22][32]; // ΞΚuΏl
static int Near[49][64]; // ίT
static int PositionToDiff[49][64]; // ΚuπValueRelativeΜYΙΟ·
int Value; // ]Ώ
void Initialize();
int GetRelativeValue( const CBoard *board, int pos1, int pos2 ) const;
public:
void SetWeight( const CBoard *board, const int weight[ELEMNUM] );
void Update( const CBoard *board );
void Put( const CBoard *board, int pos, int piece );
void PutHand( const CBoard *board, int piece );
void Remove( const CBoard *board, int pos );
void RemoveHand( const CBoard *board, int piece );
int GetValue( const CBoard *board ) const;
void SetValue( int value );
void GetElement( const CBoard *board, int element[ELEMNUM] ) const;
int GetCharacter( const CBoard *board, int threshold, CHARACTER character[], int maxnumber ) const;
};
| [
"[email protected]"
]
| [
[
[
1,
51
]
]
]
|
91e687447b7582c600ba1c67533e3fbfd5776e8f | 5c4e36054f0752a610ad149dfd81e6f35ccb37a1 | /libs/src2.75/BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h | 837c16da3fa1e149e4673e29dec5944f203f46b6 | []
| no_license | Akira-Hayasaka/ofxBulletPhysics | 4141dc7b6dff7e46b85317b0fe7d2e1f8896b2e4 | 5e45da80bce2ed8b1f12de9a220e0c1eafeb7951 | refs/heads/master | 2016-09-15T23:11:01.354626 | 2011-09-22T04:11:35 | 2011-09-22T04:11:35 | 1,152,090 | 6 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 15,289 | h | /*
Bullet Continuous Collision Detection and Physics Library
Copyright (c) 2003-2006 Erwin Coumans http://continuousphysics.com/Bullet/
This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it freely,
subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
/// 2009 March: btGeneric6DofConstraint refactored by Roman Ponomarev
/// Added support for generic constraint solver through getInfo1/getInfo2 methods
/*
2007-09-09
btGeneric6DofConstraint Refactored by Francisco Le?n
email: [email protected]
http://gimpact.sf.net
*/
#ifndef GENERIC_6DOF_CONSTRAINT_H
#define GENERIC_6DOF_CONSTRAINT_H
#include "LinearMath/btVector3.h"
#include "btJacobianEntry.h"
#include "btTypedConstraint.h"
class btRigidBody;
//! Rotation Limit structure for generic joints
class btRotationalLimitMotor
{
public:
//! limit_parameters
//!@{
btScalar m_loLimit;//!< joint limit
btScalar m_hiLimit;//!< joint limit
btScalar m_targetVelocity;//!< target motor velocity
btScalar m_maxMotorForce;//!< max force on motor
btScalar m_maxLimitForce;//!< max force on limit
btScalar m_damping;//!< Damping.
btScalar m_limitSoftness;//! Relaxation factor
btScalar m_ERP;//!< Error tolerance factor when joint is at limit
btScalar m_bounce;//!< restitution factor
bool m_enableMotor;
//!@}
//! temp_variables
//!@{
btScalar m_currentLimitError;//! How much is violated this limit
btScalar m_currentPosition; //! current value of angle
int m_currentLimit;//!< 0=free, 1=at lo limit, 2=at hi limit
btScalar m_accumulatedImpulse;
//!@}
btRotationalLimitMotor()
{
m_accumulatedImpulse = 0.f;
m_targetVelocity = 0;
m_maxMotorForce = 0.1f;
m_maxLimitForce = 300.0f;
m_loLimit = 1.0f;
m_hiLimit = -1.0f;
m_ERP = 0.5f;
m_bounce = 0.0f;
m_damping = 1.0f;
m_limitSoftness = 0.5f;
m_currentLimit = 0;
m_currentLimitError = 0;
m_enableMotor = false;
}
btRotationalLimitMotor(const btRotationalLimitMotor & limot)
{
m_targetVelocity = limot.m_targetVelocity;
m_maxMotorForce = limot.m_maxMotorForce;
m_limitSoftness = limot.m_limitSoftness;
m_loLimit = limot.m_loLimit;
m_hiLimit = limot.m_hiLimit;
m_ERP = limot.m_ERP;
m_bounce = limot.m_bounce;
m_currentLimit = limot.m_currentLimit;
m_currentLimitError = limot.m_currentLimitError;
m_enableMotor = limot.m_enableMotor;
}
//! Is limited
bool isLimited()
{
if(m_loLimit > m_hiLimit) return false;
return true;
}
//! Need apply correction
bool needApplyTorques()
{
if(m_currentLimit == 0 && m_enableMotor == false) return false;
return true;
}
//! calculates error
/*!
calculates m_currentLimit and m_currentLimitError.
*/
int testLimitValue(btScalar test_value);
//! apply the correction impulses for two bodies
btScalar solveAngularLimits(btScalar timeStep,btVector3& axis, btScalar jacDiagABInv,btRigidBody * body0, btSolverBody& bodyA,btRigidBody * body1,btSolverBody& bodyB);
};
class btTranslationalLimitMotor
{
public:
btVector3 m_lowerLimit;//!< the constraint lower limits
btVector3 m_upperLimit;//!< the constraint upper limits
btVector3 m_accumulatedImpulse;
//! Linear_Limit_parameters
//!@{
btScalar m_limitSoftness;//!< Softness for linear limit
btScalar m_damping;//!< Damping for linear limit
btScalar m_restitution;//! Bounce parameter for linear limit
//!@}
bool m_enableMotor[3];
btVector3 m_targetVelocity;//!< target motor velocity
btVector3 m_maxMotorForce;//!< max force on motor
btVector3 m_currentLimitError;//! How much is violated this limit
btVector3 m_currentLinearDiff;//! Current relative offset of constraint frames
int m_currentLimit[3];//!< 0=free, 1=at lower limit, 2=at upper limit
btTranslationalLimitMotor()
{
m_lowerLimit.setValue(0.f,0.f,0.f);
m_upperLimit.setValue(0.f,0.f,0.f);
m_accumulatedImpulse.setValue(0.f,0.f,0.f);
m_limitSoftness = 0.7f;
m_damping = btScalar(1.0f);
m_restitution = btScalar(0.5f);
for(int i=0; i < 3; i++)
{
m_enableMotor[i] = false;
m_targetVelocity[i] = btScalar(0.f);
m_maxMotorForce[i] = btScalar(0.f);
}
}
btTranslationalLimitMotor(const btTranslationalLimitMotor & other )
{
m_lowerLimit = other.m_lowerLimit;
m_upperLimit = other.m_upperLimit;
m_accumulatedImpulse = other.m_accumulatedImpulse;
m_limitSoftness = other.m_limitSoftness ;
m_damping = other.m_damping;
m_restitution = other.m_restitution;
for(int i=0; i < 3; i++)
{
m_enableMotor[i] = other.m_enableMotor[i];
m_targetVelocity[i] = other.m_targetVelocity[i];
m_maxMotorForce[i] = other.m_maxMotorForce[i];
}
}
//! Test limit
/*!
- free means upper < lower,
- locked means upper == lower
- limited means upper > lower
- limitIndex: first 3 are linear, next 3 are angular
*/
inline bool isLimited(int limitIndex)
{
return (m_upperLimit[limitIndex] >= m_lowerLimit[limitIndex]);
}
inline bool needApplyForce(int limitIndex)
{
if(m_currentLimit[limitIndex] == 0 && m_enableMotor[limitIndex] == false) return false;
return true;
}
int testLimitValue(int limitIndex, btScalar test_value);
btScalar solveLinearAxis(
btScalar timeStep,
btScalar jacDiagABInv,
btRigidBody& body1,btSolverBody& bodyA,const btVector3 &pointInA,
btRigidBody& body2,btSolverBody& bodyB,const btVector3 &pointInB,
int limit_index,
const btVector3 & axis_normal_on_a,
const btVector3 & anchorPos);
};
/// btGeneric6DofConstraint between two rigidbodies each with a pivotpoint that descibes the axis location in local space
/*!
btGeneric6DofConstraint can leave any of the 6 degree of freedom 'free' or 'locked'.
currently this limit supports rotational motors<br>
<ul>
<li> For Linear limits, use btGeneric6DofConstraint.setLinearUpperLimit, btGeneric6DofConstraint.setLinearLowerLimit. You can set the parameters with the btTranslationalLimitMotor structure accsesible through the btGeneric6DofConstraint.getTranslationalLimitMotor method.
At this moment translational motors are not supported. May be in the future. </li>
<li> For Angular limits, use the btRotationalLimitMotor structure for configuring the limit.
This is accessible through btGeneric6DofConstraint.getLimitMotor method,
This brings support for limit parameters and motors. </li>
<li> Angulars limits have these possible ranges:
<table border=1 >
<tr
<td><b>AXIS</b></td>
<td><b>MIN ANGLE</b></td>
<td><b>MAX ANGLE</b></td>
<td>X</td>
<td>-PI</td>
<td>PI</td>
<td>Y</td>
<td>-PI/2</td>
<td>PI/2</td>
<td>Z</td>
<td>-PI/2</td>
<td>PI/2</td>
</tr>
</table>
</li>
</ul>
*/
class btGeneric6DofConstraint : public btTypedConstraint
{
protected:
//! relative_frames
//!@{
btTransform m_frameInA;//!< the constraint space w.r.t body A
btTransform m_frameInB;//!< the constraint space w.r.t body B
//!@}
//! Jacobians
//!@{
btJacobianEntry m_jacLinear[3];//!< 3 orthogonal linear constraints
btJacobianEntry m_jacAng[3];//!< 3 orthogonal angular constraints
//!@}
//! Linear_Limit_parameters
//!@{
btTranslationalLimitMotor m_linearLimits;
//!@}
//! hinge_parameters
//!@{
btRotationalLimitMotor m_angularLimits[3];
//!@}
protected:
//! temporal variables
//!@{
btScalar m_timeStep;
btTransform m_calculatedTransformA;
btTransform m_calculatedTransformB;
btVector3 m_calculatedAxisAngleDiff;
btVector3 m_calculatedAxis[3];
btVector3 m_calculatedLinearDiff;
btVector3 m_AnchorPos; // point betwen pivots of bodies A and B to solve linear axes
bool m_useLinearReferenceFrameA;
//!@}
btGeneric6DofConstraint& operator=(btGeneric6DofConstraint& other)
{
btAssert(0);
(void) other;
return *this;
}
int setAngularLimits(btConstraintInfo2 *info, int row_offset,const btTransform& transA,const btTransform& transB,const btVector3& linVelA,const btVector3& linVelB,const btVector3& angVelA,const btVector3& angVelB);
int setLinearLimits(btConstraintInfo2 *info,const btTransform& transA,const btTransform& transB,const btVector3& linVelA,const btVector3& linVelB,const btVector3& angVelA,const btVector3& angVelB);
void buildLinearJacobian(
btJacobianEntry & jacLinear,const btVector3 & normalWorld,
const btVector3 & pivotAInW,const btVector3 & pivotBInW);
void buildAngularJacobian(btJacobianEntry & jacAngular,const btVector3 & jointAxisW);
// tests linear limits
void calculateLinearInfo();
//! calcs the euler angles between the two bodies.
void calculateAngleInfo();
public:
///for backwards compatibility during the transition to 'getInfo/getInfo2'
bool m_useSolveConstraintObsolete;
btGeneric6DofConstraint(btRigidBody& rbA, btRigidBody& rbB, const btTransform& frameInA, const btTransform& frameInB ,bool useLinearReferenceFrameA);
btGeneric6DofConstraint();
//! Calcs global transform of the offsets
/*!
Calcs the global transform for the joint offset for body A an B, and also calcs the agle differences between the bodies.
\sa btGeneric6DofConstraint.getCalculatedTransformA , btGeneric6DofConstraint.getCalculatedTransformB, btGeneric6DofConstraint.calculateAngleInfo
*/
void calculateTransforms(const btTransform& transA,const btTransform& transB);
void calculateTransforms();
//! Gets the global transform of the offset for body A
/*!
\sa btGeneric6DofConstraint.getFrameOffsetA, btGeneric6DofConstraint.getFrameOffsetB, btGeneric6DofConstraint.calculateAngleInfo.
*/
const btTransform & getCalculatedTransformA() const
{
return m_calculatedTransformA;
}
//! Gets the global transform of the offset for body B
/*!
\sa btGeneric6DofConstraint.getFrameOffsetA, btGeneric6DofConstraint.getFrameOffsetB, btGeneric6DofConstraint.calculateAngleInfo.
*/
const btTransform & getCalculatedTransformB() const
{
return m_calculatedTransformB;
}
const btTransform & getFrameOffsetA() const
{
return m_frameInA;
}
const btTransform & getFrameOffsetB() const
{
return m_frameInB;
}
btTransform & getFrameOffsetA()
{
return m_frameInA;
}
btTransform & getFrameOffsetB()
{
return m_frameInB;
}
//! performs Jacobian calculation, and also calculates angle differences and axis
virtual void buildJacobian();
virtual void getInfo1 (btConstraintInfo1* info);
void getInfo1NonVirtual (btConstraintInfo1* info);
virtual void getInfo2 (btConstraintInfo2* info);
void getInfo2NonVirtual (btConstraintInfo2* info,const btTransform& transA,const btTransform& transB,const btVector3& linVelA,const btVector3& linVelB,const btVector3& angVelA,const btVector3& angVelB);
virtual void solveConstraintObsolete(btSolverBody& bodyA,btSolverBody& bodyB,btScalar timeStep);
void updateRHS(btScalar timeStep);
//! Get the rotation axis in global coordinates
/*!
\pre btGeneric6DofConstraint.buildJacobian must be called previously.
*/
btVector3 getAxis(int axis_index) const;
//! Get the relative Euler angle
/*!
\pre btGeneric6DofConstraint::calculateTransforms() must be called previously.
*/
btScalar getAngle(int axis_index) const;
//! Get the relative position of the constraint pivot
/*!
\pre btGeneric6DofConstraint::calculateTransforms() must be called previously.
*/
btScalar getRelativePivotPosition(int axis_index) const;
//! Test angular limit.
/*!
Calculates angular correction and returns true if limit needs to be corrected.
\pre btGeneric6DofConstraint::calculateTransforms() must be called previously.
*/
bool testAngularLimitMotor(int axis_index);
void setLinearLowerLimit(const btVector3& linearLower)
{
m_linearLimits.m_lowerLimit = linearLower;
}
void setLinearUpperLimit(const btVector3& linearUpper)
{
m_linearLimits.m_upperLimit = linearUpper;
}
void setAngularLowerLimit(const btVector3& angularLower)
{
for(int i = 0; i < 3; i++)
m_angularLimits[i].m_loLimit = btNormalizeAngle(angularLower[i]);
}
void setAngularUpperLimit(const btVector3& angularUpper)
{
for(int i = 0; i < 3; i++)
m_angularLimits[i].m_hiLimit = btNormalizeAngle(angularUpper[i]);
}
//! Retrieves the angular limit informacion
btRotationalLimitMotor * getRotationalLimitMotor(int index)
{
return &m_angularLimits[index];
}
//! Retrieves the limit informacion
btTranslationalLimitMotor * getTranslationalLimitMotor()
{
return &m_linearLimits;
}
//first 3 are linear, next 3 are angular
void setLimit(int axis, btScalar lo, btScalar hi)
{
if(axis<3)
{
m_linearLimits.m_lowerLimit[axis] = lo;
m_linearLimits.m_upperLimit[axis] = hi;
}
else
{
lo = btNormalizeAngle(lo);
hi = btNormalizeAngle(hi);
m_angularLimits[axis-3].m_loLimit = lo;
m_angularLimits[axis-3].m_hiLimit = hi;
}
}
//! Test limit
/*!
- free means upper < lower,
- locked means upper == lower
- limited means upper > lower
- limitIndex: first 3 are linear, next 3 are angular
*/
bool isLimited(int limitIndex)
{
if(limitIndex<3)
{
return m_linearLimits.isLimited(limitIndex);
}
return m_angularLimits[limitIndex-3].isLimited();
}
virtual void calcAnchorPos(void); // overridable
int get_limit_motor_info2( btRotationalLimitMotor * limot,
const btTransform& transA,const btTransform& transB,const btVector3& linVelA,const btVector3& linVelB,const btVector3& angVelA,const btVector3& angVelB,
btConstraintInfo2 *info, int row, btVector3& ax1, int rotational);
};
#endif //GENERIC_6DOF_CONSTRAINT_H
| [
"[email protected]"
]
| [
[
[
1,
492
]
]
]
|
9c6dee2acfd17c4afadec2ba60659d8721acb591 | c0bd82eb640d8594f2d2b76262566288676b8395 | /src/scripts/ShamanSpells.cpp | 1370be223d4ee42fbb4ab92b2db6565455b301e9 | [
"FSFUL"
]
| permissive | vata/solution | 4c6551b9253d8f23ad5e72f4a96fc80e55e583c9 | 774fca057d12a906128f9231831ae2e10a947da6 | refs/heads/master | 2021-01-10T02:08:50.032837 | 2007-11-13T22:01:17 | 2007-11-13T22:01:17 | 45,352,930 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 3,229 | cpp | //////////////////////////////////////////////////
// Copyright (C) 2006 Burlex for WoWd Project
//////////////////////////////////////////////////
// Warrior Dummy Spell Module
#include "StdAfx.h"
/* Script Export Declarations */
extern "C" WOWD_SCRIPT_DECL void ScriptInitialize(ScriptModule *mod);
extern "C" WOWD_SCRIPT_DECL bool HandleDummySpell(uint32 uSpellId, uint32 i, Spell *pSpell);
// Build version info function
BUILD_VERSIONINFO_DATA(SCRIPTLIB_VERSION_MAJOR, SCRIPTLIB_VERSION_MINOR);
#ifdef WIN32
/* This is needed because windows is a piece of shit. ;) */
BOOL APIENTRY DllMain( HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved )
{
return TRUE;
}
#endif
/************************************************************************/
/* Spell Defs */
/************************************************************************/
void RockbiterWeapon(uint32 uSpellId, uint32 i, Spell* pSpell)
{
uint32 enchantment_entry = 0;
switch(pSpell->m_spellInfo->RankNumber)
{
case 1:
enchantment_entry = 3021;
break;
case 2:
enchantment_entry = 3024;
break;
case 3:
enchantment_entry = 3027;
break;
case 4:
enchantment_entry = 3030;
break;
case 5:
enchantment_entry = 3033;
break;
case 6:
enchantment_entry = 3036;
break;
case 7:
enchantment_entry = 3039;
break;
case 8:
enchantment_entry = 3042;
break;
}
if(!enchantment_entry || !pSpell->p_caster)
return;
Item * item = pSpell->p_caster->GetItemInterface()->GetInventoryItem(EQUIPMENT_SLOT_MAINHAND);
EnchantEntry * enchant = sEnchantStore.LookupEntry(enchantment_entry);
if(!item || !enchant)
return;
int32 Slot = item->HasEnchantment(enchant->Id);
if(Slot >= 0)
item->ModifyEnchantmentTime(Slot, 1800);
else
{
Slot = item->AddEnchantment(enchant, 1800, false, true); // 5min
if(Slot < 0) return;
item->ApplyEnchantmentBonus(Slot, APPLY);
}
script_debuglog("ShamanSpells.cpp :: Rockbiter Weapon Rank %u, enchant %u, slot %u", pSpell->m_spellInfo->RankNumber,
enchantment_entry, Slot);
}
/* Actual Spell Code */
bool HandleDummySpell(uint32 uSpellId, uint32 i, Spell *pSpell)
{
switch(uSpellId)
{
case 8017:
case 8018:
case 8019:
case 8020:
case 8021:
case 8022:
RockbiterWeapon(uSpellId, i, pSpell);
break;
default:
return false;
break;
}
return true;
}
/* Module info */
void ScriptInitialize(ScriptModule *mod)
{
/**** Rockbiter Weapon ****/
sScriptMgr.ScriptAddSpellModule(8017, mod); // Rank 1
sScriptMgr.ScriptAddSpellModule(8018, mod); // Rank 2
sScriptMgr.ScriptAddSpellModule(8019, mod); // Rank 3
sScriptMgr.ScriptAddSpellModule(8020, mod); // Rank 4
sScriptMgr.ScriptAddSpellModule(8021, mod); // Rank 5
sScriptMgr.ScriptAddSpellModule(8022, mod); // Rank 6
} | [
"[email protected]"
]
| [
[
[
1,
116
]
]
]
|
f30c382eebc58ec3f77ed235d045d0ec268339f9 | a0bc9908be9d42d58af7a1a8f8398c2f7dcfa561 | /SlonEngine/slon/Database/Library.h | 526e24e5211dfc42694d21e7dee52388d129956b | []
| no_license | BackupTheBerlios/slon | e0ca1137a84e8415798b5323bc7fd8f71fe1a9c6 | dc10b00c8499b5b3966492e3d2260fa658fee2f3 | refs/heads/master | 2016-08-05T09:45:23.467442 | 2011-10-28T16:19:31 | 2011-10-28T16:19:31 | 39,895,039 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,983 | h | #ifndef __SLON_ENGINE_DATABASE_LIBRARY_H__
#define __SLON_ENGINE_DATABASE_LIBRARY_H__
#include "../Realm/Location.h"
#include "Forward.h"
#include <boost/unordered_map.hpp>
namespace slon {
namespace database {
/** Interface for library loaders */
class Library :
public Referenced
{
public:
template<typename T>
struct element_type { typedef boost::intrusive_ptr<T> type; };
template<typename T>
struct storage_type { typedef boost::unordered_map<std::string, typename element_type<T>::type> type; };
typedef storage_type<animation::Animation>::type::value_type key_animation_pair;
typedef storage_type<graphics::Effect>::type::value_type key_effect_pair;
typedef storage_type<graphics::Texture>::type::value_type key_texture_pair;
typedef storage_type<scene::Node>::type::value_type key_visual_scene_pair;
typedef storage_type<realm::Location>::type::value_type key_location_pair;
#ifdef SLON_ENGINE_USE_PHYSICS
typedef storage_type<physics::PhysicsModel>::type::value_type key_physics_scene_pair;
#endif
typedef storage_type<animation::Animation>::type key_animation_map;
typedef storage_type<graphics::Effect>::type key_effect_map;
typedef storage_type<graphics::Texture>::type key_texture_map;
typedef storage_type<scene::Node>::type key_visual_scene_map;
typedef storage_type<realm::Location>::type key_location_map;
#ifdef SLON_ENGINE_USE_PHYSICS
typedef storage_type<physics::PhysicsModel>::type key_physics_scene_map;
#endif
public:
key_animation_map animations;
key_effect_map effects;
key_texture_map textures;
key_visual_scene_map visualScenes;
key_location_map locations;
#ifdef SLON_ENGINE_USE_PHYSICS
key_physics_scene_map physicsScenes;
#endif
};
} // namespace database
} // namespace slon
#endif // __SLON_ENGINE_DATABASE_LIBRARY_H__
| [
"devnull@localhost"
]
| [
[
[
1,
54
]
]
]
|
f2f9f1ee2b3285806e05ed3351c3e770aaef1cf9 | 709cd826da3ae55945fd7036ecf872ee7cdbd82a | /Term/WildMagic2/Source/Physics/WmlRectangleSurface.inl | 45158f65ef5f978901395fbdfa7f4afaf9f8703e | []
| no_license | argapratama/kucgbowling | 20dbaefe1596358156691e81ccceb9151b15efb0 | 65e40b6f33c5511bddf0fa350c1eefc647ace48a | refs/heads/master | 2018-01-08T15:27:44.784437 | 2011-06-19T15:23:39 | 2011-06-19T15:23:39 | 36,738,655 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,138 | inl | // Magic Software, Inc.
// http://www.magic-software.com
// http://www.wild-magic.com
// Copyright (c) 2003. All Rights Reserved
//
// The Game Physics source code is supplied under the terms of the license
// agreement http://www.magic-software.com/License/GamePhysics.pdf and may not
// be copied or disclosed except in accordance with the terms of that
// agreement.
//----------------------------------------------------------------------------
inline ParametricSurfacef*& RectangleSurface::Surface ()
{
return m_pkSurface;
}
//----------------------------------------------------------------------------
inline const ParametricSurfacef* RectangleSurface::GetSurface () const
{
return m_pkSurface;
}
//----------------------------------------------------------------------------
inline int RectangleSurface::GetUSamples () const
{
return m_iUSamples;
}
//----------------------------------------------------------------------------
inline int RectangleSurface::GetVSamples () const
{
return m_iVSamples;
}
//----------------------------------------------------------------------------
| [
"[email protected]"
]
| [
[
[
1,
31
]
]
]
|
6a31e62e65d62ba345d443a433de857c0bfa1598 | 021e8c48a44a56571c07dd9830d8bf86d68507cb | /build/vtk/vtkPipelineGraphSource.h | 81df973eccfc9f167b4e5c71511c367eae0afd61 | [
"BSD-3-Clause"
]
| permissive | Electrofire/QdevelopVset | c67ae1b30b0115d5c2045e3ca82199394081b733 | f88344d0d89beeec46f5dc72c20c0fdd9ef4c0b5 | refs/heads/master | 2021-01-18T10:44:01.451029 | 2011-05-01T23:52:15 | 2011-05-01T23:52:15 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,066 | h | /*=========================================================================
Program: Visualization Toolkit
Module: vtkPipelineGraphSource.h
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
// .NAME vtkPipelineGraphSource - a graph constructed from a VTK pipeline
//
// .SECTION Description
#ifndef __vtkPipelineGraphSource_h
#define __vtkPipelineGraphSource_h
#include "vtkDirectedGraphAlgorithm.h"
#include <vtkStdString.h>
class vtkCollection;
class VTK_VIEWS_EXPORT vtkPipelineGraphSource : public vtkDirectedGraphAlgorithm
{
public:
static vtkPipelineGraphSource* New();
vtkTypeMacro(vtkPipelineGraphSource,vtkDirectedGraphAlgorithm);
void PrintSelf(ostream& os, vtkIndent indent);
void AddSink(vtkObject* object);
void RemoveSink(vtkObject* object);
//BTX
// Description:
// Generates a GraphViz DOT file that describes the VTK pipeline
// terminating at the given sink.
static void PipelineToDot(vtkAlgorithm* sink, ostream& output, const vtkStdString& graph_name = "");
// Description:
// Generates a GraphViz DOT file that describes the VTK pipeline
// terminating at the given sinks.
static void PipelineToDot(vtkCollection* sinks, ostream& output, const vtkStdString& graph_name = "");
protected:
vtkPipelineGraphSource();
~vtkPipelineGraphSource();
int RequestData(
vtkInformation*,
vtkInformationVector**,
vtkInformationVector*);
vtkCollection* Sinks;
private:
vtkPipelineGraphSource(const vtkPipelineGraphSource&); // Not implemented
void operator=(const vtkPipelineGraphSource&); // Not implemented
//ETX
};
#endif
| [
"ganondorf@ganondorf-VirtualBox.(none)"
]
| [
[
[
1,
66
]
]
]
|
8dcbee0cd54c6654558055f13e7bd0d673b19738 | 011359e589f99ae5fe8271962d447165e9ff7768 | /src/burn/konami/d_parodius.cpp | dcfff900567d593ebbe63bf045f103ef3ddd515f | []
| no_license | PS3emulators/fba-next-slim | 4c753375fd68863c53830bb367c61737393f9777 | d082dea48c378bddd5e2a686fe8c19beb06db8e1 | refs/heads/master | 2021-01-17T23:05:29.479865 | 2011-12-01T18:16:02 | 2011-12-01T18:16:02 | 2,899,840 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 19,675 | cpp | // FB Alpha Parodius Da! driver module
// Based on MAME driver by Nicola Salmoria
#include "tiles_generic.h"
#include "burn_ym2151.h"
#include "konami_intf.h"
#include "konamiic.h"
#include "k053260.h"
static unsigned char *AllMem;
static unsigned char *MemEnd;
static unsigned char *AllRam;
static unsigned char *RamEnd;
static unsigned char *DrvKonROM;
static unsigned char *DrvZ80ROM;
static unsigned char *DrvGfxROM0;
static unsigned char *DrvGfxROM1;
static unsigned char *DrvGfxROMExp0;
static unsigned char *DrvGfxROMExp1;
static unsigned char *DrvSndROM;
static unsigned char *DrvBankRAM;
static unsigned char *DrvKonRAM;
static unsigned char *DrvPalRAM;
static unsigned char *DrvZ80RAM;
static unsigned int *Palette;
static unsigned int *DrvPalette;
static unsigned char DrvRecalc;
static unsigned char *nDrvRomBank;
static int layer_colorbase[3];
static int sprite_colorbase;
static int layerpri[3];
static unsigned char DrvJoy1[8];
static unsigned char DrvJoy2[8];
static unsigned char DrvJoy3[8];
static unsigned char DrvDips[3];
static unsigned char DrvReset;
static unsigned char DrvInputs[3];
static int nCyclesDone[2];
static struct BurnInputInfo ParodiusInputList[] = {
{"P1 Coin", BIT_DIGITAL, DrvJoy3 + 2, "p1 coin" },
{"P1 Start", BIT_DIGITAL, DrvJoy1 + 0, "p1 start" },
{"P1 Up", BIT_DIGITAL, DrvJoy1 + 1, "p1 up" },
{"P1 Down", BIT_DIGITAL, DrvJoy1 + 2, "p1 down" },
{"P1 Left", BIT_DIGITAL, DrvJoy1 + 3, "p1 left" },
{"P1 Right", BIT_DIGITAL, DrvJoy1 + 4, "p1 right" },
{"P1 Button 1", BIT_DIGITAL, DrvJoy1 + 5, "p1 fire 1" },
{"P1 Button 2", BIT_DIGITAL, DrvJoy1 + 6, "p1 fire 2" },
{"P1 Button 3", BIT_DIGITAL, DrvJoy1 + 7, "p1 fire 3" },
{"P2 Coin", BIT_DIGITAL, DrvJoy3 + 3, "p2 coin" },
{"P2 Start", BIT_DIGITAL, DrvJoy2 + 0, "p2 start" },
{"P2 Up", BIT_DIGITAL, DrvJoy2 + 1, "p2 up" },
{"P2 Down", BIT_DIGITAL, DrvJoy2 + 2, "p2 down" },
{"P2 Left", BIT_DIGITAL, DrvJoy2 + 3, "p2 left" },
{"P2 Right", BIT_DIGITAL, DrvJoy2 + 4, "p2 right" },
{"P2 Button 1", BIT_DIGITAL, DrvJoy2 + 5, "p2 fire 1" },
{"P2 Button 2", BIT_DIGITAL, DrvJoy2 + 6, "p2 fire 2" },
{"P2 Button 3", BIT_DIGITAL, DrvJoy2 + 7, "p2 fire 3" },
{"Reset", BIT_DIGITAL, &DrvReset, "reset" },
{"Service", BIT_DIGITAL, DrvJoy3 + 0, "service" },
{"Dip A", BIT_DIPSWITCH, DrvDips + 0, "dip" },
{"Dip B", BIT_DIPSWITCH, DrvDips + 1, "dip" },
{"Dip C", BIT_DIPSWITCH, DrvDips + 2, "dip" },
};
STDINPUTINFO(Parodius)
static struct BurnDIPInfo ParodiusDIPList[]=
{
{0x14, 0xff, 0xff, 0xff, NULL },
{0x15, 0xff, 0xff, 0x5a, NULL },
{0x16, 0xff, 0xff, 0xf0, NULL },
{0 , 0xfe, 0 , 16, "Coin A" },
{0x14, 0x01, 0x0f, 0x02, "4 Coins 1 Credits" },
{0x14, 0x01, 0x0f, 0x05, "3 Coins 1 Credits" },
{0x14, 0x01, 0x0f, 0x08, "2 Coins 1 Credits" },
{0x14, 0x01, 0x0f, 0x04, "3 Coins 2 Credits" },
{0x14, 0x01, 0x0f, 0x01, "4 Coins 3 Credits" },
{0x14, 0x01, 0x0f, 0x0f, "1 Coin 1 Credits" },
{0x14, 0x01, 0x0f, 0x03, "3 Coins 4 Credits" },
{0x14, 0x01, 0x0f, 0x07, "2 Coins 3 Credits" },
{0x14, 0x01, 0x0f, 0x0e, "1 Coin 2 Credits" },
{0x14, 0x01, 0x0f, 0x06, "2 Coins 5 Credits" },
{0x14, 0x01, 0x0f, 0x0d, "1 Coin 3 Credits" },
{0x14, 0x01, 0x0f, 0x0c, "1 Coin 4 Credits" },
{0x14, 0x01, 0x0f, 0x0b, "1 Coin 5 Credits" },
{0x14, 0x01, 0x0f, 0x0a, "1 Coin 6 Credits" },
{0x14, 0x01, 0x0f, 0x09, "1 Coin 7 Credits" },
{0x14, 0x01, 0x0f, 0x00, "Free Play" },
{0 , 0xfe, 0 , 15, "Coin B" },
{0x14, 0x01, 0xf0, 0x20, "4 Coins 1 Credits" },
{0x14, 0x01, 0xf0, 0x50, "3 Coins 1 Credits" },
{0x14, 0x01, 0xf0, 0x80, "2 Coins 1 Credits" },
{0x14, 0x01, 0xf0, 0x40, "3 Coins 2 Credits" },
{0x14, 0x01, 0xf0, 0x10, "4 Coins 3 Credits" },
{0x14, 0x01, 0xf0, 0xf0, "1 Coin 1 Credits" },
{0x14, 0x01, 0xf0, 0x30, "3 Coins 4 Credits" },
{0x14, 0x01, 0xf0, 0x70, "2 Coins 3 Credits" },
{0x14, 0x01, 0xf0, 0xe0, "1 Coin 2 Credits" },
{0x14, 0x01, 0xf0, 0x60, "2 Coins 5 Credits" },
{0x14, 0x01, 0xf0, 0xd0, "1 Coin 3 Credits" },
{0x14, 0x01, 0xf0, 0xc0, "1 Coin 4 Credits" },
{0x14, 0x01, 0xf0, 0xb0, "1 Coin 5 Credits" },
{0x14, 0x01, 0xf0, 0xa0, "1 Coin 6 Credits" },
{0x14, 0x01, 0xf0, 0x90, "1 Coin 7 Credits" },
{0 , 0xfe, 0 , 4, "Lives" },
{0x15, 0x01, 0x03, 0x03, "2" },
{0x15, 0x01, 0x03, 0x02, "3" },
{0x15, 0x01, 0x03, 0x01, "4" },
{0x15, 0x01, 0x03, 0x00, "7" },
// {0 , 0xfe, 0 , 2, "Cabinet" },
// {0x15, 0x01, 0x04, 0x00, "Upright" },
// {0x15, 0x01, 0x04, 0x04, "Cocktail" },
{0 , 0xfe, 0 , 4, "Bonus Life" },
{0x15, 0x01, 0x18, 0x18, "20000 80000" },
{0x15, 0x01, 0x18, 0x10, "30000 100000" },
{0x15, 0x01, 0x18, 0x08, "20000" },
{0x15, 0x01, 0x18, 0x00, "70000" },
{0 , 0xfe, 0 , 4, "Difficulty" },
{0x15, 0x01, 0x60, 0x60, "Easy" },
{0x15, 0x01, 0x60, 0x40, "Normal" },
{0x15, 0x01, 0x60, 0x20, "Difficult" },
{0x15, 0x01, 0x60, 0x00, "Very Difficult" },
{0 , 0xfe, 0 , 2, "Demo Sounds" },
{0x15, 0x01, 0x80, 0x80, "Off" },
{0x15, 0x01, 0x80, 0x00, "On" },
// {0 , 0xfe, 0 , 2, "Flip Screen" },
// {0x16, 0x01, 0x10, 0x10, "Off" },
// {0x16, 0x01, 0x10, 0x00, "On" },
{0 , 0xfe, 0 , 2, "Upright Controls" },
{0x16, 0x01, 0x20, 0x20, "Single" },
{0x16, 0x01, 0x20, 0x00, "Dual" },
{0 , 0xfe, 0 , 2, "Service Mode" },
{0x16, 0x01, 0x40, 0x40, "Off" },
{0x16, 0x01, 0x40, 0x00, "On" },
};
STDDIPINFO(Parodius)
void parodius_main_write(unsigned short address, unsigned char data)
{
switch (address)
{
case 0x3fc0:
K052109RMRDLine = data & 0x08;
return;
case 0x3fc4:
nDrvRomBank[1] = data;
return;
case 0x3fc8:
ZetSetVector(0xff);
ZetSetIRQLine(0, ZET_IRQSTATUS_ACK);
return;
case 0x3fcc:
case 0x3fcd:
K053260Write(0, address & 1, data);
return;
}
if ((address & 0xf800) == 0x0000) {
if (nDrvRomBank[1] & 1) {
DrvPalRAM[((nDrvRomBank[1] & 0x04) << 9) + address] = data;
} else {
DrvBankRAM[address] = data;
}
return;
}
if ((address & 0xfff0) == 0x3fa0) {
K053244Write(0, address & 0x0f, data);
return;
}
if ((address & 0xfff0) == 0x3fb0) {
K053251Write(address & 0x0f, data);
return;
}
if ((address & 0xf800) == 0x2000) {
if (nDrvRomBank[1] & 0x02) {
K053245Write(0, address & 0x7ff, data);
return;
}
}
if (address >= 0x2000 && address <= 0x5fff) {
K052109Write(address - 0x2000, data);
}
}
unsigned char parodius_main_read(unsigned short address)
{
switch (address)
{
case 0x3f8c:
return DrvInputs[0];
case 0x3f8d:
return DrvInputs[1];
case 0x3f8e:
return (DrvDips[2] & 0xf0) | (DrvInputs[2] & 0x0f);
case 0x3f8f:
return DrvDips[0];
case 0x3f90:
return DrvDips[1];
case 0x3fc0: // watchdog
return 0;
case 0x3fcc:
case 0x3fcd:
return K053260Read(0, (address & 1)+2);
}
if ((address & 0xf800) == 0x0000) {
if (nDrvRomBank[1] & 1) {
return DrvPalRAM[((nDrvRomBank[1] & 0x04) << 9) + address];
} else {
return DrvBankRAM[address];
}
}
if ((address & 0xfff0) == 0x3fa0) {
return K053244Read(0, address & 0x0f);
}
if ((address & 0xf800) == 0x2000) {
if (nDrvRomBank[1] & 0x02) {
return K053245Read(0, address & 0x7ff);
}
}
if (address >= 0x2000 && address <= 0x5fff) {
return K052109Read(address - 0x2000);
}
return 0;
}
void __fastcall parodius_sound_write(unsigned short address, unsigned char data)
{
switch (address)
{
case 0xf800:
BurnYM2151SelectRegister(data);
return;
case 0xf801:
BurnYM2151WriteRegister(data);
return;
case 0xfa00:
nCyclesDone[1] += ZetRun(100);
ZetNmi();
return;
}
if (address >= 0xfc00 && address <= 0xfc2f) {
K053260Write(0, address & 0x3f, data);
}
}
unsigned char __fastcall parodius_sound_read(unsigned short address)
{
switch (address)
{
case 0xf800:
return 0xff;
case 0xf801:
return BurnYM2151ReadStatus();
}
if (address >= 0xfc00 && address <= 0xfc2f) {
if ((address & 0x3e) == 0x00) ZetSetIRQLine(0, ZET_IRQSTATUS_NONE);
return K053260Read(0, address & 0x3f);
}
return 0;
}
static void K052109Callback(int layer, int bank, int *code, int *color, int *flags, int *)
{
*flags = (*color & 0x80) >> 7;
*code |= ((*color & 0x03) << 8) | ((*color & 0x10) << 6) | ((*color & 0x0c) << 9) | (bank << 13);
*color = layer_colorbase[layer] + ((*color & 0xe0) >> 5);
}
static void K053245Callback(int *code, int *color, int *priority)
{
int pri = 0x20 | ((*color & 0x60) >> 2);
if (pri <= layerpri[2]) *priority = 0;
else if (pri > layerpri[2] && pri <= layerpri[1]) *priority = 1;
else if (pri > layerpri[1] && pri <= layerpri[0]) *priority = 2;
else *priority = 3;
*code &= 0x1fff;
*color = sprite_colorbase + (*color & 0x1f);
}
static void parodius_set_lines(int lines)
{
nDrvRomBank[0] = lines;
konamiMapMemory(DrvKonROM + 0x10000 + ((~lines & 0x0f) * 0x4000), 0x6000, 0x9fff, KON_ROM);
}
static int DrvDoReset()
{
DrvReset = 0;
memset (AllRam, 0, RamEnd - AllRam);
konamiOpen(0);
konamiReset();
konamiClose();
ZetOpen(0);
ZetReset();
ZetClose();
BurnYM2151Reset();
KonamiICReset();
K053260Reset(0);
return 0;
}
static int MemIndex()
{
unsigned char *Next; Next = AllMem;
DrvKonROM = Next; Next += 0x050000;
DrvZ80ROM = Next; Next += 0x010000;
DrvGfxROM0 = Next; Next += 0x100000;
DrvGfxROMExp0 = Next; Next += 0x200000;
DrvGfxROM1 = Next; Next += 0x100000;
DrvGfxROMExp1 = Next; Next += 0x200000;
DrvSndROM = Next; Next += 0x080000;
Palette = (unsigned int*)Next; Next += 0x800 * sizeof(int);
DrvPalette = (unsigned int*)Next; Next += 0x800 * sizeof(int);
AllRam = Next;
DrvBankRAM = Next; Next += 0x000800;
DrvKonRAM = Next; Next += 0x001800;
DrvPalRAM = Next; Next += 0x001000;
DrvZ80RAM = Next; Next += 0x000800;
nDrvRomBank = Next; Next += 0x000002;
RamEnd = Next;
MemEnd = Next;
return 0;
}
static int DrvGfxDecode()
{
int Plane[4] = { 0x018, 0x010, 0x008, 0x000 };
int XOffs[8] = { 0x000, 0x001, 0x002, 0x003, 0x004, 0x005, 0x006, 0x007 };
int YOffs[8] = { 0x000, 0x020, 0x040, 0x060, 0x080, 0x0a0, 0x0c0, 0x0e0 };
konami_rom_deinterleave_2(DrvGfxROM0, 0x100000);
konami_rom_deinterleave_2(DrvGfxROM1, 0x100000);
GfxDecode(0x8000, 4, 8, 8, Plane, XOffs, YOffs, 0x100, DrvGfxROM0, DrvGfxROMExp0);
K053245GfxDecode(DrvGfxROM1, DrvGfxROMExp1, 0x100000);
return 0;
}
static int DrvInit()
{
AllMem = NULL;
MemIndex();
int nLen = MemEnd - (unsigned char *)0;
if ((AllMem = (unsigned char *)malloc(nLen)) == NULL) return 1;
memset(AllMem, 0, nLen);
MemIndex();
{
if (BurnLoadRom(DrvKonROM + 0x010000, 0, 1)) return 1;
if (BurnLoadRom(DrvKonROM + 0x030000, 1, 1)) return 1;
memcpy (DrvKonROM + 0x08000, DrvKonROM + 0x48000, 0x8000);
if (BurnLoadRom(DrvZ80ROM + 0x000000, 2, 1)) return 1;
if (BurnLoadRom(DrvGfxROM0 + 0x000000, 3, 1)) return 1;
if (BurnLoadRom(DrvGfxROM0 + 0x080000, 4, 1)) return 1;
if (BurnLoadRom(DrvGfxROM1 + 0x000000, 5, 1)) return 1;
if (BurnLoadRom(DrvGfxROM1 + 0x080000, 6, 1)) return 1;
if (BurnLoadRom(DrvSndROM + 0x000000, 7, 1)) return 1;
DrvGfxDecode();
}
konamiInit(1);
konamiOpen(0);
konamiMapMemory(DrvKonRAM, 0x0800, 0x1fff, KON_RAM);
konamiMapMemory(DrvKonROM + 0x10000, 0x6000, 0x9fff, KON_ROM);
konamiMapMemory(DrvKonROM + 0x0a000, 0xa000, 0xffff, KON_ROM);
konamiSetWriteHandler(parodius_main_write);
konamiSetReadHandler(parodius_main_read);
konamiSetlinesCallback(parodius_set_lines);
konamiClose();
ZetInit(1);
ZetOpen(0);
ZetMapArea(0x0000, 0xefff, 0, DrvZ80ROM);
ZetMapArea(0x0000, 0xefff, 2, DrvZ80ROM);
ZetMapArea(0xf000, 0xf7ff, 0, DrvZ80RAM);
ZetMapArea(0xf000, 0xf7ff, 1, DrvZ80RAM);
ZetMapArea(0xf000, 0xf7ff, 2, DrvZ80RAM);
ZetSetWriteHandler(parodius_sound_write);
ZetSetReadHandler(parodius_sound_read);
ZetMemEnd();
ZetClose();
K052109Init(DrvGfxROM0, 0xfffff);
K052109SetCallback(K052109Callback);
K052109AdjustScroll(8, 0);
K053245Init(0, DrvGfxROM1, 0xfffff, K053245Callback);
K053245SetSpriteOffset(0, -112, -16);
BurnYM2151Init(3579545, 70.0);
K053260Init(0, 3579545, DrvSndROM, 0x80000);
GenericTilesInit();
DrvDoReset();
return 0;
}
static int DrvExit()
{
GenericTilesExit();
KonamiICExit();
konamiExit();
ZetExit();
BurnYM2151Exit();
K053260Exit();
free (AllMem);
AllMem = NULL;
return 0;
}
static void sortlayers(int *layer,int *pri)
{
#define SWAP(a,b) \
if (pri[a] < pri[b]) \
{ \
int t; \
t = pri[a]; pri[a] = pri[b]; pri[b] = t; \
t = layer[a]; layer[a] = layer[b]; layer[b] = t; \
}
SWAP(0,1)
SWAP(0,2)
SWAP(1,2)
}
static void DrvRecalcPal()
{
unsigned char r,g,b;
unsigned short *p = (unsigned short*)DrvPalRAM;
for (int i = 0; i < 0x1000 / 2; i++) {
unsigned short d = swapWord((p[i] << 8) | (p[i] >> 8));
b = (d >> 10) & 0x1f;
g = (d >> 5) & 0x1f;
r = (d >> 0) & 0x1f;
r = (r << 3) | (r >> 2);
g = (g << 3) | (g >> 2);
b = (b << 3) | (b >> 2);
DrvPalette[i] = BurnHighCol(r, g, b, 0);
Palette[i] = (r << 16) | (g << 8) | b;
}
}
static int DrvDraw()
{
if (DrvRecalc)
DrvRecalcPal();
K052109UpdateScroll();
int bg_colorbase, layer[3];
bg_colorbase = K053251GetPaletteIndex(0);
sprite_colorbase = K053251GetPaletteIndex(1);
layer_colorbase[0] = K053251GetPaletteIndex(2);
layer_colorbase[1] = K053251GetPaletteIndex(4);
layer_colorbase[2] = K053251GetPaletteIndex(3);
layerpri[0] = K053251GetPriority(2);
layerpri[1] = K053251GetPriority(4);
layerpri[2] = K053251GetPriority(3);
layer[0] = 0;
layer[1] = 1;
layer[2] = 2;
sortlayers(layer,layerpri);
for (int i = 0; i < nScreenWidth * nScreenHeight; i++)
pTransDraw[i] = 16 * bg_colorbase;
#ifndef NO_LAYER_ENABLE_TOGGLE
if (nBurnLayer & 1)
#endif
K052109RenderLayer(layer[0], 0, DrvGfxROMExp0);
#ifndef NO_SPRITE_ENABLE_TOGGLE
if (nSpriteEnable & 4)
#endif
K053245SpritesRender(0, DrvGfxROMExp1, 2); // right?
#ifndef NO_SPRITE_ENABLE_TOGGLE
if (nSpriteEnable & 8)
#endif
K053245SpritesRender(0, DrvGfxROMExp1, 3);
#ifndef NO_LAYER_ENABLE_TOGGLE
if (nBurnLayer & 2)
#endif
K052109RenderLayer(layer[1], 0, DrvGfxROMExp0);
#ifndef NO_SPRITE_ENABLE_TOGGLE
if (nSpriteEnable & 2)
#endif
K053245SpritesRender(0, DrvGfxROMExp1, 1);
#ifndef NO_LAYER_ENABLE_TOGGLE
if (nBurnLayer & 4)
#endif
K052109RenderLayer(layer[2], 0, DrvGfxROMExp0);
#ifndef NO_SPRITE_ENABLE_TOGGLE
if (nSpriteEnable & 1)
#endif
K053245SpritesRender(0, DrvGfxROMExp1, 0); // used (back)?
KonamiBlendCopy(Palette, DrvPalette);
return 0;
}
static int DrvFrame()
{
if (DrvReset) {
DrvDoReset();
}
ZetNewFrame();
konamiNewFrame();
{
memset (DrvInputs, 0xff, 3);
for (int i = 0; i < 8; i++) {
DrvInputs[0] ^= (DrvJoy1[i] & 1) << i;
DrvInputs[1] ^= (DrvJoy2[i] & 1) << i;
DrvInputs[2] ^= (DrvJoy3[i] & 1) << i;
}
}
int nInterleave = nBurnSoundLen;
int nSoundBufferPos = 0;
int nCyclesTotal[2] = { 3000000 / 60, 3579545 / 60 };
nCyclesDone[0] = nCyclesDone[1] = 0;
ZetOpen(0);
konamiOpen(0);
for (int i = 0; i < nInterleave; i++) {
int nNext, nCyclesSegment;
nNext = (i + 1) * nCyclesTotal[0] / nInterleave;
nCyclesSegment = nNext - nCyclesDone[0];
nCyclesSegment = konamiRun(nCyclesSegment);
nCyclesDone[0] += nCyclesSegment;
nNext = (i + 1) * nCyclesTotal[1] / nInterleave;
nCyclesSegment = nNext - nCyclesDone[1];
nCyclesSegment = ZetRun(nCyclesSegment);
nCyclesDone[1] += nCyclesSegment;
if (pBurnSoundOut) {
int nSegmentLength = nBurnSoundLen / nInterleave;
short* pSoundBuf = pBurnSoundOut + (nSoundBufferPos << 1);
BurnYM2151Render(pSoundBuf, nSegmentLength);
K053260Update(0, pSoundBuf, nSegmentLength);
nSoundBufferPos += nSegmentLength;
}
}
if (K052109_irq_enabled) konamiSetIrqLine(KONAMI_IRQ_LINE, KONAMI_HOLD_LINE);
if (pBurnSoundOut) {
int nSegmentLength = nBurnSoundLen - nSoundBufferPos;
short* pSoundBuf = pBurnSoundOut + (nSoundBufferPos << 1);
if (nSegmentLength) {
BurnYM2151Render(pSoundBuf, nSegmentLength);
K053260Update(0, pSoundBuf, nSegmentLength);
}
}
konamiClose();
ZetClose();
if (pBurnDraw) {
DrvDraw();
}
return 0;
}
static int DrvScan(int nAction,int *pnMin)
{
struct BurnArea ba;
if (pnMin) {
*pnMin = 0x029705;
}
if (nAction & ACB_VOLATILE) {
memset(&ba, 0, sizeof(ba));
ba.Data = AllRam;
ba.nLen = RamEnd - AllRam;
ba.szName = "All Ram";
BurnAcb(&ba);
konamiCpuScan(nAction, pnMin);
ZetScan(nAction);
BurnYM2151Scan(nAction);
KonamiICScan(nAction);
}
if (nAction & ACB_WRITE) {
konamiOpen(0);
parodius_set_lines(nDrvRomBank[0]);
konamiClose();
}
return 0;
}
// Parodius DA! (World)
static struct BurnRomInfo parodiusRomDesc[] = {
{ "955l01.bin", 0x20000, 0x49a658eb, 1 | BRF_PRG | BRF_ESS }, // 0 Konami Custom Code
{ "955l02.bin", 0x20000, 0x161d7322, 1 | BRF_PRG | BRF_ESS }, // 1
{ "955e03.bin", 0x10000, 0x940aa356, 2 | BRF_PRG | BRF_ESS }, // 2 Z80 Code
{ "955d07.bin", 0x80000, 0x89473fec, 3 | BRF_GRA }, // 3 Background Tiles
{ "955d08.bin", 0x80000, 0x43d5cda1, 3 | BRF_GRA }, // 4
{ "955d05.bin", 0x80000, 0x7a1e55e0, 4 | BRF_GRA }, // 5 Sprites
{ "955d06.bin", 0x80000, 0xf4252875, 4 | BRF_GRA }, // 6
{ "955d04.bin", 0x80000, 0xe671491a, 5 | BRF_SND }, // 7 K053260 Samples
};
STD_ROM_PICK(parodius)
STD_ROM_FN(parodius)
struct BurnDriver BurnDrvParodius = {
"parodius", NULL, NULL, "1990",
"Parodius DA! (World)\0", NULL, "Konami", "GX955",
NULL, NULL, NULL, NULL,
BDF_GAME_WORKING, 2, HARDWARE_PREFIX_KONAMI,
NULL, parodiusRomInfo, parodiusRomName, ParodiusInputInfo, ParodiusDIPInfo,
DrvInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc,
288, 224, 4, 3
};
// Parodius DA! (Japan)
static struct BurnRomInfo parodiusjRomDesc[] = {
{ "955e01.bin", 0x20000, 0x49baa334, 1 | BRF_PRG | BRF_ESS }, // 0 Konami Custom Code
{ "955e02.bin", 0x20000, 0x14010d6f, 1 | BRF_PRG | BRF_ESS }, // 1
{ "955e03.bin", 0x10000, 0x940aa356, 2 | BRF_PRG | BRF_ESS }, // 2 Z80 Code
{ "955d07.bin", 0x80000, 0x89473fec, 3 | BRF_GRA }, // 3 Background Tiles
{ "955d08.bin", 0x80000, 0x43d5cda1, 3 | BRF_GRA }, // 4
{ "955d05.bin", 0x80000, 0x7a1e55e0, 4 | BRF_GRA }, // 5 Sprites
{ "955d06.bin", 0x80000, 0xf4252875, 4 | BRF_GRA }, // 6
{ "955d04.bin", 0x80000, 0xe671491a, 5 | BRF_SND }, // 7 K053260 Samples
};
STD_ROM_PICK(parodiusj)
STD_ROM_FN(parodiusj)
struct BurnDriver BurnDrvParodiusj = {
"parodiusj", "parodius", NULL, "1990",
"Parodius DA! (Japan)\0", NULL, "Konami", "GX955",
NULL, NULL, NULL, NULL,
BDF_GAME_WORKING | BDF_CLONE, 2, HARDWARE_PREFIX_KONAMI,
NULL, parodiusjRomInfo, parodiusjRomName, ParodiusInputInfo, ParodiusDIPInfo,
DrvInit, DrvExit, DrvFrame, DrvDraw, DrvScan, &DrvRecalc,
288, 224, 4, 3
};
| [
"[email protected]"
]
| [
[
[
1,
747
]
]
]
|
63fdd97c866de2024b12c317714859c9a1be5b99 | 6e563096253fe45a51956dde69e96c73c5ed3c18 | /dhnetsdk/netsdk/Talk.cpp | aa242ffdd9ecc8de1f70bb8b65e6642baa19bdaf | []
| no_license | 15831944/phoebemail | 0931b76a5c52324669f902176c8477e3bd69f9b1 | e10140c36153aa00d0251f94bde576c16cab61bd | refs/heads/master | 2023-03-16T00:47:40.484758 | 2010-10-11T02:31:02 | 2010-10-11T02:31:02 | null | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 49,672 | cpp |
#include "Talk.h"
#include "RenderManager.h"
#include "VideoRender.h"
#include "DevConfig.h"
#ifdef WIN32
#include "Alaw_encoder.c"
#include "./depend/hisamr.h"
/* $FXN : CTalk()
== ======================================================================
== $DSC : 构造函数，在其中对类的一些成员变量进行了初始化
== $ARG :
== :
== $RET :
== $MOD : 2006-12-20 yehao(10857) Create the Function
== ======================================================================
*/
CTalk::CTalk(CManager *pManager)
: m_pManager(pManager)
{
// InitializeCriticalSection(&m_cs);
m_ARStartSuc = FALSE;
m_iEncodeFlag = 0;
m_render = NULL;
m_hisEncodeHandle = 0;
m_hisDecodeHandle = 0;
}
/* $FXN : ~CTalk()
== ======================================================================
== $DSC : 析构函数，一些善后工作
== $ARG :
== :
== $RET :
== $MOD : 2006-12-20 yehao(10857) Create the Function
== ======================================================================
*/
CTalk::~CTalk()
{
// DeleteCriticalSection(&m_cs);
}
/* $FXN : Init()
== ======================================================================
== $DSC : 模块工作前的初始化工作,初始化的工作可能会失败,所以要从构造函数中分离出来
== $ARG :
== :
== $RET : 0表示成功,非零失败
== $MOD : 2006-12-20 yehao(10857) Create the Function
== ======================================================================
*/
int CTalk::Init()
{
{
list<LPTALKHANDLEINFO>::iterator it = m_talkhandlelist.begin();
for (; it != m_talkhandlelist.end(); it++)
{
if (*it)
{
if ((*it)->pTalkChannel)
{
(*it)->pTalkChannel->close((*it)->pTalkChannel);
}
delete (*it);
}
}
m_talkhandlelist.clear();
}
{
list<LPTALKBROADCASTINFO>::iterator it = m_broadcastlist.begin();
for (; it != m_broadcastlist.end(); it++)
{
if (*it)
{
if ((*it)->pTalkChannel)
{
(*it)->pTalkChannel->close((*it)->pTalkChannel);
}
delete (*it);
}
}
m_broadcastlist.clear();
}
//Begin: Modify by li_deming(11517) 2008-1-14
/*
memset((void *)&m_AudioFormat, 0, sizeof(AUDIOFORMAT));
m_AudioFormat.dwFrameLen = 1024*2;
m_AudioFormat.nAudioBitrate = 64;
m_AudioFormat.nAudioLayer = 5;
m_AudioFormat.wChannels = 1;
m_AudioFormat.dwSamplesPerSec = 8000;
m_AudioFormat.wBitsPerSample = 8;*/
m_FrameLength=2048;//1024*2
//End:li_deming(11517)
m_ARStartSuc = FALSE;
m_dwAudioEncodeType = INTERNEL_ENCODE_TYPE_8K8BPCM;
m_render = m_pManager->GetRenderManager().GetRender((HWND)0xFFFFFFFF);
if (0 == (int)m_render || -1 == (int)m_render)
{
m_render = NULL;
}
if (0 == m_hisEncodeHandle)
{
if (HI_SUCCESS != AMR_Encode_Init(&m_hisEncodeHandle, 0))
{
m_iEncodeFlag = 0;
m_hisEncodeHandle = 0;
m_pManager->SetLastError(NET_ILLEGAL_PARAM);
return NET_ILLEGAL_PARAM;
}
}
/*
其实在render_open之前一定要调用render_init，已经和render库的开发者约定好AUDIO_RENDER_INDEX为对讲模块所用
if (render_open(AUDIO_RENDER_INDEX, 0, 0, 0, NULL, 0, ByDDOffscreen, 0) == 0)
{
m_irenderindex = AUDIO_RENDER_INDEX;
}
*/
m_iEncodeFlag = 0;
return 0;
}
/* $FXN : UnInit()
== ======================================================================
== $DSC : 模块功能不再使用时释放资源.
== $ARG :
== :
== $RET : 0表示成功,非零失败
== $MOD : 2006-12-20 yehao(10857) Create the Function
== ======================================================================
*/
int CTalk::UnInit()
{
// EnterCriticalSection(&m_cs);
m_cs.Lock();
{
list<LPTALKHANDLEINFO>::iterator it = m_talkhandlelist.begin();
for (; it != m_talkhandlelist.end(); it++)
{
if (*it)
{
if ((*it)->pTalkChannel)
{
(*it)->pTalkChannel->close((*it)->pTalkChannel);
}
delete (*it);
}
}
m_talkhandlelist.clear();
}
{
list<LPTALKBROADCASTINFO>::iterator it = m_broadcastlist.begin();
for (; it != m_broadcastlist.end(); it++)
{
if (*it)
{
if ((*it)->pTalkChannel)
{
(*it)->pTalkChannel->close((*it)->pTalkChannel);
}
delete (*it);
}
}
m_broadcastlist.clear();
}
// LeaveCriticalSection(&m_cs);
m_cs.UnLock();
//Begin: Delete by li_deming(11517) 2008-1-14
/*
if (m_RecordHandle != NULL)
{
CloseAudioRecordEx(m_RecordHandle);
m_RecordHandle = 0;
}*/
//End:li_deming(11517)
if (TRUE == m_ARStartSuc)
{
//Begin: Modify by li_deming(11517) 2008-1-14
//UnInitAudioRecordEx();
m_render->CloseAudioRecord();
//End:li_deming(11517)
m_ARStartSuc = FALSE;
}
if (m_render != NULL)
{
m_pManager->GetRenderManager().ReleaseRender(m_render);
m_render = NULL;
}
if (m_hisEncodeHandle != 0)
{
AMR_Encode_Exit(&m_hisEncodeHandle);
}
/*
if (AUDIO_RENDER_INDEX == m_irenderindex)
{
render_close(m_irenderindex);
m_irenderindex = INVALID_RENDER_INDEX;
}
*/
return 0;
}
/* $FXN : StartTalk(LONG lLoginID, pfAudioDataCallBack pfcb, DWORD dwUser)
== ======================================================================
== $DSC : 启动和设备的对讲，实现了和设备之间建立对讲通道
== $ARG : (in)lLoginID就是设备的句柄，(in)pfcb通过它把设备的数据和录音数据(如果在录音的话)回调给用户，
== : (in)dwUser是用户自定义信息
== $RET : -1 or 0表示失败，否则返回一个注册的句柄，通过它调用下面的TalkSendData和StopTalk
== $MOD : 2006-12-20 yehao(10857) Create the Function
== ======================================================================
*/
LONG CTalk::StartTalk(LONG lLoginID, pfAudioDataCallBack pfcb, DWORD dwUser)
{
afk_device_s *device = (afk_device_s *)lLoginID;
int nTalkMode = 0;
BOOL bServerMode = FALSE;
AUDIO_ATTR_T stTalkEncodeType = {0};
device->get_info(device, dit_talk_use_mode, &nTalkMode);
bServerMode = nTalkMode==1? TRUE:FALSE;
device->get_info(device, dit_talk_encode_type, &stTalkEncodeType);
m_dwAudioEncodeType = INTERNEL_ENCODE_TYPE_8K8BPCM;
m_FrameLength=1024;
m_dwSampleRate = 8000;
m_nAudioBit = 8;
if (stTalkEncodeType.iAudioType == 0xFFFF) // 为了兼容性，默认方式就为PCM
{
stTalkEncodeType.iAudioType = 0;
int bufLen = sizeof(DIALOG_CAPS)+16*sizeof(AUDIO_ATTR_T);
char* capBuf = new char[bufLen];
if (NULL == capBuf)
{
return NET_SYSTEM_ERROR;
}
int retlen = 0;
int iRet = m_pManager->GetDevConfig().QuerySystemInfo(lLoginID, SYSTEM_INFO_TALK_ATTR, capBuf, bufLen, &retlen, QUERY_WAIT);
if (iRet >= 0 && retlen >= sizeof(DIALOG_CAPS) && ((retlen-sizeof(DIALOG_CAPS))%sizeof(AUDIO_ATTR_T))==0)
{
DIALOG_CAPS* pDialogCap = (DIALOG_CAPS*)capBuf;
if (0 == pDialogCap->iAudioTypeNum)
{
delete[] capBuf;
return NET_UNSUPPORTED;
}
AUDIO_ATTR_T* pAAT = NULL;
for (int i = 0; i < pDialogCap->iAudioTypeNum; i++)
{
pAAT = (AUDIO_ATTR_T*)(capBuf+sizeof(DIALOG_CAPS)+i*sizeof(AUDIO_ATTR_T));
if(1==pAAT->iAudioType && m_dwAudioEncodeType<INTERNEL_ENCODE_TYPE_8K16BNEWPCM)
{
//设备支持带头信息的PCM 8K 16 Bit
m_dwAudioEncodeType = INTERNEL_ENCODE_TYPE_8K16BNEWPCM;
m_FrameLength=1024;
m_dwSampleRate = pAAT->dwSampleRate;
m_nAudioBit = pAAT->iAudioBit;
}
}
}
if (capBuf != NULL)
{
delete[] capBuf;
capBuf = NULL;
}
}
else if (stTalkEncodeType.iAudioType == 0)
{
m_dwAudioEncodeType = INTERNEL_ENCODE_TYPE_8K8BPCM;
m_FrameLength=1024;
m_dwSampleRate = stTalkEncodeType.dwSampleRate;
m_nAudioBit = stTalkEncodeType.iAudioBit;
}
else if (stTalkEncodeType.iAudioType == 1)
{
m_dwAudioEncodeType = INTERNEL_ENCODE_TYPE_8K16BNEWPCM;
m_FrameLength=1024;
m_dwSampleRate = stTalkEncodeType.dwSampleRate;
m_nAudioBit = stTalkEncodeType.iAudioBit;
}
else if (stTalkEncodeType.iAudioType == 2)
{
m_dwAudioEncodeType = INTERNEL_ENCODE_TYPE_G711A8K16B;
m_FrameLength=1280;
m_dwSampleRate = stTalkEncodeType.dwSampleRate;
m_nAudioBit = stTalkEncodeType.iAudioBit;
}
else if (stTalkEncodeType.iAudioType == 3)
{
m_dwAudioEncodeType = INTERNEL_ENCODE_TYPE_AMR8K16B;
m_FrameLength=320;
m_dwSampleRate = stTalkEncodeType.dwSampleRate;
m_nAudioBit = stTalkEncodeType.iAudioBit;
}
else if (stTalkEncodeType.iAudioType == 4)
{
m_dwAudioEncodeType = INTERNEL_ENCODE_TYPE_G711U8K16B;
m_FrameLength=320;
m_dwSampleRate = stTalkEncodeType.dwSampleRate;
m_nAudioBit = stTalkEncodeType.iAudioBit;
}
else if (stTalkEncodeType.iAudioType == 5)
{
m_dwAudioEncodeType = INTERNEL_ENCODE_TYPE_G7268K16B;
m_FrameLength=320;
m_dwSampleRate = stTalkEncodeType.dwSampleRate;
m_nAudioBit = stTalkEncodeType.iAudioBit;
}
if (NULL == m_render)
{
return NET_NO_TALK_CHANNEL;
}
if (!bServerMode)
{
if (m_render->StartDec(FALSE,
(INTERNEL_ENCODE_TYPE_8K16BNEWPCM==m_dwAudioEncodeType || INTERNEL_ENCODE_TYPE_G711A8K16B==m_dwAudioEncodeType || INTERNEL_ENCODE_TYPE_AMR8K16B==m_dwAudioEncodeType || INTERNEL_ENCODE_TYPE_G711U8K16B==m_dwAudioEncodeType || INTERNEL_ENCODE_TYPE_G7268K16B==m_dwAudioEncodeType) ? 2 : 1) < 0)
{
return NET_RENDER_SOUND_ON_ERROR;
}
}
m_cs.Lock();
LONG lRet = 0;
list<LPTALKHANDLEINFO>::iterator it = m_talkhandlelist.begin();
for (;it != m_talkhandlelist.end(); it++)
{
if ((*it)->lDevHandle == lLoginID)
{
m_cs.UnLock();
return 0;
}
}
afk_talk_channel_param_s talkchannelpar;
LPTALKHANDLEINFO pstTalkInfo = NULL;
pstTalkInfo = new TALKHANDLEINFO;
if (NULL == pstTalkInfo)
{
lRet = NET_SYSTEM_ERROR;
goto FAILED;
}
memset((void *)pstTalkInfo, 0, sizeof(TALKHANDLEINFO));
memset((void *)&talkchannelpar, 0, sizeof(afk_channel_param_s));
talkchannelpar.base.udata = (void *)pstTalkInfo;
talkchannelpar.base.func = CTalk::TalkFunc;
talkchannelpar.no = pstTalkInfo->iChannelId;
talkchannelpar.nEncodeType = stTalkEncodeType.iAudioType==0?1:stTalkEncodeType.iAudioType;
talkchannelpar.nAudioBit = stTalkEncodeType.iAudioBit;
talkchannelpar.dwSampleRate = stTalkEncodeType.dwSampleRate;
pstTalkInfo->pTalkChannel = (afk_channel_s *)device->open_channel(device, AFK_CHANNEL_TYPE_TALK, &talkchannelpar);
if (NULL == pstTalkInfo->pTalkChannel)
{
lRet = NET_OPEN_CHANNEL_ERROR;
goto FAILED;
}
pstTalkInfo->lDevHandle = lLoginID;
pstTalkInfo->pfcb = pfcb;
pstTalkInfo->dwUser = dwUser;
m_talkhandlelist.push_back(pstTalkInfo);
lRet = (LONG)pstTalkInfo;
goto END;
FAILED:
if (pstTalkInfo != NULL)
{
if (pstTalkInfo->pTalkChannel)
{
pstTalkInfo->pTalkChannel->close(pstTalkInfo->pTalkChannel);
}
delete pstTalkInfo;
}
if (!bServerMode)
{
if (m_render != NULL)
{
m_render->CloseAudio();
m_render->StopDec();
}
}
END:
m_cs.UnLock();
return lRet;
}
/* $FXN : SetVolume(LONG lTalkHandle, WORD wVolume)
== ======================================================================
== $DSC : 设置语音对讲的音量，这里的lTalkHandle是通过上面的StartTalk得来的。
== $ARG : (in)lTalkHandle是权限凭证，是上面的StartTalk的返回值，
== : (in)wVolume是要设置的音量值，范围: 0 -- 0xFFFF, 0 音量最小;
== $RET : 成功返回TRUE，否则返回FALSE
== $MOD : 2006-12-20 yehao(10857) Create the Function
== ======================================================================
*/
BOOL CTalk::SetVolume(LONG lTalkHandle, WORD wVolume)
{
// EnterCriticalSection(&m_cs);
m_cs.Lock();
BOOL bRet = FALSE;
list<LPTALKHANDLEINFO>::iterator it = m_talkhandlelist.begin();
for (; it != m_talkhandlelist.end(); it++)
{
if (lTalkHandle == (LONG)(*it))
{
break;
}
}
if (it == m_talkhandlelist.end())
{
m_pManager->SetLastError(NET_INVALID_HANDLE);
bRet = FALSE;
goto END;
}
if (NULL == m_render)
{
m_pManager->SetLastError(NET_NO_TALK_CHANNEL);
bRet = FALSE;
goto END;
}
bRet = m_render->SetAudioVolume(wVolume);
if (!bRet)
{
m_pManager->SetLastError(NET_RENDER_SET_VOLUME_ERROR);
goto END;
}
/*
if (m_irenderindex != AUDIO_RENDER_INDEX)
{
m_pManager->SetLastError(NET_SYSTEM_ERROR);
bRet = FALSE;
goto END;
}
*/
/*
DWORD dwVol;
dwVol = ((0xFFFF*wVolume)/100 << 16 | (0xFFFF*wVolume)/100);
if (render_set_volume(m_irenderindex, dwVol) >= 0)
{
bRet = TRUE;
goto END;
}
*/
//m_pManager->SetLastError(NET_ERROR);
END:
// LeaveCriticalSection(&m_cs);
m_cs.UnLock();
return bRet;
}
/* $FXN : SendData2Dev(LONG lchannel, char *pSendBuf, DWORD dwBufSize)
== ======================================================================
== $DSC : 把pSendBuf,通过lchannel发送给设备，设计这个函数是为了局部功能的模块化。
== $ARG : (in)lchannel是语音对讲的通道句柄，(in)pSendBuf是要发送的数据地址，(in)dwBufSize是要发送的数据长度
== :
== $RET : 成功返回发送的数据长度，失败返回-1 or 0
== $MOD : 2006-12-20 yehao(10857) Create the Function
== ======================================================================
*/
LONG CTalk::SendData2Dev(afk_channel_s *pChannel, char *pSendBuf, DWORD dwBufSize)
{
LONG lRet = 0;
if (NULL == pChannel || NULL == pSendBuf || 0 == dwBufSize)
{
m_pManager->SetLastError(NET_ILLEGAL_PARAM);
return -1;
}
struct afk_talk_info_s tempst;
tempst.data = pSendBuf;
tempst.datalen = dwBufSize;
if (1 == pChannel->set_info(pChannel, 0, &tempst))
{
lRet = dwBufSize;
}
return lRet;
}
/* $FXN : TalkSendData(LONG lTalkHandle, char *pSendBuf, DWORD dwBufSize)
== ======================================================================
== $DSC : 接受用户的请求，要发送数据到设备。
== $ARG : (in)lTalkHandle是上面注册的语音对讲的句柄，(in)pSendBuf是要发送的数据地址，(in)dwBufSize是要发送的数据长度
== :
== $RET : 成功返回发送的数据长度，失败返回-1 or 0
== $MOD : 2006-12-20 yehao(10857) Create the Function
== ======================================================================
*/
LONG CTalk::TalkSendData(LONG lTalkHandle, char *pSendBuf, DWORD dwBufSize)
{
m_cs.Lock();
LONG lRet = 0;
list<LPTALKHANDLEINFO>::iterator it = m_talkhandlelist.begin();
for (; it != m_talkhandlelist.end(); it++)
{
if ((LONG)(*it) == lTalkHandle)
{
break;
}
}
if (it == m_talkhandlelist.end() || NULL == (*it))
{
m_pManager->SetLastError(NET_INVALID_HANDLE);
lRet = -1;
goto END;
}
lRet = SendData2Dev((*it)->pTalkChannel, pSendBuf, dwBufSize);
END:
m_cs.UnLock();
return lRet;
}
/* $FXN : RecordStart()
== ======================================================================
== $DSC : 启动本地录音功能
== $ARG :
== :
== $RET : 成功返回TRUE,失败返回FALSE
== $MOD : 2006-12-20 yehao(10857) Create the Function
== ======================================================================
*/
BOOL CTalk::RecordStart()
{
// EnterCriticalSection(&m_cs);
m_cs.Lock();
//Begin: Modify by li_deming(11517) 2008-1-14
/*
if (FALSE == m_ARStartSuc)
{
if (InitAudioRecordEx(m_AudioFormat) == 1)
{
m_ARStartSuc = TRUE;
}
}
BOOL bRet = FALSE;
if (FALSE == m_ARStartSuc)
{
m_pManager->SetLastError(NET_TALK_INIT_ERROR);
bRet = FALSE;
goto END;
}
if (NULL == m_RecordHandle)
{
m_RecordHandle = OpenAudioRecordEx(CTalk::RecordFunc, (int)this);
if (m_RecordHandle != NULL)
{
bRet = TRUE;
goto END;
}
}
else
{
bRet = TRUE;
goto END;
}
m_pManager->SetLastError(NET_ERROR);*/
BOOL bRet = FALSE;
m_ARStartSuc=FALSE;
bRet=m_render->OpenAudioRecord(CTalk::RecordFunc,m_nAudioBit,m_dwSampleRate,m_FrameLength,0,(long)this);
if(TRUE==bRet)
{
m_ARStartSuc=TRUE;
goto END;
}
m_pManager->SetLastError(NET_ERROR);
//End:li_deming(11517)
END:
// LeaveCriticalSection(&m_cs);
m_cs.UnLock();
return bRet;
}
/* $FXN : RecordStop()
== ======================================================================
== $DSC : 停止本地录音功能
== $ARG :
== :
== $RET : 成功返回TRUE,失败返回FALSE
== $MOD : 2006-12-20 yehao(10857) Create the Function
== ======================================================================
*/
BOOL CTalk::RecordStop()
{
// EnterCriticalSection(&m_cs);
m_cs.Lock();
BOOL bRet = FALSE;
//Begin: Modify by li_deming(11517) 2008-1-14
/*
if (FALSE == m_ARStartSuc)
{
m_pManager->SetLastError(NET_TALK_INIT_ERROR);
bRet = FALSE;
goto END;
}
if (NULL == m_RecordHandle)
{
m_pManager->SetLastError(NET_ERROR);
bRet = FALSE;
}
else
{
if (CloseAudioRecordEx(m_RecordHandle) != 1)
{
m_pManager->SetLastError(NET_ERROR);
bRet = FALSE;
goto END;
}
m_RecordHandle = NULL;
bRet = TRUE;
}
END:
if (TRUE == m_ARStartSuc)
{
UnInitAudioRecordEx();
m_ARStartSuc = FALSE;
}*/
//End:li_deming(11517)
// LeaveCriticalSection(&m_cs);
if(TRUE==m_ARStartSuc)
{
bRet=m_render->CloseAudioRecord();
}
m_cs.UnLock();
return bRet;
}
/* $FXN : AudioDec(char *pAudioDataBuf, DWORD dwBufSize)
== ======================================================================
== $DSC : 实现音频数据解码
== $ARG : (in)pAudioDataBuf是要解码的音频数据，(in)dwBufSize是音频数据的长度
== :
== $RET :
== $MOD : 2006-12-20 yehao(10857) Create the Function
== ======================================================================
*/
void CTalk::AudioDec(char *pAudioDataBuf, DWORD dwBufSize)
{
if (NULL == m_render)
{
return;
}
/*
static FILE* f = NULL;
if (f == NULL)
{
f = fopen("e:\\savetalk.dav", "wb");
if (f == NULL)
{
DWORD dw = GetLastError();
OutputDebugString("damen!\n");
}
}
if (f != NULL)
{
fwrite(pAudioDataBuf, 1, dwBufSize, f);
}
*/
if (INTERNEL_ENCODE_TYPE_8K8BPCM == m_dwAudioEncodeType)
{
for (int i = 0; i < dwBufSize; i++)
{
pAudioDataBuf[i] += 128;
}
}
/*
//test
static FILE* f = NULL;
if (f == NULL)
{
f = fopen("e:\\savetalk.pcm", "wb");
if (f == NULL)
{
DWORD dw = GetLastError();
OutputDebugString("damen!\n");
}
}
if (f != NULL)
{
fwrite(pAudioDataBuf, 1, dwBufSize, f);
}
*/
m_render->Play((BYTE*)pAudioDataBuf, dwBufSize);
/*
if (AUDIO_RENDER_INDEX == m_irenderindex)
{
render_audio(m_irenderindex, (unsigned char *)pAudioDataBuf, dwBufSize, 8, 8000);
}
*/
}
/* $FXN : StopTalk(LONG lTalkHandle)
== ======================================================================
== $DSC : 停止和设备之间的对讲功能
== $ARG : (in)lTalkHandle是启动对讲时得到的对讲句柄
== :
== $RET : 成功返回TRUE，否则返回FALSE
== $MOD : 2006-12-20 yehao(10857) Create the Function
== ======================================================================
*/
BOOL CTalk::StopTalk(LONG lTalkHandle)
{
m_cs.Lock();
BOOL bRet = TRUE;
list<LPTALKHANDLEINFO>::iterator it = m_talkhandlelist.begin();
for (; it != m_talkhandlelist.end(); it++)
{
if ((LONG)(*it) == lTalkHandle)
{
break;
}
}
if (it == m_talkhandlelist.end())
{
bRet = FALSE;
m_pManager->SetLastError(NET_ERROR);
goto END;
}
if (*it)
{
if ((*it)->pTalkChannel)
{
(*it)->pTalkChannel->close((*it)->pTalkChannel);
}
delete (*it);
}
m_talkhandlelist.erase(it);
if (m_render != NULL)
{
if (m_render->StopDec() < 0)
{
#ifdef DEBUG
OutputDebugString("stop dec while stop talk failed!\n");
#endif
}
if (!m_render->CloseAudio())
{
#ifdef DEBUG
OutputDebugString("stop dec while stop talk failed!\n");
#endif
}
}
END:
m_cs.UnLock();
return bRet;
}
/* $FXN : AddDev(LONG lLoginID)
== ======================================================================
== $DSC : 把设备增加到广播组，在本地采集到的数据，模块会自动地发送给广播组中的设备
== $ARG : (in)lLoginID是设备的句柄
== :
== $RET : 成功返回TRUE，否则返回FALSE
== $MOD : 2006-12-20 yehao(10857) Create the Function
== ======================================================================
*/
BOOL CTalk::BroadcastAddDev(LONG lLoginID)
{
if (m_pManager->IsDeviceValid((afk_device_s *)lLoginID) < 0)
{
m_pManager->SetLastError(NET_INVALID_HANDLE);
return FALSE;
}
// EnterCriticalSection(&m_cs);
m_cs.Lock();
list<LPTALKBROADCASTINFO>::iterator it = m_broadcastlist.begin();
for (; it != m_broadcastlist.end(); it++)
{
if ((*it)->lDevHandle == lLoginID)
{
// LeaveCriticalSection(&m_cs);
m_cs.UnLock();
m_pManager->SetLastError(NET_ERROR);
return FALSE;
}
}
BOOL bRet = FALSE;
afk_device_s *device = (afk_device_s *)lLoginID;
afk_talk_channel_param_s talkchannelpar;
LPTALKBROADCASTINFO ptmpinfo = NULL;
ptmpinfo = new TALKBROADCASTINFO;
if (NULL == ptmpinfo)
{
m_pManager->SetLastError(NET_SYSTEM_ERROR);
goto FAILED;
}
memset((void *)ptmpinfo, 0, sizeof(TALKBROADCASTINFO));
memset((void *)&talkchannelpar, 0, sizeof(afk_talk_channel_param_s));
talkchannelpar.base.udata = (void *)ptmpinfo;
talkchannelpar.base.func = NULL;
talkchannelpar.no = ptmpinfo->iChannelId;
ptmpinfo->pTalkChannel = (afk_channel_s *)device->open_channel(device, AFK_CHANNEL_TYPE_TALK, &talkchannelpar);
if (NULL == ptmpinfo->pTalkChannel)
{
m_pManager->SetLastError(NET_OPEN_CHANNEL_ERROR);
goto FAILED;
}
ptmpinfo->lDevHandle = lLoginID;
m_broadcastlist.push_back(ptmpinfo);
bRet = TRUE;
goto END;
FAILED:
bRet = FALSE;
if (ptmpinfo != NULL)
{
if (ptmpinfo->pTalkChannel)
{
ptmpinfo->pTalkChannel->close(ptmpinfo->pTalkChannel);
}
delete ptmpinfo;
}
END:
// LeaveCriticalSection(&m_cs);
m_cs.UnLock();
return bRet;
}
/* $FXN : DelDev(LONG lLoginID)
== ======================================================================
== $DSC : 和AddDev(LONG lLoginID)是相对的功能
== $ARG : (in)lLoginID是设备的句柄
== :
== $RET : 成功返回TRUE，否则返回FALSE
== $MOD : 2006-12-20 yehao(10857) Create the Function
== ======================================================================
*/
BOOL CTalk::BroadcastDelDev(LONG lLoginID)
{
// EnterCriticalSection(&m_cs);
m_cs.Lock();
BOOL bRet = FALSE;
list<LPTALKBROADCASTINFO>::iterator it = m_broadcastlist.begin();
for (; it != m_broadcastlist.end(); it++)
{
if ((*it) && (*it)->lDevHandle == lLoginID)
{
if ((*it)->pTalkChannel)
{
(*it)->pTalkChannel->close((*it)->pTalkChannel);
}
delete (*it);
m_broadcastlist.erase(it);
break;
}
}
if (m_broadcastlist.end() == it)
{
m_pManager->SetLastError(NET_ERROR);
bRet = FALSE;
}
// LeaveCriticalSection(&m_cs);
m_cs.UnLock();
return bRet;
}
/* $FXN : InitAudioEncode(AUDIO_FORMAT aft)
== ======================================================================
== $DSC : 音频编码初始化(标准格式->亿蛙格式)
== $ARG : [in]aft，表示的是要编码的原始数据的音频格式；
== :
== $RET : 成功返回0,失败返回错误码
== $MOD : 2007-03-20 yehao(10857) Create the Function
== ======================================================================
*/
int CTalk::InitAudioEncode(AUDIO_FORMAT aft)
{
if (aft.byFormatTag != 0 || aft.nChannels != 1 || aft.wBitsPerSample != 16 || aft.nSamplesPerSec != 8000)
{
m_iEncodeFlag = 0;
m_pManager->SetLastError(NET_ILLEGAL_PARAM);
return NET_ILLEGAL_PARAM;
}
m_iEncodeFlag = 1;
return 0;
}
/* $FXN : AudioEncode(LONG lHandle, BYTE *lpInBuf, DWORD *lpInLen, BYTE *lpOutBuf, DWORD *lpOutLen)
== ======================================================================
== $DSC : 进行音频数据编码
== $ARG : [in]lHandle，开启对讲的句柄；//目前没有用
== : [in]lpInBuf，要进行编码的源数据；
== : [in,out]lpInBuf，调用时输入的是lpInBuf的数据长度，调用返回时是成功编码的数据长度；
== : [out]lpOutBuf，用来存储编码后的音频数据；
== : [in,out]lpOutLen，调用时表述lpOutBuf的最大长度，如果音频缓冲长度不足而失败时lpOutLen表示要求的数据长度，成功返回时表示lpOutBuf有效数据长度；
== :
== $RET : 成功返回0,失败返回错误码
== $MOD : 2006-12-20 yehao(10857) Create the Function
== ======================================================================
*/
int CTalk::AudioEncode(LONG lHandle, BYTE *lpInBuf, DWORD *lpInLen, BYTE *lpOutBuf, DWORD *lpOutLen)
{
if (0 == m_iEncodeFlag)
{
m_pManager->SetLastError(NET_AUDIOENCODE_NOTINIT);
return NET_AUDIOENCODE_NOTINIT;
}
if (NULL == lpInBuf || NULL == lpInLen || NULL == lpOutBuf || NULL == lpOutLen || 0 == *lpInLen)
{
m_pManager->SetLastError(NET_ILLEGAL_PARAM);
return NET_ILLEGAL_PARAM;
}
if (*lpInLen >= MAX_ENCODE_LEN*2)
{
*lpInLen = MAX_ENCODE_LEN*2;
m_pManager->SetLastError(NET_DATA_TOOLONGH);
return NET_DATA_TOOLONGH;
}
if (*lpOutLen < (*lpInLen/2 + 8))
{
*lpOutLen = *lpInLen/2 + 8;
m_pManager->SetLastError(NET_INSUFFICIENT_BUFFER);
return NET_INSUFFICIENT_BUFFER;
}
int iRet = 0;
int iCount = 0;
int iDataLen = (*lpInLen>>1);
unsigned short *p16 = (unsigned short *)lpInBuf;
lpOutBuf[iCount++] = 0x00;
lpOutBuf[iCount++] = 0x00;
lpOutBuf[iCount++] = 0x01;
lpOutBuf[iCount++] = 0xf0;
lpOutBuf[iCount++] = 0x07;
lpOutBuf[iCount++] = 0x02;
*(unsigned short *)(lpOutBuf+iCount) = (unsigned short)iDataLen;
iCount += 2;
for (int i = 0; i < iDataLen; i++)
{
lpOutBuf[iCount++] = BYTE(*p16>>8);
p16++;
}
*lpOutLen = iCount;
*lpInLen = 0;
return iRet;
}
/* $FXN : ReleaseAudioEncode(LONG lHandle)
== ======================================================================
== $DSC : 音频解码完成退出
== $ARG :
== :
== $RET : 成功返回0,失败返回非零的错误码
== $MOD : 2007-03-20 yehao(10857) Create the Function
== ======================================================================
*/
int CTalk::ReleaseAudioEncode()
{
// EnterCriticalSection(&m_cs);
m_cs.Lock();
m_iEncodeFlag = 0;
// LeaveCriticalSection(&m_cs);
m_cs.UnLock();
return 0;
}
/* $FXN : InitAudioDecode(AUDIO_FORMAT aft)
== ======================================================================
== $DSC : 音频解码的初始化(亿蛙格式->标准格式)
== $ARG : [in]aft，要转换的目标音频格式；
== :
== $RET : 成功返回有效句柄,失败返回无效句柄
== $MOD : 2007-03-20 yehao(10857) Create the Function
== ======================================================================
*/
LONG CTalk::InitAudioDecode(AUDIO_FORMAT aft)
{
LONG lRet = (LONG)INVALID_HANDLE_VALUE;
return lRet;
}
/* $FXN : AudioDecode(LONG lHandle, BYTE *lpInBuf, DWORD *lpInLen, BYTE *lpOutBuf, DWORD *lpOutLen)
== ======================================================================
== $DSC : 进行数据解码
== $ARG : [in]lHandle，其值就是上面的初始化的返回值；
== : [in]lpInBuf，要求解码的原音频数据；
== : [in,out]lpInLen，调用时表示lpInBuf的长度，返回时其值是没有完成解码的数据长度；
== : [in]lpOutBuf，用来存放解码后的音频数据；
== : [in,out]lpOutLen，调用时表示lpOutBuf的缓冲最大长度，如果音频缓冲长度不足而失败时lpOutLen表示要求的数据长度，成功返回时表示lpOutBuf有效数据长度；
== :
== $RET : 成功返回0,失败返回非零的错误码
== $MOD : 2007-03-20 yehao(10857) Create the Function
== ======================================================================
*/
int CTalk::AudioDecode(LONG lHandle, BYTE *lpInBuf, DWORD *lpInLen, BYTE *lpOutBuf, DWORD *lpOutLen)
{
int iRet = 0;
return iRet;
}
/* $FXN : ReleaseAudioDecode(LONG lHandle)
== ======================================================================
== $DSC : 完成解码，退出
== $ARG : [in]lHandle，上面的初始化接口的返回值；
== :
== $RET : 成功返回0,失败返回非零的错误码
== $MOD : 2007-03-20 yehao(10857) Create the Function
== ======================================================================
*/
int CTalk::ReleaseAudioDecode(LONG lHandle)
{
int iRet = 0;
return iRet;
}
/* $FXN : CloseChannelOfDevice(afk_device_s * pdev)
== ======================================================================
== $DSC : 关闭和pdev设备相关的所以通道
== $ARG : [in]pdev,关联的设备
== :
== $RET : 成功返回0,失败返回非零的错误码
== $MOD : 2006-12-20 yehao(10857) Create the Function
== ======================================================================
*/
int CTalk::CloseChannelOfDevice(afk_device_s * pdev)
{
// EnterCriticalSection(&m_cs);
m_cs.Lock();
int iRet = 0;
{
list<LPTALKHANDLEINFO>::iterator it = m_talkhandlelist.begin();
for (; it != m_talkhandlelist.end(); it++)
{
if ((*it)->lDevHandle == LONG(pdev))
{
if ((*it)->pTalkChannel != NULL)
{
(*it)->pTalkChannel->close((*it)->pTalkChannel);
}
delete (*it);
m_talkhandlelist.erase(it);
break;
}
}
}
{
list<LPTALKBROADCASTINFO>::iterator it = m_broadcastlist.begin();
for (; it != m_broadcastlist.end(); it++)
{
if ((*it)->lDevHandle == LONG(pdev))
{
if ((*it)->pTalkChannel != NULL)
{
(*it)->pTalkChannel->close((*it)->pTalkChannel);
}
delete (*it);
m_broadcastlist.erase(it);
break;
}
}
}
// LeaveCriticalSection(&m_cs);
m_cs.UnLock();
return iRet;
}
/* $FXN : TalkFunc(...)
== ======================================================================
== $DSC : 打开和设备的对讲通道时注册的回调函数
== $ARG :
== :
== $RET :
== $MOD : 2006-12-20 yehao(10857) Create the Function
== ======================================================================
*/
int WINAPI CTalk::TalkFunc(
afk_handle_t object,
unsigned char *data,
unsigned int datalen,
void *param,
void *udata)
{
LPTALKHANDLEINFO pTalkHandle = (LPTALKHANDLEINFO)udata;
if (pTalkHandle == NULL || 0 == datalen)
{
return -1;
}
if (pTalkHandle->pfcb)
{
pTalkHandle->pfcb((LONG)pTalkHandle, (char *)data, datalen, 1, pTalkHandle->dwUser);
}
return 0;
}
/* $FXN : RecordFunc(LPBYTE pDataBuffer, DWORD DataLength, int user)
== ======================================================================
== $DSC : 注册录音库时的注册回调函数，在其中除了把音频数据回调给对讲用户外，还发送给广播组中的设备。
== $ARG : (in)pDataBuffer是录音音频数据，(in)是音频数据长度,(in)注册录音库时的用户自定义信息
== :
== $RET :
== $MOD : 2006-12-20 yehao(10857) Create the Function
== ======================================================================
*/
//Begin: Modify by li_deming(11517) 2008-1-14
//void WINAPI CTalk::RecordFunc(LPBYTE pDataBuffer, DWORD DataLength, int user)
void WINAPI CTalk::RecordFunc(LPBYTE pDataBuffer, DWORD DataLength, long user)
//End:li_deming(11517)
{
/*
//test
static FILE* ff = NULL;
int jjj = 0;
if (ff == NULL)
{
ff = fopen("e:\\savetalk1.pcm", "wb");
if (ff == NULL)
{
DWORD dw = GetLastError();
OutputDebugString("damen!\n");
}
}
if (ff != NULL)
{
fwrite(pDataBuffer, 1, DataLength, ff);
}
*/
if (NULL == pDataBuffer || 0 == DataLength)
{
return;
}
CTalk *ptalk = (CTalk *)user;
if (NULL == ptalk)
{
return;
}
char* pCbData = NULL;
pCbData = new char[DataLength+100]; //如果说编完码比原来的数据还大，则会挂。。
if (NULL == pCbData)
{
return;
}
int iCbLen = 0;
if ((ptalk->GetAudioEncodeType() == INTERNEL_ENCODE_TYPE_8K8BPCM) || (ptalk->GetAudioEncodeType() == INTERNEL_ENCODE_TYPE_8K16BNEWPCM))
{
if (ptalk->GetAudioEncodeBit() == 8)
{
for( int j = 0 ; j < DataLength; j++)
{
*(pDataBuffer + j) += 128;
}
}
pCbData[0]=0x00;
pCbData[1]=0x00;
pCbData[2]=0x01;
pCbData[3]=0xF0;
pCbData[4]= 8 == ptalk->GetAudioEncodeBit() ? 0x07:0x0C; //pcm8:0x07; pcm16:0x0C
pCbData[5]=0x02;//8k
*(DWORD*)(pCbData+6)=DataLength;
memcpy(pCbData+8, pDataBuffer, DataLength);
iCbLen = 8+DataLength;
/*
//从16bit转至8bit
iCbLen = DataLength+8;
DWORD dwRecordDataSize = DataLength;
unsigned short *p16 = (unsigned short *)pDataBuffer;
BYTE *pu8 = (BYTE *)pDataBuffer;
int i = 0;
dwRecordDataSize = DataLength>>1;
while(dwRecordDataSize>0)
{
pCbData[i++]=0x00;
pCbData[i++]=0x00;
pCbData[i++]=0x01;
pCbData[i++]=0xF0;
pCbData[i++]=0x07;//pcm8
pCbData[i++]=0x02;//8k
if(dwRecordDataSize>=1024)
{
pCbData[i++]=0x00;
pCbData[i++]=0x04;
for(int j=0;j<1024;j++)
{
pCbData[i++]=BYTE(*p16>>8);
p16++;
}
dwRecordDataSize-=1024;
}
else
{
pCbData[i++]=BYTE(dwRecordDataSize&0xff);
pCbData[i++]=BYTE(dwRecordDataSize>>8);
for(int j=0;j<(int)dwRecordDataSize;j++)
{
pCbData[i++]=BYTE(*p16>>8);
p16++;
}
dwRecordDataSize=0;
}
iCbLen = i;
}
*/
}
else if (ptalk->GetAudioEncodeType() == INTERNEL_ENCODE_TYPE_G711A8K16B)
{
if (g711a_Encode((char*)pDataBuffer, pCbData+8, DataLength, &iCbLen) != 1)
{
delete pCbData;
return;
}
//亿蛙码流格式帧头
pCbData[0]=0x00;
pCbData[1]=0x00;
pCbData[2]=0x01;
pCbData[3]=0xF0;
pCbData[4]=0x0E; //G711A
pCbData[5]=0x02;
pCbData[6]=BYTE(iCbLen&0xff);
pCbData[7]=BYTE(iCbLen>>8);
iCbLen += 8;
}
else if (ptalk->GetAudioEncodeType() == INTERNEL_ENCODE_TYPE_AMR8K16B)
{
//AMR encode
iCbLen = AMR_Encode_Frame(ptalk->GetHisEncodeHandle(),(HI_S16*)pDataBuffer,
(HI_U8*)(pCbData+8),MR102,MIME);
if (iCbLen <= 0)
{
delete pCbData;
return;
}
pCbData[0]=0x00;
pCbData[1]=0x00;
pCbData[2]=0x01;
pCbData[3]=0xF0;
pCbData[4]=0x14; //AMR
pCbData[5]=0x02;
pCbData[6]=BYTE(iCbLen&0xff);
pCbData[7]=BYTE(iCbLen>>8);
iCbLen += 8;
}
else if (ptalk->GetAudioEncodeType() == INTERNEL_ENCODE_TYPE_G711U8K16B)
{
if (g711u_Encode((char*)pDataBuffer, pCbData+8, DataLength, &iCbLen) != 1)
{
delete pCbData;
return;
}
//亿蛙码流格式帧头
pCbData[0]=0x00;
pCbData[1]=0x00;
pCbData[2]=0x01;
pCbData[3]=0xF0;
pCbData[4]=0x0A; //G711u
pCbData[5]=0x02;
pCbData[6]=BYTE(iCbLen&0xff);
pCbData[7]=BYTE(iCbLen>>8);
iCbLen += 8;
}
else
{
return;
}
/*
//test
static FILE* ff2 = NULL;
if (ff2 == NULL)
{
ff2 = fopen("e:\\savetalk-enc.pcm", "wb");
if (ff2 == NULL)
{
DWORD dw = GetLastError();
OutputDebugString("damen!\n");
}
}
if (ff2 != NULL)
{
fwrite(pCbData, 1, iCbLen, ff2);
}
*/
// EnterCriticalSection(&ptalk->m_cs);
ptalk->m_cs.Lock();
{
list<LPTALKHANDLEINFO>::iterator it = ptalk->m_talkhandlelist.begin();
for (; it != ptalk->m_talkhandlelist.end(); it++)
{
if (*it && (*it)->pfcb)
{
(*it)->pfcb(LONG(*it), pCbData, iCbLen, 0, (*it)->dwUser);
//(*it)->pfcb(LONG(*it), newdata, DataLength+8, 0, (*it)->dwUser);
}
}
}
{
list<LPTALKBROADCASTINFO>::iterator it = ptalk->m_broadcastlist.begin();
for (; it != ptalk->m_broadcastlist.end(); it++)
{
if ((*it) && (*it)->pTalkChannel)
{
ptalk->SendData2Dev(((*it)->pTalkChannel), pCbData, iCbLen);
}
}
}
// LeaveCriticalSection(&ptalk->m_cs);
ptalk->m_cs.UnLock();
delete[] pCbData;
}
#else //linux
CTalk::CTalk(CManager &man):m_man(man)
{
m_ARStartSuc = FALSE;
m_iEncodeFlag = 0;
m_render = NULL;
m_hisEncodeHandle = 0;
m_hisDecodeHandle = 0;
}
CTalk::~CTalk()
{
}
int CTalk::Init()
{
{
list<LPTALKHANDLEINFO>::iterator it = m_talkhandlelist.begin();
for (; it != m_talkhandlelist.end(); it++)
{
if (*it)
{
if ((*it)->pTalkChannel)
{
(*it)->pTalkChannel->close((*it)->pTalkChannel);
}
delete (*it);
}
}
m_talkhandlelist.clear();
}
{
list<LPTALKBROADCASTINFO>::iterator it = m_broadcastlist.begin();
for (; it != m_broadcastlist.end(); it++)
{
if (*it)
{
if ((*it)->pTalkChannel)
{
(*it)->pTalkChannel->close((*it)->pTalkChannel);
}
delete (*it);
}
}
m_broadcastlist.clear();
}
m_ARStartSuc = FALSE;
m_dwAudioEncodeType = INTERNEL_ENCODE_TYPE_8K8BPCM;
m_render = m_pManager->GetRenderManager().GetRender((HWND)0xFFFFFFFF);
if (0 == (int)m_render || -1 == (int)m_render)
{
m_render = NULL;
}
m_iEncodeFlag = 0;
return 0;
}
int CTalk::UnInit()
{
// EnterCriticalSection(&m_cs);
m_cs.Lock();
{
list<LPTALKHANDLEINFO>::iterator it = m_talkhandlelist.begin();
for (; it != m_talkhandlelist.end(); it++)
{
if (*it)
{
if ((*it)->pTalkChannel)
{
(*it)->pTalkChannel->close((*it)->pTalkChannel);
}
delete (*it);
}
}
m_talkhandlelist.clear();
}
{
list<LPTALKBROADCASTINFO>::iterator it = m_broadcastlist.begin();
for (; it != m_broadcastlist.end(); it++)
{
if (*it)
{
if ((*it)->pTalkChannel)
{
(*it)->pTalkChannel->close((*it)->pTalkChannel);
}
delete (*it);
}
}
m_broadcastlist.clear();
}
// LeaveCriticalSection(&m_cs);
m_cs.UnLock();
if (m_render != NULL)
{
m_pManager->GetRenderManager().ReleaseRender(m_render);
m_render = NULL;
}
return 0;
}
LONG CTalk::StartTalk(LONG lLoginID, pfAudioDataCallBack pfcb, DWORD dwUser)
{
if (m_pManager->IsDeviceValid((afk_device_s *)lLoginID) < 0)
{
m_pManager->SetLastError(NET_INVALID_HANDLE);
return 0;
}
afk_device_s *device = (afk_device_s *)lLoginID;
int nTalkMode = 0;
BOOL bServerMode = FALSE;
device->get_info(device, dit_talk_use_mode, &nTalkMode);
bServerMode = nTalkMode==1? TRUE:FALSE;
//先查询设备支持的音频编码格式
int bufLen = sizeof(DIALOG_CAPS)+16*sizeof(AUDIO_ATTR_T);
char* capBuf = new char[bufLen];
if (NULL == capBuf)
{
m_pManager->SetLastError(NET_SYSTEM_ERROR);
return FALSE;
}
int retlen = 0;
int iRet = m_pManager->GetDevConfig().QuerySystemInfo(lLoginID, SYSTEM_INFO_TALK_ATTR, capBuf, bufLen, &retlen, QUERY_WAIT);
if (iRet >= 0 && retlen >= sizeof(DIALOG_CAPS) && ((retlen-sizeof(DIALOG_CAPS))%sizeof(AUDIO_ATTR_T))==0)
{
DIALOG_CAPS* pDialogCap = (DIALOG_CAPS*)capBuf;
if (0 == pDialogCap->iAudioTypeNum)
{
int tecType = 0;
device->set_info(device, dit_talk_encode_type, &tecType);
delete capBuf;
m_pManager->SetLastError(NET_UNSUPPORTED);
return FALSE;
}
AUDIO_ATTR_T* pAAT = NULL;
for (int i = 0; i < pDialogCap->iAudioTypeNum; i++)
{
pAAT = (AUDIO_ATTR_T*)(capBuf+sizeof(DIALOG_CAPS)+i*sizeof(AUDIO_ATTR_T));
if (2 == pAAT->iAudioType && 16 == pAAT->iAudioBit && 8000 == pAAT->dwSampleRate
&& m_dwAudioEncodeType < INTERNEL_ENCODE_TYPE_G711A8K16B)
{
//设备支持G711 8K 16 Bit
m_dwAudioEncodeType = INTERNEL_ENCODE_TYPE_G711A8K16B;
// m_AudioFormat.dwFrameLen = 320;
int tecType = 2;
device->set_info(device, dit_talk_encode_type, &tecType);
}
if (3 == pAAT->iAudioType && 16 == pAAT->iAudioBit && 8000 == pAAT->dwSampleRate
&& m_dwAudioEncodeType < INTERNEL_ENCODE_TYPE_AMR8K16B)
{
//设备支持AMR 8K 16 Bit
m_dwAudioEncodeType = INTERNEL_ENCODE_TYPE_AMR8K16B;
// m_AudioFormat.dwFrameLen = 320;
int tecType = 3;
device->set_info(device, dit_talk_encode_type, &tecType);
}
}
}
delete capBuf;
if (NULL == m_render)
{
m_pManager->SetLastError(NET_NO_TALK_CHANNEL);
return 0;
}
if (!bServerMode)
{
if (m_render->StartDec(FALSE,
(INTERNEL_ENCODE_TYPE_G711A8K16B==m_dwAudioEncodeType || INTERNEL_ENCODE_TYPE_AMR8K16B==m_dwAudioEncodeType) ? 2 : 1) < 0)
{
m_pManager->SetLastError(NET_RENDER_SOUND_ON_ERROR);
return 0;
}
}
// EnterCriticalSection(&m_cs);
m_cs.Lock();
LONG lRet = 0;
list<LPTALKHANDLEINFO>::iterator it = m_talkhandlelist.begin();
for (;it != m_talkhandlelist.end(); it++)
{
if ((*it)->lDevHandle == lLoginID)
{
// LeaveCriticalSection(&m_cs);
m_cs.UnLock();
return 0;
}
}
afk_talk_channel_param_s talkchannelpar;
LPTALKHANDLEINFO ptmpinfo = NULL;
ptmpinfo = new TALKHANDLEINFO;
if (NULL == ptmpinfo)
{
m_pManager->SetLastError(NET_SYSTEM_ERROR);
lRet = 0;
goto FAILED;
}
memset((void *)ptmpinfo, 0, sizeof(TALKHANDLEINFO));
memset((void *)&talkchannelpar, 0, sizeof(afk_channel_param_s));
talkchannelpar.base.udata = (void *)ptmpinfo;
talkchannelpar.base.func = CTalk::TalkFunc;
talkchannelpar.no = ptmpinfo->iChannelId;
ptmpinfo->pTalkChannel = (afk_channel_s *)device->open_channel(device, AFK_CHANNEL_TYPE_TALK, &talkchannelpar);
if (NULL == ptmpinfo->pTalkChannel)
{
m_pManager->SetLastError(NET_OPEN_CHANNEL_ERROR);
lRet = 0;
goto FAILED;
}
ptmpinfo->lDevHandle = lLoginID;
ptmpinfo->pfcb = pfcb;
ptmpinfo->dwUser = dwUser;
m_talkhandlelist.push_back(ptmpinfo);
lRet = (LONG)ptmpinfo;
goto END;
FAILED:
if (ptmpinfo != NULL)
{
if (ptmpinfo->pTalkChannel)
{
ptmpinfo->pTalkChannel->close(ptmpinfo->pTalkChannel);
}
delete ptmpinfo;
}
if (!bServerMode)
{
if (m_render != NULL)
{
m_render->CloseAudio();
m_render->StopDec();
}
}
END:
// LeaveCriticalSection(&m_cs);
m_cs.UnLock();
return lRet;
}
BOOL CTalk::SetVolume(LONG lTalkHandle, WORD wVolume)
{
return FALSE;
}
LONG CTalk::SendData2Dev(afk_channel_s *pChannel, char *pSendBuf, DWORD dwBufSize)
{
LONG lRet = 0;
if (NULL == pChannel || NULL == pSendBuf || 0 == dwBufSize)
{
m_pManager->SetLastError(NET_ILLEGAL_PARAM);
return -1;
}
struct afk_talk_info_s tempst;
tempst.data = pSendBuf;
tempst.datalen = dwBufSize;
if (1 == pChannel->set_info(pChannel, 0, &tempst))
{
lRet = dwBufSize;
}
return lRet;
}
LONG CTalk::TalkSendData(LONG lTalkHandle, char *pSendBuf, DWORD dwBufSize)
{
// EnterCriticalSection(&m_cs);
m_cs.Lock();
LONG lRet = 0;
list<LPTALKHANDLEINFO>::iterator it = m_talkhandlelist.begin();
for (; it != m_talkhandlelist.end(); it++)
{
if ((LONG)(*it) == lTalkHandle)
{
break;
}
}
if (it == m_talkhandlelist.end() || NULL == (*it))
{
m_pManager->SetLastError(NET_INVALID_HANDLE);
lRet = -1;
goto END;
}
lRet = SendData2Dev((*it)->pTalkChannel, pSendBuf, dwBufSize);
END:
// LeaveCriticalSection(&m_cs);
m_cs.UnLock();
return lRet;
}
BOOL CTalk::RecordStart()
{
return FALSE;
}
BOOL CTalk::RecordStop()
{
return FALSE;
}
void CTalk::AudioDec(char *pAudioDataBuf, DWORD dwBufSize)
{
}
BOOL CTalk::StopTalk(LONG lTalkHandle)
{
return FALSE;
}
BOOL CTalk::BroadcastAddDev(LONG lLoginID)
{
if (m_pManager->IsDeviceValid((afk_device_s *)lLoginID) < 0)
{
m_pManager->SetLastError(NET_INVALID_HANDLE);
return FALSE;
}
// EnterCriticalSection(&m_cs);
m_cs.Lock();
list<LPTALKBROADCASTINFO>::iterator it = m_broadcastlist.begin();
for (; it != m_broadcastlist.end(); it++)
{
if ((*it)->lDevHandle == lLoginID)
{
// LeaveCriticalSection(&m_cs);
m_cs.UnLock();
m_pManager->SetLastError(NET_ERROR);
return FALSE;
}
}
BOOL bRet = FALSE;
afk_device_s *device = (afk_device_s *)lLoginID;
afk_talk_channel_param_s talkchannelpar;
LPTALKBROADCASTINFO ptmpinfo = NULL;
ptmpinfo = new TALKBROADCASTINFO;
if (NULL == ptmpinfo)
{
m_pManager->SetLastError(NET_SYSTEM_ERROR);
goto FAILED;
}
memset((void *)ptmpinfo, 0, sizeof(TALKBROADCASTINFO));
memset((void *)&talkchannelpar, 0, sizeof(afk_talk_channel_param_s));
talkchannelpar.base.udata = (void *)ptmpinfo;
talkchannelpar.base.func = NULL;
talkchannelpar.no = ptmpinfo->iChannelId;
ptmpinfo->pTalkChannel = (afk_channel_s *)device->open_channel(device, AFK_CHANNEL_TYPE_TALK, &talkchannelpar);
if (NULL == ptmpinfo->pTalkChannel)
{
m_pManager->SetLastError(NET_OPEN_CHANNEL_ERROR);
goto FAILED;
}
ptmpinfo->lDevHandle = lLoginID;
m_broadcastlist.push_back(ptmpinfo);
bRet = TRUE;
goto END;
FAILED:
bRet = FALSE;
if (ptmpinfo != NULL)
{
if (ptmpinfo->pTalkChannel)
{
ptmpinfo->pTalkChannel->close(ptmpinfo->pTalkChannel);
}
delete ptmpinfo;
}
END:
// LeaveCriticalSection(&m_cs);
m_cs.UnLock();
return bRet;
}
BOOL CTalk::BroadcastDelDev(LONG lLoginID)
{
// EnterCriticalSection(&m_cs);
m_cs.Lock();
BOOL bRet = FALSE;
list<LPTALKBROADCASTINFO>::iterator it = m_broadcastlist.begin();
for (; it != m_broadcastlist.end(); it++)
{
if ((*it) && (*it)->lDevHandle == lLoginID)
{
if ((*it)->pTalkChannel)
{
(*it)->pTalkChannel->close((*it)->pTalkChannel);
}
delete (*it);
m_broadcastlist.erase(it);
break;
}
}
if (m_broadcastlist.end() == it)
{
m_pManager->SetLastError(NET_ERROR);
bRet = FALSE;
}
// LeaveCriticalSection(&m_cs);
m_cs.UnLock();
return bRet;
}
int CTalk::InitAudioEncode(AUDIO_FORMAT aft)
{
if (aft.byFormatTag != 0 || aft.nChannels != 1 || aft.wBitsPerSample != 16 || aft.nSamplesPerSec != 8000)
{
m_iEncodeFlag = 0;
m_pManager->SetLastError(NET_ILLEGAL_PARAM);
return NET_ILLEGAL_PARAM;
}
m_iEncodeFlag = 1;
return 0;
}
int CTalk::AudioEncode(LONG lHandle, BYTE *lpInBuf, DWORD *lpInLen, BYTE *lpOutBuf, DWORD *lpOutLen)
{
if (0 == m_iEncodeFlag)
{
m_pManager->SetLastError(NET_AUDIOENCODE_NOTINIT);
return NET_AUDIOENCODE_NOTINIT;
}
if (NULL == lpInBuf || NULL == lpInLen || NULL == lpOutBuf || NULL == lpOutLen || 0 == *lpInLen)
{
m_pManager->SetLastError(NET_ILLEGAL_PARAM);
return NET_ILLEGAL_PARAM;
}
if (*lpInLen >= MAX_ENCODE_LEN*2)
{
*lpInLen = MAX_ENCODE_LEN*2;
m_pManager->SetLastError(NET_DATA_TOOLONGH);
return NET_DATA_TOOLONGH;
}
if (*lpOutLen < (*lpInLen/2 + 8))
{
*lpOutLen = *lpInLen/2 + 8;
m_pManager->SetLastError(NET_INSUFFICIENT_BUFFER);
return NET_INSUFFICIENT_BUFFER;
}
int iRet = 0;
int iCount = 0;
int iDataLen = (*lpInLen>>1);
unsigned short *p16 = (unsigned short *)lpInBuf;
lpOutBuf[iCount++] = 0x00;
lpOutBuf[iCount++] = 0x00;
lpOutBuf[iCount++] = 0x01;
lpOutBuf[iCount++] = 0xf0;
lpOutBuf[iCount++] = 0x07;
lpOutBuf[iCount++] = 0x02;
*(unsigned short *)(lpOutBuf+iCount) = (unsigned short)iDataLen;
iCount += 2;
for (int i = 0; i < iDataLen; i++)
{
lpOutBuf[iCount++] = (BYTE)(*p16>>8);
p16++;
}
*lpOutLen = iCount;
*lpInLen = 0;
return iRet;
}
int CTalk::ReleaseAudioEncode()
{
// EnterCriticalSection(&m_cs);
m_cs.Lock();
m_iEncodeFlag = 0;
// LeaveCriticalSection(&m_cs);
m_cs.UnLock();
return 0;
}
LONG CTalk::InitAudioDecode(AUDIO_FORMAT aft)
{
return 0;
}
int CTalk::AudioDecode(LONG lHandle, BYTE *lpInBuf, DWORD *lpInLen, BYTE *lpOutBuf, DWORD *lpOutLen)
{
return 0;
}
int CTalk::ReleaseAudioDecode(LONG lHandle)
{
return 0;
}
int CTalk::CloseChannelOfDevice(afk_device_s * pdev)
{
// EnterCriticalSection(&m_cs);
m_cs.Lock();
int iRet = 0;
{
list<LPTALKHANDLEINFO>::iterator it = m_talkhandlelist.begin();
for (; it != m_talkhandlelist.end(); it++)
{
if ((*it)->lDevHandle == LONG(pdev))
{
if ((*it)->pTalkChannel != NULL)
{
(*it)->pTalkChannel->close((*it)->pTalkChannel);
}
delete (*it);
m_talkhandlelist.erase(it);
break;
}
}
}
{
list<LPTALKBROADCASTINFO>::iterator it = m_broadcastlist.begin();
for (; it != m_broadcastlist.end(); it++)
{
if ((*it)->lDevHandle == LONG(pdev))
{
if ((*it)->pTalkChannel != NULL)
{
(*it)->pTalkChannel->close((*it)->pTalkChannel);
}
delete (*it);
m_broadcastlist.erase(it);
break;
}
}
}
// LeaveCriticalSection(&m_cs);
m_cs.UnLock();
return iRet;
}
int CTalk::WINAPI TalkFunc(afk_handle_t object,
unsigned char *data,
unsigned int datalen,
void *param,
void *udata)
{
if (NULL == data || 0 == datalen)
{
return -1;
}
int iRet = 0;
LPTALKHANDLEINFO pTalkHandle = (LPTALKHANDLEINFO)udata;
if (pTalkHandle && pTalkHandle->pfcb)
{
pTalkHandle->pfcb((LONG)pTalkHandle, (char *)data, datalen, 1, pTalkHandle->dwUser);
}
return iRet;
}
void CTalk::WINAPI RecordFunc(LPBYTE pDataBuffer, DWORD DataLength, /*int*/long user)
{
}
#endif
| [
"guoqiao@a83c37f4-16cc-5f24-7598-dca3a346d5dd"
]
| [
[
[
1,
1969
]
]
]
|
12609899c2e43fa2c322a4d5a5b746a1a894cb28 | 63fc6506b8e438484a013b3c341a1f07f121686b | /addons/ofxOpenCv/example/testApp.h | fafa37330eed0e7ad7dcffa72429e3a2ff43aa8e | []
| no_license | progen/ofx-dev | c5a54d3d588d8fd7318e35e9b57bf04c62cda5a8 | 45125fcab657715abffc7e84819f8097d594e28c | refs/heads/master | 2021-01-20T07:15:39.755316 | 2009-03-03T22:33:37 | 2009-03-03T22:33:37 | 140,479 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 934 | h | #ifndef _TEST_APP
#define _TEST_APP
#include "ofMain.h"
#define OF_ADDON_USING_OFXOPENCV
#include "ofAddons.h"
#define _USE_LIVE_VIDEO // uncomment this to use a live camera
// otherwise, we'll use a movie file
class testApp : public ofSimpleApp{
public:
void setup();
void update();
void draw();
void keyPressed (int key);
void mouseMoved(int x, int y );
void mouseDragged(int x, int y, int button);
void mousePressed(int x, int y, int button);
void mouseReleased();
#ifdef _USE_LIVE_VIDEO
ofVideoGrabber vidGrabber;
#else
ofVideoPlayer vidPlayer;
#endif
ofxCvColorImage colorImg;
ofxCvGrayscaleImage grayImage;
ofxCvGrayscaleImage grayBg;
ofxCvGrayscaleImage grayDiff;
ofxCvContourFinder contourFinder;
int threshold;
bool bLearnBakground;
};
#endif
| [
"[email protected]"
]
| [
[
[
1,
48
]
]
]
|
6f8efd08614e1cae7b141d6da2a3730cb17ab6f2 | d57f646dc96686ef496054d073d4d495b6036b9b | /NetPipe.NET/ServiceManager.cpp | b8bf5bafd9acc49f6e660407a00c7c4eab47fd74 | [
"BSD-2-Clause"
]
| permissive | limura/netpipe | 00d65fd542d3bab833acf24a1a27ac7fd767503a | 1e363a21e299bc2bab4f902c8e70c66786ea8e5b | refs/heads/master | 2021-01-19T13:50:41.041736 | 2007-10-02T10:25:13 | 2007-10-02T10:25:13 | 32,438,427 | 0 | 1 | null | null | null | null | SHIFT_JIS | C++ | false | false | 6,256 | cpp | /*
* Copyright (c) 2007 IIMURA Takuji. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $Id$
*/
#include "stdafx.h"
#include "NetPipe.NET.h"
#include <gcroot.h>
#include <map>
#include <NetPipe.h>
#include <MainLoop.h>
#include <ServiceManager.h>
#include <ServiceCreator.h>
#include <Service.h>
#using <mscorlib.dll>
namespace NetPipeDotNET {
ServiceManager::ServiceManager(System::String ^serviceName){
char *name = static_cast<char*>((System::Runtime::InteropServices::Marshal::StringToHGlobalAnsi(serviceName)).ToPointer());
UmServiceManager = new NetPipe::ServiceManager(name);
System::Runtime::InteropServices::Marshal::FreeHGlobal(System::IntPtr((void *)name));
}
ServiceManager::~ServiceManager(){
this->!ServiceManager();
}
ServiceManager::!ServiceManager(){
if(UmServiceManager != NULL)
delete UmServiceManager;
}
NetPipe::ServiceManager *ServiceManager::getUnmanagedObject(){
return UmServiceManager;
}
System::String ^ServiceManager::getServiceName(){
if(UmServiceManager == NULL)
return gcnew System::String(""); // null を返すにはどうすればいいのー？！
char *serviceName = UmServiceManager->getServiceName();
return gcnew System::String(serviceName);
}
void ServiceManager::addReadPort(System::String ^portName, System::String ^description){
char *name = static_cast<char*>((System::Runtime::InteropServices::Marshal::StringToHGlobalAnsi(portName)).ToPointer());
char *desc = static_cast<char*>((System::Runtime::InteropServices::Marshal::StringToHGlobalAnsi(description)).ToPointer());
UmServiceManager->addReadPort(name, desc);
System::Runtime::InteropServices::Marshal::FreeHGlobal(System::IntPtr((void *)name));
System::Runtime::InteropServices::Marshal::FreeHGlobal(System::IntPtr((void *)desc));
}
void ServiceManager::addReadPort(System::String ^portName){
char *name = static_cast<char*>((System::Runtime::InteropServices::Marshal::StringToHGlobalAnsi(portName)).ToPointer());
UmServiceManager->addReadPort(name);
System::Runtime::InteropServices::Marshal::FreeHGlobal(System::IntPtr((void *)name));
}
void addReadPort(System::String ^portName);
void ServiceManager::addWritePort(System::String ^portName, System::String ^description){
char *name = static_cast<char*>((System::Runtime::InteropServices::Marshal::StringToHGlobalAnsi(portName)).ToPointer());
char *desc = static_cast<char*>((System::Runtime::InteropServices::Marshal::StringToHGlobalAnsi(description)).ToPointer());
UmServiceManager->addWritePort(name, desc);
System::Runtime::InteropServices::Marshal::FreeHGlobal(System::IntPtr((void *)name));
System::Runtime::InteropServices::Marshal::FreeHGlobal(System::IntPtr((void *)desc));
}
void ServiceManager::addWritePort(System::String ^portName){
char *name = static_cast<char*>((System::Runtime::InteropServices::Marshal::StringToHGlobalAnsi(portName)).ToPointer());
UmServiceManager->addWritePort(name);
System::Runtime::InteropServices::Marshal::FreeHGlobal(System::IntPtr((void *)name));
}
//void addReadFD(int fd, string description = "UNDEFINED", size_t bufSize = 4096);
// void addTimer(int usec, string description = "UNDEFINED");
class ServiceWrapper : public NetPipe::Service {
private:
gcroot<NetPipeDotNET::Service ^> gcService;
public:
ServiceWrapper(gcroot<NetPipeDotNET::Service ^>service){
gcService = service;
}
void onEvent(NetPipe::PipeManager *pipeManager, char *portName,
char *arg, NetPipe::Service::EVENT_TYPE type, char *buf, size_t bufSize){
array<System::Byte>^ byteArray = gcnew array<System::Byte>(bufSize);
pin_ptr<System::Byte> pBuf = &byteArray[0];
memcpy(pBuf, buf, bufSize);
gcService->onEvent(gcnew NetPipeDotNET::PipeManager(pipeManager),
gcnew System::String(portName), gcnew System::String(arg),
(NetPipeDotNET::Service::EVENT_TYPE)type,
byteArray);
}
};
class ServiceCreatorWrapper : public NetPipe::ServiceCreator {
private:
gcroot<NetPipeDotNET::ServiceCreator ^> gcServiceCreator;
public:
ServiceCreatorWrapper(NetPipeDotNET::ServiceCreator ^serviceCreator){
gcServiceCreator = serviceCreator;
}
NetPipe::Service *createNewService(void *userData){
gcroot<NetPipeDotNET::Service ^> service = gcServiceCreator->createNewService((System::IntPtr)userData);
return new ServiceWrapper(service);
}
};
void ServiceManager::addServiceCreator(NetPipeDotNET::ServiceCreator ^serviceCreator, System::IntPtr userData){
ServiceCreatorWrapper *scw = new ServiceCreatorWrapper(serviceCreator);
UmServiceManager->addServiceCreator(scw, (void *)userData);
}
void ServiceManager::addServiceCreator(NetPipeDotNET::ServiceCreator ^serviceCreator){
this->addServiceCreator(serviceCreator, System::IntPtr::Zero);
}
}; /* namespace NetPipeDotNET */ | [
"uirou.j@b085bb30-bf34-0410-99c5-0750ab6b8f60"
]
| [
[
[
1,
133
]
]
]
|
eeac4274bba56bbb65e53a95e16629d53c406885 | 282057a05d0cbf9a0fe87457229f966a2ecd3550 | /EIBStdLib/include/xml/xpath_expression.h | 9b968e32b51b405df517c9a7c2911ca55619cb16 | []
| no_license | radtek/eibsuite | 0d1b1c826f16fc7ccfd74d5e82a6f6bf18892dcd | 4504fcf4fa8c7df529177b3460d469b5770abf7a | refs/heads/master | 2021-05-29T08:34:08.764000 | 2011-12-06T20:42:06 | 2011-12-06T20:42:06 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,466 | h | /*
www.sourceforge.net/projects/tinyxpath
Copyright (c) 2002-2004 Yves Berquin ([email protected])
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any
damages arising from the use of this software.
Permission is granted to anyone to use this software for any
purpose, including commercial applications, and to alter it and
redistribute it freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must
not claim that you wrote the original software. If you use this
software in a product, an acknowledgment in the product documentation
would be appreciated but is not required.
2. Altered source versions must be plainly marked as such, and
must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source
distribution.
*/
#ifndef __EXPR_H
#define __EXPR_H
#include "xml/tinyxpath_conf.h"
#include "xml/tinyxml.h"
#include "xml/node_set.h"
namespace TinyXPath
{
/// Expression types
typedef enum {e_bool, e_string, e_int, e_double, e_node_set, e_invalid} e_expression_type;
/// Class holding the result of an expression (e_expression_type)
class expression_result
{
protected :
/// String content
TIXML_STRING S_content;
#ifdef TINYXPATH_DEBUG
/// Comment. This is for debuging only, for stack dump
TIXML_STRING S_comment;
#endif
/// bool content
bool o_content;
/// integer content
int i_content;
/// double content
double d_content;
/// node set content
node_set ns_set;
/// Ptr to the root node
const TiXmlNode * XNp_root;
public :
/// expression type
e_expression_type e_type;
/// Dummy constructor
expression_result (const TiXmlNode * XNp_in_root) : XNp_root (XNp_in_root)
{
e_type = e_invalid;
o_content = false;
i_content = 0;
d_content = 0.0;
}
expression_result ()
{
XNp_root = NULL;
e_type = e_invalid;
o_content = false;
i_content = 0;
d_content = 0.0;
}
void v_set_root (const TiXmlNode * XNp_in) {XNp_root = XNp_in;}
/// Copy constructor
expression_result (const expression_result & er_2)
{
* this = er_2;
}
expression_result & operator = (const expression_result & er_2)
{
XNp_root = er_2 . XNp_root;
e_type = er_2 . e_type;
switch (e_type)
{
case e_bool :
o_content = er_2 . o_content;
break;
case e_int :
i_content = er_2 . i_content;
break;
case e_string :
S_content = er_2 . S_content;
break;
case e_double :
d_content = er_2 . d_content;
break;
case e_node_set :
ns_set = er_2 . ns_set;
break;
case e_invalid :
break;
}
#ifdef TINYXPATH_DEBUG
S_comment = er_2 . S_comment;
#endif
return * this;
}
/// Set expression_result to a bool
void v_set_bool (bool o_in)
{
e_type = e_bool;
o_content = o_in;
}
/// Set expression_result to an int
void v_set_int (int i_in)
{
e_type = e_int;
i_content = i_in;
}
/// Set expression_result to a string
void v_set_string (const char * cp_in)
{
e_type = e_string;
S_content = cp_in;
}
/// Set expression_result to a string
void v_set_string (TIXML_STRING S_in)
{
e_type = e_string;
S_content = S_in;
}
/// Set expression_result to a double
void v_set_double (double d_in)
{
e_type = e_double;
d_content = d_in;
}
/// Set the comment associated with a stack element. This is for debuging
void v_set_comment (const char * cp_in)
{
#ifdef TINYXPATH_DEBUG
S_comment = cp_in;
#endif
}
int i_get_int ();
TIXML_STRING S_get_string ();
/// Get the expression_result as a string
const char * cp_get_string ()
{
assert (e_type == e_string);
return S_content . c_str ();
}
bool o_get_bool ();
double d_get_double ();
/// Set the expression_result as a node set
void v_set_node_set (node_set * nsp_source)
{
e_type = e_node_set;
ns_set = * nsp_source;
}
/// Set the expression_result as a node set
void v_set_node_set (TiXmlNode * XNp_root)
{
e_type = e_node_set;
ns_set . v_copy_node_children (XNp_root);
}
/// Set the expression_result as a node set
void v_set_node_set (TiXmlNode * XNp_root, const char * cp_lookup)
{
e_type = e_node_set;
ns_set . v_copy_node_children (XNp_root, cp_lookup);
}
/// Set the expression_result as a node set
void v_set_node_set_recursive (TiXmlNode * XNp_root)
{
e_type = e_node_set;
ns_set . v_copy_selected_node_recursive (XNp_root);
}
/// Set the expression_result as a node set
void v_set_node_set_recursive (TiXmlNode * XNp_root, const char * cp_lookup)
{
e_type = e_node_set;
ns_set . v_copy_selected_node_recursive (XNp_root, cp_lookup);
}
/// Set the expression_result as an empty node set
void v_set_node_set ()
{
e_type = e_node_set;
}
/// Get the expression_result as a node set
node_set * nsp_get_node_set ()
{
return & ns_set;
}
#ifdef TINYXPATH_DEBUG
void v_dump ();
#endif
} ;
}
#endif
| [
"[email protected]"
]
| [
[
[
1,
211
]
]
]
|
4c5d724e4a3821d27cc2417c721ad27bf83c3d19 | 51febe6598848c79ffa36890655e25ed05652d7d | /MarioBros/MarioBros/Hill.h | 4dc58fbf21d36178c93d9a264171173d4195f1e2 | []
| no_license | vohoangviet/game-mario-directx | d6db92457ad10fa97d2241394a2c46457fdbe2c3 | e7ad07e7335cd7a2c0cb6b3d1a02af36798cafc4 | refs/heads/master | 2021-01-10T01:33:15.453400 | 2011-12-08T14:15:39 | 2011-12-08T14:15:39 | 43,821,369 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 381 | h | #pragma once
#include "GAnimation.h"
#include "GSprite.h"
#include "GObject.h"
#include <list>
using namespace std;
class Hill:public GObject
{
public:
Hill();
Hill(float _x, float _y,float width,float height,int _ID,GSprite* _sprite);
void Render(GCamera *camera);
void ResetWhenReload(GSprite* _sprite);
void Save(fstream *fs);
void Load(fstream *fs);
}; | [
"[email protected]"
]
| [
[
[
1,
18
]
]
]
|
e1d8689d5267e314185fcbee50604f42d29be500 | fcdddf0f27e52ece3f594c14fd47d1123f4ac863 | /terralib/src/terralib/kernel/Gra_algo.h | be87d692f5bc0c015bd2662134f538b1e44d7889 | []
| no_license | radtek/terra-printer | 32a2568b1e92cb5a0495c651d7048db6b2bbc8e5 | 959241e52562128d196ccb806b51fda17d7342ae | refs/heads/master | 2020-06-11T01:49:15.043478 | 2011-12-12T13:31:19 | 2011-12-12T13:31:19 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,671 | h | /************************************************************************************
TerraLib - a library for developing GIS applications.
Copyright � 2001-2007 INPE and Tecgraf/PUC-Rio.
This code is part of the TerraLib library.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
You should have received a copy of the GNU Lesser General Public
License along with this library.
The authors reassure the license terms regarding the warranties.
They specifically disclaim any warranties, including, but not limited to,
the implied warranties of merchantability and fitness for a particular purpose.
The library provided hereunder is on an "as is" basis, and the authors have no
obligation to provide maintenance, support, updates, enhancements, or modifications.
In no event shall INPE and Tecgraf / PUC-Rio be held liable to any party for direct,
indirect, special, incidental, or consequential damages arising out of the use
of this library and its documentation.
*************************************************************************************/
// include/gra_algo.h
#ifndef GRAPH_ALGORITHMS_H
#define GRAPH_ALGORITHMS_H
#include "dynpq.h"
#include "graph.h"
#include <limits>
#include <iostream>
namespace br_stl {
template<class GraphType, class EdgeType>
void Dijkstra(
GraphType& Gr,
std::vector<EdgeType>& Dist,
std::vector<int>& Pred,
int Start) {
/* The algorithm proceeds in such a way that the distances are
estimated and the estimates gradually improved. The distance to
the starting point is known (0). For all other vertices, the
worst possible estimate is entered.*/
Dist = std::vector<EdgeType>(Gr.size(),
TeMAXFLOAT); // as good as infinity
Dist[Start] = (EdgeType)0;
/* The predecessor vector too is initialized with `impossible'
values. Subsequently, a dynamic priority queue is defined and
initialized with the distance vector: */
Pred = std::vector<int>(Gr.size(), -1);
dynamic_priority_queue<EdgeType> Q(Dist);
// In the next step, all vertices are extracted one by one from
// the priority queue, and precisely in the order of the estimated
// distance towards the starting vertex. Obviously, the starting
//vertex is dealt with first. No vertex is looked at twice.
int u;
while(!Q.empty()) {
u = Q.topIndex(); // extract vertex with minimum
Q.pop();
// Now, the distance estimates for all neighboring vertices of
// u are updated. If the previous estimate of the distance
// between the current neighbor of u and the starting vertex
// (Dist[Neighbor]) is worse than the distance between vertex u
// and the starting vertex (Dist[u]) plus the distance between
// u and the neighboring vertex (dist), the estimate is
// improved: this process is called relaxation. In this case,
// the path from the starting vertex to the neighbor cannot be
// longer than (Dist[u] + dist). In this case, u would have to
// be regarded as predecessor of the neighbor.
// improve estimates for all neighbors of u
typename GraphType::Successor::const_iterator
I = Gr[u].second.begin();
while(I != Gr[u].second.end()) {
int Neighbor = (*I).first;
EdgeType dist = (*I).second;
// relaxation
if(Dist[Neighbor] > Dist[u] + dist) {
// improve estimate
Q.changeKeyAt(Neighbor, Dist[u] + dist);
// u is predecessor of the neighbor
Pred[Neighbor] = u;
}
++I;
}
}
return;
}
template<class GraphType>
bool topoSort(
GraphType& G,
std::vector<int>& Result) {
assert(G.isDirected()); // let's play this safe!
int ResCounter = 0;
Result = std::vector<int>(G.size(), -1);
/* The vector Result takes the indices of the correspondingly
distributed vertices. The counter ResCounter is the position in
Result where the next entry belongs. */
vector<int> PredecessorCount(G.size(), 0);
int VerticesWithoutSuccessor = 0;
/* For each vertex, the vector PredecessorCount counts how many
predecessors it has. There are vertices without successors,
whose number is kept in VerticesWithoutSuccessor. Furthermore,
the algorithm remains stable if the precondition that a graph
must not have cycles is violated. The variable
VerticesWithoutSuccessor is used to recognize this situation
(see below). */
/*
for(size_t iv = 0; iv < G.size(); ++iv) {
if(G[iv].second.size() > 0) { // is predecessor
typename GraphType::Successor::const_iterator I =
G[iv].second.begin();
while(I != G[iv].second.end())
// update number of predecessors
++PredecessorCount[(*I++).first];
}
else { // Vertex is no predecessor, that is, without successor
// an excessively high number of predecessors is used
// for later recognition
PredecessorCount[iv] = G.size(); // too many!
++VerticesWithoutSuccessor;
}
}
*/
/* The dynamic priority queue is initialized with the vector of
numbers of predecessors. At the beginning of the queue we find
those vertices that have no predecessors and therefore are to
be processed next. Only the vertices which are predecessors
themselves, that is that have successors are processed. The
subsequent loop is terminated when the queue only contains
successor vertices which themselves are not predecessors. Their
number of predecessors can never be 0 because further above
they were initialized with too high a value.*/
/*
dynamic_priority_queue<int> Q(PredecessorCount);
// process all predecessors
while(Q.topKey() == 0) {
// determine vertex with predecessor number 0
int oV = Q.topIndex();
Q.pop();
Result[ResCounter++] = oV;
// In order to ensure that this vertex without predecessors oV
// is no longer considered in the next cycle, the number of
// predecessors of all its successors is decreased by 1.
typename GraphType::Successor::const_iterator
I = G[oV].second.begin();
while(I != G[oV].second.end()) {
// decrease number of predecessors with
// changeKeyAt()}. Do not change directly!
int V = (*I).first;
Q.changeKeyAt(V, PredecessorCount[V] -1);
++I;
}
}
// Now, all vertices without successors are entered. As a
// countercheck, the variable VerticesWithoutSuccessor is
// decreased. If the queue contains too many vertices, an error
// message is displayed.
while(!Q.empty()) {
Result[ResCounter++] = Q.topIndex();
Q.pop();
--VerticesWithoutSuccessor;
}
if(VerticesWithoutSuccessor < 0)
std::cerr << "Error: graph contains a cycle!\n";
return VerticesWithoutSuccessor == 0;
*/
return;
}
} // namespace br_stl
#endif
| [
"[email protected]@58180da6-ba8b-8960-36a5-00cc02a3ddec"
]
| [
[
[
1,
195
]
]
]
|
94cf36c189da9a7394d640037530f2efcd22999a | ee065463a247fda9a1927e978143186204fefa23 | /Src/Depends/Entity/IProperty.h | 44c9c8c19115f280ac7734bec1b32f03a040973c | [
"Zlib"
]
| permissive | ptrefall/hinsimviz | 32e9a679170eda9e552d69db6578369a3065f863 | 9caaacd39bf04bbe13ee1288d8578ece7949518f | refs/heads/master | 2021-01-22T09:03:52.503587 | 2010-09-26T17:29:20 | 2010-09-26T17:29:20 | 32,448,374 | 1 | 0 | null | null | null | null | ISO-8859-15 | C++ | false | false | 1,497 | h | /*Component-based Entity Engine
Copyright (c) 2009 Pål Trefall and Kenneth Gangstø
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
Note: Some of the libraries Component-based Entity Engine may link to may have additional
requirements or restrictions.
*/
#pragma once
#include "precomp.h"
namespace Engine
{
namespace Entity
{
class IProperty
{
public:
virtual ~IProperty() {}
virtual const CL_String &GetName() const = 0;
virtual bool IsNull() const = 0;
virtual bool IsDirty() const = 0;
virtual void ClearDirty() = 0;
virtual CL_String ToString() const = 0;
virtual void SetFromString(const CL_String &value) = 0;
virtual int GetTypeId() const = 0;
};
}}
| [
"[email protected]@28a56cb3-1e7c-bc60-7718-65c159e1d2df"
]
| [
[
[
1,
48
]
]
]
|
fa99a378500e15b82f996c17a608370e016cfa97 | f55665c5faa3d79d0d6fe91fcfeb8daa5adf84d0 | /GameSDK/GameUILib/Source/RenderTarget.cpp | c8e5afe7a990fd083a12d9794e05b0838d79506e | []
| no_license | lxinhcn/starworld | 79ed06ca49d4064307ae73156574932d6185dbab | 86eb0fb8bd268994454b0cfe6419ffef3fc0fc80 | refs/heads/master | 2021-01-10T07:43:51.858394 | 2010-09-15T02:38:48 | 2010-09-15T02:38:48 | 47,859,019 | 2 | 1 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 2,181 | cpp | #include "header.h"
#include "RenderTarget.h"
#include "Texture.h"
#include "Canvas.h"
namespace UILib
{
BEGIN_UIMSG_MAP( CRenderTarget, CUIElement )
ON_UI_CREATE()
END_UIMSG_MAP()
CRenderTarget::CRenderTarget(void)
{
}
CRenderTarget::~CRenderTarget(void)
{
}
void CRenderTarget::SetModelName( LPCSTR lpszModelName )
{
m_strModelName = lpszModelName;
}
LPCSTR CRenderTarget::GetModelName()
{
return m_strModelName.c_str();
}
void CRenderTarget::RenderSelf(const CUIRect& clipper)
{
__super::RenderSelf( clipper );
if( m_pCanvas )
{
//±³¾°
CUIPoint pt( 0, 0 );
pt = ClientToScreen(pt);
int nWidth = m_wndRect.Width();
int nHeight = m_wndRect.Height();
// °´Å¥±³¾°
CTexture tex;
tex.SetName( m_strModelName.c_str() );
m_pCanvas->DrawTexture( &tex, pt.x, pt.y, nWidth, nHeight, clipper );
}
}
BOOL CRenderTarget::OnCreate( WPARAM wParam, LPARAM lParam )
{
if( m_pParent )
{
NMUIHDR hdr;
hdr.code = NC_CREATE;
hdr.pCtrl = this;
hdr.idFrom = GetID();
m_pParent->SendMessage( WM_NOTIFY, 0, (LPARAM)&hdr );
}
return TRUE;
}
void CRenderTarget::LoadProperty(TiXmlElement* pXMLElement )
{
__super::LoadProperty( pXMLElement );
m_strModelName = pXMLElement->Attribute( "ModelName" );
}
void CRenderTarget::SaveProperty(TiXmlElement* pXMLElement )
{
__super::SaveProperty( pXMLElement );
pXMLElement->SetAttribute( "ModelName", m_strModelName.c_str() );
}
// ÉèÖÿؼþÊôÐÔ
bool CRenderTarget::SetProperty( const char* pszPropertyName, const char* pszValue )
{
if( stricmp( pszPropertyName, "ModelName" ) == 0 )
{
SetModelName( pszValue );
}
else
{
return __super::SetProperty( pszPropertyName, pszValue );
}
return true;
}
bool CRenderTarget::GetProperty( const char* pszPropertyName, char* pValueBuffer, int size )
{
if( stricmp( pszPropertyName, "ModelName" ) == 0 )
{
strncpy( pValueBuffer, GetModelName(), size );
}
else
{
return __super::GetProperty( pszPropertyName, pValueBuffer, size );
}
return true;
}
}
| [
"albertclass@a94d7126-06ea-11de-b17c-0f1ef23b492c"
]
| [
[
[
1,
98
]
]
]
|
eb8a49b61e9d20d9f27a4ae9086205af56a5f1ab | 547a31c6d098df866be58befd8642ab773b32226 | /vc/DataLogger/LogFile.h | 4bc8f6c003b57708806e6c23a839f23927a98bed | []
| no_license | neirons/pythondatalogger | 64634d97eaa724a04707e4837dced51bcf750146 | f1cd1aea4d63407c3d4156ddccd02339dc96dcec | refs/heads/master | 2020-05-17T07:48:33.707106 | 2010-08-08T13:37:33 | 2010-08-08T13:37:33 | 41,642,510 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 569 | h | // LogFile.h: interface for the CLogFile class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_LOGFILE_H__288388CA_9A3E_4F3D_A2B8_F1078E1F6A6B__INCLUDED_)
#define AFX_LOGFILE_H__288388CA_9A3E_4F3D_A2B8_F1078E1F6A6B__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
class CLogFile
{
public:
CLogFile();
virtual ~CLogFile();
BOOL WriteLog(CString LogText);
private:
CString GetFilePath();
};
#endif // !defined(AFX_LOGFILE_H__288388CA_9A3E_4F3D_A2B8_F1078E1F6A6B__INCLUDED_)
| [
"shixiaoping79@5c1c4db6-e7b1-408c-73c2-e61316242a6a"
]
| [
[
[
1,
22
]
]
]
|
52f21e694ccfe76cfd3f171c2e9b49547d9c113e | bc3073755ed70dd63a7c947fec63ccce408e5710 | /src/Game/Components/Player.h | c7c46d86f13bd96cfe028821de95744ea2f7f398 | []
| no_license | ptrefall/ste6274gamedesign | 9e659f7a8a4801c5eaa060ebe2d7edba9c31e310 | 7d5517aa68910877fe9aa98243f6bb2444d533c7 | refs/heads/master | 2016-09-07T18:42:48.012493 | 2011-10-13T23:41:40 | 2011-10-13T23:41:40 | 32,448,466 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,311 | h | #pragma once
#include <types_config.h>
#include <Component.h>
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
class Game;
namespace Components
{
class Player : public Totem::Component
{
public:
COMPONENT_1(Player, Game);
Player(Totem::Entity &owner, const T_String &name, Game &game);
virtual ~Player();
virtual void update(const F32 &deltaTime);
void onKeyPressed(const int &key, const unsigned int &modifiers);
void onKeyReleased(const int &key, const unsigned int &modifiers);
private:
void onPositionChanged(const glm::vec3 &oldValue, const glm::vec3 &newValue);
void setRollDirection(const float &roll);
Game &game;
T_Map<int, bool>::Type key_map;
Totem::Property<D32> x_dir;
Totem::Property<D32> y_dir;
Totem::Property<D32> velocity;
Totem::Property<glm::gtc::quaternion::quat> qStepPitchRotation;
Totem::Property<glm::gtc::quaternion::quat> qStepYawRotation;
Totem::Property<glm::gtc::quaternion::quat> qStepRollRotation;
Totem::Property<glm::gtc::quaternion::quat> qRotation;
Totem::Property<glm::vec3> position;
Totem::Property<glm::vec3> camera_distance;
float roll_angle;
float roll_speed;
float steer_angle;
float old_steer_angle;
float turn_speed;
T_HashedString moveEventId;
};
}
| [
"[email protected]@2c5777c1-dd38-1616-73a3-7306c0addc79"
]
| [
[
[
1,
46
]
]
]
|
29f9a578b2cf1b59ce3da27043891d6e357af2c9 | b822313f0e48cf146b4ebc6e4548b9ad9da9a78e | /KylinSdk/Core/Source/rCollisionMonitor.cpp | 0636f05fe3a8303b2d669f7ea14511ae459902ef | []
| no_license | dzw/kylin001v | 5cca7318301931bbb9ede9a06a24a6adfe5a8d48 | 6cec2ed2e44cea42957301ec5013d264be03ea3e | refs/heads/master | 2021-01-10T12:27:26.074650 | 2011-05-30T07:11:36 | 2011-05-30T07:11:36 | 46,501,473 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 7,566 | cpp | #include "corepch.h"
#include "rCollisionMonitor.h"
#include "Node.h"
#include "Entity.h"
#include "KylinRoot.h"
#include "rOgreUtils.h"
Kylin::PhyX::CollisionMonitor::CollisionMonitor()
{
}
KVOID Kylin::PhyX::CollisionMonitor::Tick( KFLOAT fElapsed )
{
TestEntities( );
}
KVOID Kylin::PhyX::CollisionMonitor::Destroy()
{
for ( CllsnObjMap::iterator it = m_kObjsMap.begin();
it != m_kObjsMap.end();
it++ )
{
SAFE_DEL(it->second);
}
m_kObjsMap.clear();
m_kSceneVec.clear();
m_kFloorVec.clear();
}
Kylin::PhyX::CollisionMonitor::CollisionData* Kylin::PhyX::CollisionMonitor::Commit( Node* pHost,KBOOL bCollider,KUINT uSelf,KUINT uMate )
{
CollisionData* pData = NULL;
CllsnObjMap::iterator it = m_kObjsMap.find(pHost);
if (it != m_kObjsMap.end())
{
pData = it->second;
pData->m_bCollider = bCollider;
pData->m_uSelf = uSelf;
pData->m_uMate = uMate;
}
else
{
pData = KNEW CollisionData(pHost,bCollider);
pData->m_uSelf = uSelf;
pData->m_uMate = uMate;
m_kObjsMap.insert(std::pair<Node*, CollisionData*>(pData->m_pHost,pData));
}
return pData;
}
KBOOL Kylin::PhyX::CollisionMonitor::QueryScene( KPoint3 kPos, KPoint3 kDir, KFLOAT fRadius)
{
if (QuerySceneCllsnBox(kPos))
return false;
KPoint3 kSrc(kPos.x,kPos.y + 1.5f*fRadius,kPos.z);
Ogre::Ray kRay(kSrc,kDir);
// 检测该射线是否与地面相交
KPoint3 kRet;
if (KylinRoot::GetSingletonPtr()->HitTest(kRay,kRet))
{
//if (kRet.squaredDistance(kPos) <= fRadius*fRadius)
{
kPos = kRet - kPos;
KFLOAT fDeg = kPos.angleBetween(KPoint3::UNIT_Y).valueDegrees();
// 如果(p2->p1)与(p2->p0)的倾斜角度小于40，认为无法行走
//
// p1<-------+p0
// \ |
// \ |
// \ |
// \ |
// \ |
// \ |
// \ |
// \|
// + p2
if (fDeg < 40)
return false;
}
}
return true;
}
KVOID Kylin::PhyX::CollisionMonitor::TestEntities( )
{
CollisionGroup kGroup;
for ( CllsnObjMap::iterator it = m_kObjsMap.begin();
it != m_kObjsMap.end();
it++ )
{
if (it->second->m_bEnable)
{
if (it->second->m_bCollider)
{
kGroup.AddCollider(it->second);
kGroup.AddCollidee(it->second);
}
else
kGroup.AddCollidee(it->second);
}
}
kGroup.Update();
}
KBOOL Kylin::PhyX::CollisionMonitor::QuerySceneCllsnBox( KPoint3 kPos )
{
for (KUINT i = 0; i < m_kSceneVec.size(); i++)
{
// if ( m_kSceneVec[i].mOBB.getCenter().squaredDistance(kPos) <=
// m_kSceneVec[i].mOBB.getSquaredRadius() * 2 )
{
if ( m_kSceneVec[i].mOBB.contains(kPos) )
{
return true;
}
}
}
return false;
}
KVOID Kylin::PhyX::CollisionMonitor::AddSceneCllsnBox(KCSTR& sName, const OrientedBox& kBox )
{
CollisionBox box;
box.mOBB = kBox;
box.mName = sName;
m_kSceneVec.push_back(box);
}
KVOID Kylin::PhyX::CollisionMonitor::Erase( Node* pHost )
{
for ( CllsnObjMap::iterator it = m_kObjsMap.begin();
it != m_kObjsMap.end();
it++ )
{
if (it->first == pHost)
{
SAFE_DEL(it->second);
m_kObjsMap.erase(it);
break;
}
}
}
KVOID Kylin::PhyX::CollisionMonitor::AddSceneCllsnPlane(KCSTR& sName, const OrientedBox& kBox )
{
CollisionBox box;
box.mOBB = kBox;
box.mName = sName;
m_kFloorVec.push_back(box);
}
KBOOL Kylin::PhyX::CollisionMonitor::QuerySceneCllsnPlane( KPoint3& kPos , KFLOAT fR)
{
KFLOAT fDis = .0f;
for (KUINT i = 0; i < m_kFloorVec.size(); i++)
{
// if ( m_kFloorVec[i].mOBB.getCenter().squaredDistance(kPos) <=
// m_kFloorVec[i].mOBB.getSquaredRadius() * 2 )
{
if ( m_kFloorVec[i].mOBB.contains(kPos) )
{
kPos.y = m_kFloorVec[i].mOBB.center.y + m_kFloorVec[i].mOBB.extents.y;
return true;
}
}
}
return false;
}
//////////////////////////////////////////////////////////////////////////
KVOID Kylin::PhyX::CollisionMonitor::CollisionGroup::AddCollider( CollisionData* pData )
{
m_kCollider.push_back(pData);
}
KVOID Kylin::PhyX::CollisionMonitor::CollisionGroup::AddCollidee( CollisionData* pData )
{
m_kCollidee.push_back(pData);
}
KVOID Kylin::PhyX::CollisionMonitor::CollisionGroup::Update()
{
//m_kCllsnBag.clear();
KPoint3 kPos1,kPos2;
for (KUINT i = 0; i < m_kCollider.size(); i++)
{
for (KUINT j = 0; j < m_kCollidee.size(); j++)
{
if (m_kCollider[i]->m_pHost == m_kCollidee[j]->m_pHost)
continue;
if (!(m_kCollider[i]->m_uSelf & m_kCollidee[j]->m_uMate))
continue;
//----------------------------------------------------------------
// 过滤掉已经处理过的碰撞对
if(IsMarked(*m_kCollider[i], *m_kCollidee[j]))
continue;
//mark as collided
AddPair(*m_kCollider[i], *m_kCollidee[j]);
//----------------------------------------------------------------
kPos1 = m_kCollider[i]->m_pHost->GetTranslate();
kPos2 = m_kCollidee[j]->m_pHost->GetTranslate();
if (kPos1.squaredDistance(kPos2) <= pow(VISIBLE_DISTANCE,2))
{
Ogre::AxisAlignedBox& box = m_kCollider[i]->m_pHost->GetWorldBoundingBox();
if (OgreUtils::IntersectsAABB(box,m_kCollidee[j]->m_pHost->GetWorldBoundingBox()) != OgreUtils::OUTSIDE)
{
CollisionPair kPair;
kPair.m_pObj1 = m_kCollider[i]->m_pHost;
kPair.m_pObj2 = m_kCollidee[j]->m_pHost;
//m_kCollider[i]->m_pCallback(kPair);
CollideCallback(kPair);
if (m_kCollidee[j]->m_eMode == CLLSN_BREAK)
break;
}
}
}
}
}
KVOID Kylin::PhyX::CollisionMonitor::CollisionGroup::CollideCallback( const CollisionPair& kPair )
{
Node* pNode1 = kPair.m_pObj1;
Node* pNode2 = kPair.m_pObj2;
Entity* pEnt1 = KylinRoot::GetSingletonPtr()->GetEntity(pNode1->GetWorldID());
Entity* pEnt2 = KylinRoot::GetSingletonPtr()->GetEntity(pNode2->GetWorldID());
if (pEnt1 && pEnt2)
{
if ( pEnt1->OnShouldCllsn(pEnt2) )
{
pEnt1->OnEntityCllsn(pEnt2,KPoint3::ZERO);
}
}
}
void Kylin::PhyX::CollisionMonitor::CollisionGroup::AddPair( const CollisionData& kCllsn, const CollisionData& kCllsn_1 )
{
//add the first of the pair
ColliderBag::iterator bagIt = m_kCllsnBag.find(&kCllsn);
if(bagIt != m_kCllsnBag.end())
{
bagIt->second.insert(&kCllsn_1);
}
else
{
ResponserSet cllsnSet;
cllsnSet.insert(&kCllsn_1);
m_kCllsnBag.insert(ColliderBag::value_type(&kCllsn, cllsnSet));
}
//add the second of the pair
bagIt = m_kCllsnBag.find(&kCllsn_1);
if(bagIt != m_kCllsnBag.end())
{
bagIt->second.insert(&kCllsn);
}
else
{
ResponserSet cllsnSet;
cllsnSet.insert(&kCllsn);
m_kCllsnBag.insert(ColliderBag::value_type(&kCllsn_1, cllsnSet));
}
}
bool Kylin::PhyX::CollisionMonitor::CollisionGroup::IsMarked( const CollisionData& kCllsn, const CollisionData& kCllsn_1 ) const
{
ColliderBag::const_iterator bagIt = m_kCllsnBag.find(&kCllsn);
if(bagIt != m_kCllsnBag.end())
{
return bagIt->second.find(&kCllsn_1) != bagIt->second.end();
}
else
return false;
}
//////////////////////////////////////////////////////////////////////////
// KVOID Kylin::PhyX::CollisionMonitor::CollisionData::SetCallbackFunc( Func pFunc )
// {
// assert(pFunc);
// m_pCallback = pFunc;
// }
KVOID Kylin::PhyX::CollisionMonitor::CollisionData::SetCollsionMode( CllsnMode eMode )
{
m_eMode = eMode;
}
KVOID Kylin::PhyX::CollisionMonitor::CollisionData::SetEnable( KBOOL bEnable )
{
m_bEnable = bEnable;
}
| [
"[email protected]",
"apayaccount@5fe9e158-c84b-58b7-3744-914c3a81fc4f"
]
| [
[
[
1,
3
],
[
5,
5
],
[
7,
28
],
[
30,
32
],
[
34,
34
],
[
37,
38
],
[
43,
45
],
[
50,
51
],
[
54,
57
],
[
61,
102
],
[
105,
105
],
[
108,
115
],
[
120,
121
],
[
129,
129
],
[
133,
133
],
[
137,
137
],
[
155,
196
],
[
199,
203
],
[
218,
219
],
[
221,
221
],
[
236,
239
],
[
298,
299
],
[
305,
313
]
],
[
[
4,
4
],
[
6,
6
],
[
29,
29
],
[
33,
33
],
[
35,
36
],
[
39,
42
],
[
46,
49
],
[
52,
53
],
[
58,
60
],
[
103,
104
],
[
106,
107
],
[
116,
119
],
[
122,
128
],
[
130,
132
],
[
134,
136
],
[
138,
154
],
[
197,
198
],
[
204,
217
],
[
220,
220
],
[
222,
235
],
[
240,
297
],
[
300,
304
],
[
314,
315
]
]
]
|
f9d91a0848b898a263232a2714fe68a9b244785c | 4323418f83efdc8b9f8b8bb1cc15680ba66e1fa8 | /Trunk/Battle Cars/Battle Cars/Source/Gamer_Profile.h | 24c51019db83f341b9bcc40442fd2cbadb1640c0 | []
| no_license | FiveFourFive/battle-cars | 5f2046e7afe5ac50eeeb9129b87fcb4b2893386c | 1809cce27a975376b0b087a96835347069fe2d4c | refs/heads/master | 2021-05-29T19:52:25.782568 | 2011-07-28T17:48:39 | 2011-07-28T17:48:39 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 645 | h | #ifndef GAMER_PROFILE_H_
#define GAMER_PROFILE_H_
#include "CKeyBinds.h"
#include "CKeyboardKeyBinds.h"
#include <string>
using namespace std;
class Gamer_Profile
{
public:
Gamer_Profile();
~Gamer_Profile();
string m_sUserName;
CKeyBinds* m_pKB;
CKeyboardKeyBinds* m_pKKB;
float m_sfx;
float m_background;
int cars[4];
int index; // the 0-2 value of which profile slot its saved in
string GetUserName(){ return m_sUserName;}
CKeyBinds* GetControllerBinds(){ return m_pKB;}
CKeyboardKeyBinds* GetKeyboardBinds(){ return m_pKKB;}
Gamer_Profile& operator()(const Gamer_Profile& temp);
};
#endif | [
"[email protected]@598269ab-7e8a-4bc4-b06e-4a1e7ae79330",
"[email protected]@598269ab-7e8a-4bc4-b06e-4a1e7ae79330"
]
| [
[
[
1,
3
],
[
9,
9
],
[
11,
13
],
[
17,
23
],
[
31,
33
]
],
[
[
4,
8
],
[
10,
10
],
[
14,
16
],
[
24,
30
]
]
]
|
a652116cb803c597cb2a636ddf63e8afb6e0b317 | c6f4fe2766815616b37beccf07db82c0da27e6c1 | /SpaceshipShieldVitals.cpp | 915f4ba0d5f87bfda0e0e8bf38ad99a84dfaaf7b | []
| no_license | fragoulis/gpm-sem1-spacegame | c600f300046c054f7ab3cbf7193ccaad1503ca09 | 85bdfb5b62e2964588f41d03a295b2431ff9689f | refs/heads/master | 2023-06-09T03:43:53.175249 | 2007-12-13T03:03:30 | 2007-12-13T03:03:30 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 696 | cpp | #include "SpaceshipShieldVitals.h"
#include "ParticleSystemMgr.h"
#include "PSSmallExplosion.h"
#include "PSSmoke.h"
SpaceshipShieldVitals::SpaceshipShieldVitals( int iMaxLives, int iMaxHealth ):
OCVitalsLives( iMaxLives, iMaxHealth )
{}
void SpaceshipShieldVitals::onKill()
{
// Create a particle explosion in its position
//PSSmallExplosion *ex =
// PSManager::Instance().addSmallExplosion( getOwner()->getPos() );
//ex->start();
//// Create a particle smoke in the same position
//PSSmoke *smoke =
// PSManager::Instance().addSmoke( getOwner()->getPos() );
//smoke->start();
}
void SpaceshipShieldVitals::onRevive()
{
} | [
"john.fragkoulis@201bd241-053d-0410-948a-418211174e54"
]
| [
[
[
1,
26
]
]
]
|
2bb2a6bb01aea8c38ba576fd14881b7fec4480be | b24d5382e0575ad5f7c6e5a77ed065d04b77d9fa | /GCore/GCore/GC_DataEvent.h | eb81e18e22ef67fdd22edb5712aa762718f9c2fa | []
| no_license | Klaim/radiant-laser-cross | f65571018bf612820415e0f672c216caf35de439 | bf26a3a417412c0e1b77267b4a198e514b2c7915 | refs/heads/master | 2021-01-01T18:06:58.019414 | 2010-11-06T14:56:11 | 2010-11-06T14:56:11 | 32,205,098 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,064 | h | #ifndef GC_DATAEVENT_H
#define GC_DATAEVENT_H
#pragma once
#include <boost/shared_ptr.hpp>
#include "GC_Common.h"
#include "GC_Event.h"
namespace gcore
{
/** The data event is just a basic event that provide some data witch type is parameterized.
Use this class for simple events that just hold some informations.
It's a utility for simple events with some data.
*/
template< typename EventTypeId, typename DataType >
class DataEvent : public Event< EventTypeId >
{
public:
DataEvent( EventTypeId typeId, const DataType& d )
: Event( typeId )
, m_data( d )
{}
// note : here we assume that NRVO will play a big part to help getting directly the data.
const DataType& data() const { return m_data; }
protected:
private:
const DataType m_data;
};
template< typename EventTypeId, typename DataType >
boost::shared_ptr< Event< EventTypeId > > make_dataevent( EventTypeId type_id, const DataType& data )
{
return boost::make_shared<DataEvent>( type_id, data );
}
}
#endif | [
"[email protected]"
]
| [
[
[
1,
46
]
]
]
|
a60ad339e2c0d35b6764e20857e10a9253c94e6e | 2d4221efb0beb3d28118d065261791d431f4518a | /OIDE源代码/OLIDE/Controls/scintilla/scintilla/win32/ScintillaWin.cxx | a7a4416b7794d8c655376e74c6c6dca79f9cd0fc | [
"LicenseRef-scancode-scintilla"
]
| permissive | ophyos/olanguage | 3ea9304da44f54110297a5abe31b051a13330db3 | 38d89352e48c2e687fd9410ffc59636f2431f006 | refs/heads/master | 2021-01-10T05:54:10.604301 | 2010-03-23T11:38:51 | 2010-03-23T11:38:51 | 48,682,489 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 72,422 | cxx | // Scintilla source code edit control
/** @file ScintillaWin.cxx
** Windows specific subclass of ScintillaBase.
**/
// Copyright 1998-2003 by Neil Hodgson <[email protected]>
// The License.txt file describes the conditions under which this software may be distributed.
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include <assert.h>
#include <limits.h>
#define _WIN32_WINNT 0x0500
#include <windows.h>
#include <commctrl.h>
#include <richedit.h>
#include <windowsx.h>
#include "Platform.h"
#include "Scintilla.h"
#include "SString.h"
#ifdef SCI_LEXER
#include "SciLexer.h"
#include "PropSet.h"
#include "Accessor.h"
#include "KeyWords.h"
#endif
#include "SplitVector.h"
#include "Partitioning.h"
#include "RunStyles.h"
#include "ContractionState.h"
#include "CellBuffer.h"
#include "CallTip.h"
#include "KeyMap.h"
#include "Indicator.h"
#include "XPM.h"
#include "LineMarker.h"
#include "Style.h"
#include "AutoComplete.h"
#include "ViewStyle.h"
#include "CharClassify.h"
#include "Decoration.h"
#include "Document.h"
#include "PositionCache.h"
#include "Editor.h"
#include "ScintillaBase.h"
#include "UniConversion.h"
#ifdef SCI_LEXER
#include "ExternalLexer.h"
#endif
#ifndef SPI_GETWHEELSCROLLLINES
#define SPI_GETWHEELSCROLLLINES 104
#endif
#ifndef WM_UNICHAR
#define WM_UNICHAR 0x0109
#endif
#ifndef UNICODE_NOCHAR
#define UNICODE_NOCHAR 0xFFFF
#endif
#ifndef WM_IME_STARTCOMPOSITION
#include <imm.h>
#endif
#include <commctrl.h>
#ifndef __BORLANDC__
#ifndef __DMC__
#include <zmouse.h>
#endif
#endif
#include <ole2.h>
#ifndef MK_ALT
#define MK_ALT 32
#endif
#define SC_WIN_IDLE 5001
// Functions imported from PlatWin
extern bool IsNT();
extern void Platform_Initialise(void *hInstance);
extern void Platform_Finalise();
/** TOTAL_CONTROL ifdef surrounds code that will only work when ScintillaWin
* is derived from ScintillaBase (all features) rather than directly from Editor
* (lightweight editor).
*/
#define TOTAL_CONTROL
// GCC has trouble with the standard COM ABI so do it the old C way with explicit vtables.
const TCHAR scintillaClassName[] = TEXT("Scintilla");
const TCHAR callClassName[] = TEXT("CallTip");
class ScintillaWin; // Forward declaration for COM interface subobjects
/**
*/
class FormatEnumerator {
public:
void **vtbl;
int ref;
int pos;
CLIPFORMAT formats[2];
int formatsLen;
FormatEnumerator(int pos_, CLIPFORMAT formats_[], int formatsLen_);
};
/**
*/
class DropSource {
public:
void **vtbl;
ScintillaWin *sci;
DropSource();
};
/**
*/
class DataObject {
public:
void **vtbl;
ScintillaWin *sci;
DataObject();
};
/**
*/
class DropTarget {
public:
void **vtbl;
ScintillaWin *sci;
DropTarget();
};
/**
*/
class ScintillaWin :
public ScintillaBase {
bool lastKeyDownConsumed;
bool capturedMouse;
unsigned int linesPerScroll; ///< Intellimouse support
int wheelDelta; ///< Wheel delta from roll
HRGN hRgnUpdate;
bool hasOKText;
CLIPFORMAT cfColumnSelect;
CLIPFORMAT cfLineSelect;
HRESULT hrOle;
DropSource ds;
DataObject dob;
DropTarget dt;
static HINSTANCE hInstance;
ScintillaWin(HWND hwnd);
ScintillaWin(const ScintillaWin &) : ScintillaBase() {}
virtual ~ScintillaWin();
ScintillaWin &operator=(const ScintillaWin &) { return *this; }
virtual void Initialise();
virtual void Finalise();
HWND MainHWND();
static sptr_t DirectFunction(
ScintillaWin *sci, UINT iMessage, uptr_t wParam, sptr_t lParam);
static sptr_t PASCAL SWndProc(
HWND hWnd, UINT iMessage, WPARAM wParam, sptr_t lParam);
static sptr_t PASCAL CTWndProc(
HWND hWnd, UINT iMessage, WPARAM wParam, sptr_t lParam);
enum { invalidTimerID, standardTimerID, idleTimerID };
virtual bool DragThreshold(Point ptStart, Point ptNow);
virtual void StartDrag();
sptr_t WndPaint(uptr_t wParam);
sptr_t HandleComposition(uptr_t wParam, sptr_t lParam);
virtual bool ValidCodePage(int codePage) const;
virtual sptr_t DefWndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
virtual bool SetIdle(bool on);
virtual void SetTicking(bool on);
virtual void SetMouseCapture(bool on);
virtual bool HaveMouseCapture();
virtual bool PaintContains(PRectangle rc);
virtual void ScrollText(int linesToMove);
virtual void UpdateSystemCaret();
virtual void SetVerticalScrollPos();
virtual void SetHorizontalScrollPos();
virtual bool ModifyScrollBars(int nMax, int nPage);
virtual void NotifyChange();
virtual void NotifyFocus(bool focus);
virtual int GetCtrlID();
virtual void NotifyParent(SCNotification scn);
virtual void NotifyDoubleClick(Point pt, bool shift, bool ctrl, bool alt);
virtual void Copy();
virtual void CopyAllowLine();
virtual bool CanPaste();
virtual void Paste();
virtual void CreateCallTipWindow(PRectangle rc);
virtual void AddToPopUp(const char *label, int cmd = 0, bool enabled = true);
virtual void ClaimSelection();
// DBCS
void ImeStartComposition();
void ImeEndComposition();
void AddCharBytes(char b0, char b1);
void GetIntelliMouseParameters();
virtual void CopyToClipboard(const SelectionText &selectedText);
void ScrollMessage(WPARAM wParam);
void HorizontalScrollMessage(WPARAM wParam);
void RealizeWindowPalette(bool inBackGround);
void FullPaint();
void FullPaintDC(HDC dc);
bool IsCompatibleDC(HDC dc);
DWORD EffectFromState(DWORD grfKeyState);
virtual int SetScrollInfo(int nBar, LPCSCROLLINFO lpsi, BOOL bRedraw);
virtual bool GetScrollInfo(int nBar, LPSCROLLINFO lpsi);
void ChangeScrollPos(int barType, int pos);
void InsertPasteText(const char *text, int len, int selStart, bool isRectangular, bool isLine);
public:
// Public for benefit of Scintilla_DirectFunction
virtual sptr_t WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
/// Implement IUnknown
STDMETHODIMP QueryInterface(REFIID riid, PVOID *ppv);
STDMETHODIMP_(ULONG)AddRef();
STDMETHODIMP_(ULONG)Release();
/// Implement IDropTarget
STDMETHODIMP DragEnter(LPDATAOBJECT pIDataSource, DWORD grfKeyState,
POINTL pt, PDWORD pdwEffect);
STDMETHODIMP DragOver(DWORD grfKeyState, POINTL pt, PDWORD pdwEffect);
STDMETHODIMP DragLeave();
STDMETHODIMP Drop(LPDATAOBJECT pIDataSource, DWORD grfKeyState,
POINTL pt, PDWORD pdwEffect);
/// Implement important part of IDataObject
STDMETHODIMP GetData(FORMATETC *pFEIn, STGMEDIUM *pSTM);
// External Lexers
#ifdef SCI_LEXER
void SetLexerLanguage(const char *languageName);
void SetLexer(uptr_t wParam);
#endif
static bool Register(HINSTANCE hInstance_);
static bool Unregister();
friend class DropSource;
friend class DataObject;
friend class DropTarget;
bool DragIsRectangularOK(CLIPFORMAT fmt) {
return drag.rectangular && (fmt == cfColumnSelect);
}
private:
// For use in creating a system caret
bool HasCaretSizeChanged();
BOOL CreateSystemCaret();
BOOL DestroySystemCaret();
HBITMAP sysCaretBitmap;
int sysCaretWidth;
int sysCaretHeight;
};
HINSTANCE ScintillaWin::hInstance = 0;
ScintillaWin::ScintillaWin(HWND hwnd) {
lastKeyDownConsumed = false;
capturedMouse = false;
linesPerScroll = 0;
wheelDelta = 0; // Wheel delta from roll
hRgnUpdate = 0;
hasOKText = false;
// There does not seem to be a real standard for indicating that the clipboard
// contains a rectangular selection, so copy Developer Studio.
cfColumnSelect = static_cast<CLIPFORMAT>(
::RegisterClipboardFormat(TEXT("MSDEVColumnSelect")));
// Likewise for line-copy (copies a full line when no text is selected)
cfLineSelect = static_cast<CLIPFORMAT>(
::RegisterClipboardFormat(TEXT("MSDEVLineSelect")));
hrOle = E_FAIL;
wMain = hwnd;
dob.sci = this;
ds.sci = this;
dt.sci = this;
sysCaretBitmap = 0;
sysCaretWidth = 0;
sysCaretHeight = 0;
Initialise();
}
ScintillaWin::~ScintillaWin() {}
void ScintillaWin::Initialise() {
// Initialize COM. If the app has already done this it will have
// no effect. If the app hasnt, we really shouldnt ask them to call
// it just so this internal feature works.
hrOle = ::OleInitialize(NULL);
}
void ScintillaWin::Finalise() {
ScintillaBase::Finalise();
SetTicking(false);
SetIdle(false);
DestroySystemCaret();
::RevokeDragDrop(MainHWND());
if (SUCCEEDED(hrOle)) {
::OleUninitialize();
}
}
HWND ScintillaWin::MainHWND() {
return reinterpret_cast<HWND>(wMain.GetID());
}
bool ScintillaWin::DragThreshold(Point ptStart, Point ptNow) {
int xMove = abs(ptStart.x - ptNow.x);
int yMove = abs(ptStart.y - ptNow.y);
return (xMove > ::GetSystemMetrics(SM_CXDRAG)) ||
(yMove > ::GetSystemMetrics(SM_CYDRAG));
}
void ScintillaWin::StartDrag() {
inDragDrop = ddDragging;
DWORD dwEffect = 0;
dropWentOutside = true;
IDataObject *pDataObject = reinterpret_cast<IDataObject *>(&dob);
IDropSource *pDropSource = reinterpret_cast<IDropSource *>(&ds);
//Platform::DebugPrintf("About to DoDragDrop %x %x\n", pDataObject, pDropSource);
HRESULT hr = ::DoDragDrop(
pDataObject,
pDropSource,
DROPEFFECT_COPY | DROPEFFECT_MOVE, &dwEffect);
//Platform::DebugPrintf("DoDragDrop = %x\n", hr);
if (SUCCEEDED(hr)) {
if ((hr == DRAGDROP_S_DROP) && (dwEffect == DROPEFFECT_MOVE) && dropWentOutside) {
// Remove dragged out text
ClearSelection();
}
}
inDragDrop = ddNone;
SetDragPosition(invalidPosition);
}
// Avoid warnings everywhere for old style casts by concentrating them here
static WORD LoWord(DWORD l) {
return LOWORD(l);
}
static WORD HiWord(DWORD l) {
return HIWORD(l);
}
static int InputCodePage() {
HKL inputLocale = ::GetKeyboardLayout(0);
LANGID inputLang = LOWORD(inputLocale);
char sCodePage[10];
int res = ::GetLocaleInfoA(MAKELCID(inputLang, SORT_DEFAULT),
LOCALE_IDEFAULTANSICODEPAGE, sCodePage, sizeof(sCodePage));
if (!res)
return 0;
return atoi(sCodePage);
}
#ifndef VK_OEM_2
static const int VK_OEM_2=0xbf;
static const int VK_OEM_3=0xc0;
static const int VK_OEM_4=0xdb;
static const int VK_OEM_5=0xdc;
static const int VK_OEM_6=0xdd;
#endif
/** Map the key codes to their equivalent SCK_ form. */
static int KeyTranslate(int keyIn) {
//PLATFORM_ASSERT(!keyIn);
switch (keyIn) {
case VK_DOWN: return SCK_DOWN;
case VK_UP: return SCK_UP;
case VK_LEFT: return SCK_LEFT;
case VK_RIGHT: return SCK_RIGHT;
case VK_HOME: return SCK_HOME;
case VK_END: return SCK_END;
case VK_PRIOR: return SCK_PRIOR;
case VK_NEXT: return SCK_NEXT;
case VK_DELETE: return SCK_DELETE;
case VK_INSERT: return SCK_INSERT;
case VK_ESCAPE: return SCK_ESCAPE;
case VK_BACK: return SCK_BACK;
case VK_TAB: return SCK_TAB;
case VK_RETURN: return SCK_RETURN;
case VK_ADD: return SCK_ADD;
case VK_SUBTRACT: return SCK_SUBTRACT;
case VK_DIVIDE: return SCK_DIVIDE;
case VK_LWIN: return SCK_WIN;
case VK_RWIN: return SCK_RWIN;
case VK_APPS: return SCK_MENU;
case VK_OEM_2: return '/';
case VK_OEM_3: return '`';
case VK_OEM_4: return '[';
case VK_OEM_5: return '\\';
case VK_OEM_6: return ']';
default: return keyIn;
}
}
LRESULT ScintillaWin::WndPaint(uptr_t wParam) {
//ElapsedTime et;
// Redirect assertions to debug output and save current state
bool assertsPopup = Platform::ShowAssertionPopUps(false);
paintState = painting;
PAINTSTRUCT ps;
PAINTSTRUCT *pps;
bool IsOcxCtrl = (wParam != 0); // if wParam != 0, it contains
// a PAINSTRUCT* from the OCX
// Removed since this interferes with reporting other assertions as it occurs repeatedly
//PLATFORM_ASSERT(hRgnUpdate == NULL);
hRgnUpdate = ::CreateRectRgn(0, 0, 0, 0);
if (IsOcxCtrl) {
pps = reinterpret_cast<PAINTSTRUCT*>(wParam);
} else {
::GetUpdateRgn(MainHWND(), hRgnUpdate, FALSE);
pps = &ps;
::BeginPaint(MainHWND(), pps);
}
AutoSurface surfaceWindow(pps->hdc, this);
if (surfaceWindow) {
rcPaint = PRectangle(pps->rcPaint.left, pps->rcPaint.top, pps->rcPaint.right, pps->rcPaint.bottom);
PRectangle rcClient = GetClientRectangle();
paintingAllText = rcPaint.Contains(rcClient);
if (paintingAllText) {
//Platform::DebugPrintf("Performing full text paint\n");
} else {
//Platform::DebugPrintf("Performing partial paint %d .. %d\n", rcPaint.top, rcPaint.bottom);
}
Paint(surfaceWindow, rcPaint);
surfaceWindow->Release();
}
if (hRgnUpdate) {
::DeleteRgn(hRgnUpdate);
hRgnUpdate = 0;
}
if(!IsOcxCtrl)
::EndPaint(MainHWND(), pps);
if (paintState == paintAbandoned) {
// Painting area was insufficient to cover new styling or brace highlight positions
FullPaint();
}
paintState = notPainting;
// Restore debug output state
Platform::ShowAssertionPopUps(assertsPopup);
//Platform::DebugPrintf("Paint took %g\n", et.Duration());
return 0l;
}
sptr_t ScintillaWin::HandleComposition(uptr_t wParam, sptr_t lParam) {
#ifdef __DMC__
// Digital Mars compiler does not include Imm library
return 0;
#else
if (lParam & GCS_RESULTSTR) {
HIMC hIMC = ::ImmGetContext(MainHWND());
if (hIMC) {
const int maxLenInputIME = 200;
wchar_t wcs[maxLenInputIME];
LONG bytes = ::ImmGetCompositionStringW(hIMC,
GCS_RESULTSTR, wcs, (maxLenInputIME-1)*2);
int wides = bytes / 2;
if (IsUnicodeMode()) {
char utfval[maxLenInputIME * 3];
unsigned int len = UTF8Length(wcs, wides);
UTF8FromUTF16(wcs, wides, utfval, len);
utfval[len] = '\0';
AddCharUTF(utfval, len);
} else {
char dbcsval[maxLenInputIME * 2];
int size = ::WideCharToMultiByte(InputCodePage(),
0, wcs, wides, dbcsval, sizeof(dbcsval) - 1, 0, 0);
for (int i=0; i<size; i++) {
AddChar(dbcsval[i]);
}
}
// Set new position after converted
Point pos = LocationFromPosition(currentPos);
COMPOSITIONFORM CompForm;
CompForm.dwStyle = CFS_POINT;
CompForm.ptCurrentPos.x = pos.x;
CompForm.ptCurrentPos.y = pos.y;
::ImmSetCompositionWindow(hIMC, &CompForm);
::ImmReleaseContext(MainHWND(), hIMC);
}
return 0;
}
return ::DefWindowProc(MainHWND(), WM_IME_COMPOSITION, wParam, lParam);
#endif
}
// Translate message IDs from WM_* and EM_* to SCI_* so can partly emulate Windows Edit control
static unsigned int SciMessageFromEM(unsigned int iMessage) {
switch (iMessage) {
case EM_CANPASTE: return SCI_CANPASTE;
case EM_CANUNDO: return SCI_CANUNDO;
case EM_EMPTYUNDOBUFFER: return SCI_EMPTYUNDOBUFFER;
case EM_FINDTEXTEX: return SCI_FINDTEXT;
case EM_FORMATRANGE: return SCI_FORMATRANGE;
case EM_GETFIRSTVISIBLELINE: return SCI_GETFIRSTVISIBLELINE;
case EM_GETLINECOUNT: return SCI_GETLINECOUNT;
case EM_GETSELTEXT: return SCI_GETSELTEXT;
case EM_GETTEXTRANGE: return SCI_GETTEXTRANGE;
case EM_HIDESELECTION: return SCI_HIDESELECTION;
case EM_LINEINDEX: return SCI_POSITIONFROMLINE;
case EM_LINESCROLL: return SCI_LINESCROLL;
case EM_REPLACESEL: return SCI_REPLACESEL;
case EM_SCROLLCARET: return SCI_SCROLLCARET;
case EM_SETREADONLY: return SCI_SETREADONLY;
case WM_CLEAR: return SCI_CLEAR;
case WM_COPY: return SCI_COPY;
case WM_CUT: return SCI_CUT;
case WM_GETTEXT: return SCI_GETTEXT;
case WM_SETTEXT: return SCI_SETTEXT;
case WM_GETTEXTLENGTH: return SCI_GETTEXTLENGTH;
case WM_PASTE: return SCI_PASTE;
case WM_UNDO: return SCI_UNDO;
}
return iMessage;
}
static UINT CodePageFromCharSet(DWORD characterSet, UINT documentCodePage) {
CHARSETINFO ci = { 0, 0, { { 0, 0, 0, 0 }, { 0, 0 } } };
BOOL bci = ::TranslateCharsetInfo((DWORD*)characterSet,
&ci, TCI_SRCCHARSET);
UINT cp;
if (bci)
cp = ci.ciACP;
else
cp = documentCodePage;
CPINFO cpi;
if (!IsValidCodePage(cp) && !GetCPInfo(cp, &cpi))
cp = CP_ACP;
return cp;
}
sptr_t ScintillaWin::WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
//Platform::DebugPrintf("S M:%x WP:%x L:%x\n", iMessage, wParam, lParam);
iMessage = SciMessageFromEM(iMessage);
switch (iMessage) {
case WM_CREATE:
ctrlID = ::GetDlgCtrlID(reinterpret_cast<HWND>(wMain.GetID()));
// Get Intellimouse scroll line parameters
GetIntelliMouseParameters();
::RegisterDragDrop(MainHWND(), reinterpret_cast<IDropTarget *>(&dt));
break;
case WM_COMMAND:
#ifdef TOTAL_CONTROL
Command(LoWord(wParam));
#endif
break;
case WM_PAINT:
return WndPaint(wParam);
case WM_PRINTCLIENT: {
HDC hdc = reinterpret_cast<HDC>(wParam);
if (!IsCompatibleDC(hdc)) {
return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
}
FullPaintDC(hdc);
}
break;
case WM_VSCROLL:
ScrollMessage(wParam);
break;
case WM_HSCROLL:
HorizontalScrollMessage(wParam);
break;
case WM_SIZE: {
//Platform::DebugPrintf("Scintilla WM_SIZE %d %d\n", LoWord(lParam), HiWord(lParam));
ChangeSize();
}
break;
case WM_MOUSEWHEEL:
// Don't handle datazoom.
// (A good idea for datazoom would be to "fold" or "unfold" details.
// i.e. if datazoomed out only class structures are visible, when datazooming in the control
// structures appear, then eventually the individual statements...)
if (wParam & MK_SHIFT) {
return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
}
// Either SCROLL or ZOOM. We handle the wheel steppings calculation
wheelDelta -= static_cast<short>(HiWord(wParam));
if (abs(wheelDelta) >= WHEEL_DELTA && linesPerScroll > 0) {
int linesToScroll = linesPerScroll;
if (linesPerScroll == WHEEL_PAGESCROLL)
linesToScroll = LinesOnScreen() - 1;
if (linesToScroll == 0) {
linesToScroll = 1;
}
linesToScroll *= (wheelDelta / WHEEL_DELTA);
if (wheelDelta >= 0)
wheelDelta = wheelDelta % WHEEL_DELTA;
else
wheelDelta = - (-wheelDelta % WHEEL_DELTA);
if (wParam & MK_CONTROL) {
// Zoom! We play with the font sizes in the styles.
// Number of steps/line is ignored, we just care if sizing up or down
if (linesToScroll < 0) {
KeyCommand(SCI_ZOOMIN);
} else {
KeyCommand(SCI_ZOOMOUT);
}
} else {
// Scroll
ScrollTo(topLine + linesToScroll);
}
}
return 0;
case WM_TIMER:
if (wParam == standardTimerID && timer.ticking) {
Tick();
} else if (wParam == idleTimerID && idler.state) {
SendMessage(MainHWND(), SC_WIN_IDLE, 0, 1);
} else {
return 1;
}
break;
case SC_WIN_IDLE:
// wParam=dwTickCountInitial, or 0 to initialize. lParam=bSkipUserInputTest
if (idler.state) {
if (lParam || (WAIT_TIMEOUT==MsgWaitForMultipleObjects(0,0,0,0, QS_INPUT|QS_HOTKEY))) {
if (Idle()) {
// User input was given priority above, but all events do get a turn. Other
// messages, notifications, etc. will get interleaved with the idle messages.
// However, some things like WM_PAINT are a lower priority, and will not fire
// when there's a message posted. So, several times a second, we stop and let
// the low priority events have a turn (after which the timer will fire again).
DWORD dwCurrent = GetTickCount();
DWORD dwStart = wParam ? wParam : dwCurrent;
if (dwCurrent >= dwStart && dwCurrent > 200 && dwCurrent - 200 < dwStart)
PostMessage(MainHWND(), SC_WIN_IDLE, dwStart, 0);
} else {
SetIdle(false);
}
}
}
break;
case WM_GETMINMAXINFO:
return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
case WM_LBUTTONDOWN: {
#ifndef __DMC__
// Digital Mars compiler does not include Imm library
// For IME, set the composition string as the result string.
HIMC hIMC = ::ImmGetContext(MainHWND());
::ImmNotifyIME(hIMC, NI_COMPOSITIONSTR, CPS_COMPLETE, 0);
::ImmReleaseContext(MainHWND(), hIMC);
#endif
//
//Platform::DebugPrintf("Buttdown %d %x %x %x %x %x\n",iMessage, wParam, lParam,
// Platform::IsKeyDown(VK_SHIFT),
// Platform::IsKeyDown(VK_CONTROL),
// Platform::IsKeyDown(VK_MENU));
ButtonDown(Point::FromLong(lParam), ::GetMessageTime(),
(wParam & MK_SHIFT) != 0,
(wParam & MK_CONTROL) != 0,
Platform::IsKeyDown(VK_MENU));
::SetFocus(MainHWND());
}
break;
case WM_MOUSEMOVE:
ButtonMove(Point::FromLong(lParam));
break;
case WM_LBUTTONUP:
ButtonUp(Point::FromLong(lParam),
::GetMessageTime(),
(wParam & MK_CONTROL) != 0);
break;
case WM_SETCURSOR:
if (LoWord(lParam) == HTCLIENT) {
if (inDragDrop == ddDragging) {
DisplayCursor(Window::cursorUp);
} else {
// Display regular (drag) cursor over selection
POINT pt;
::GetCursorPos(&pt);
::ScreenToClient(MainHWND(), &pt);
if (PointInSelMargin(Point(pt.x, pt.y))) {
DisplayCursor(Window::cursorReverseArrow);
} else if (PointInSelection(Point(pt.x, pt.y)) && !SelectionEmpty()) {
DisplayCursor(Window::cursorArrow);
} else if (PointIsHotspot(Point(pt.x, pt.y))) {
DisplayCursor(Window::cursorHand);
} else {
DisplayCursor(Window::cursorText);
}
}
return TRUE;
} else {
return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
}
case WM_CHAR:
if (((wParam >= 128) || !iscntrl(wParam)) || !lastKeyDownConsumed) {
if (::IsWindowUnicode(MainHWND())) {
wchar_t wcs[2] = {wParam, 0};
if (IsUnicodeMode()) {
// For a wide character version of the window:
char utfval[4];
unsigned int len = UTF8Length(wcs, 1);
UTF8FromUTF16(wcs, 1, utfval, len);
AddCharUTF(utfval, len);
} else {
UINT cpDest = CodePageFromCharSet(
vs.styles[STYLE_DEFAULT].characterSet, pdoc->dbcsCodePage);
char inBufferCP[20];
int size = ::WideCharToMultiByte(cpDest,
0, wcs, 1, inBufferCP, sizeof(inBufferCP) - 1, 0, 0);
AddCharUTF(inBufferCP, size);
}
} else {
if (IsUnicodeMode()) {
AddCharBytes('\0', LOBYTE(wParam));
} else {
AddChar(LOBYTE(wParam));
}
}
}
return 0;
case WM_UNICHAR:
if (wParam == UNICODE_NOCHAR) {
return IsUnicodeMode() ? 1 : 0;
} else if (lastKeyDownConsumed) {
return 1;
} else {
if (IsUnicodeMode()) {
char utfval[4];
wchar_t wcs[2] = {static_cast<wchar_t>(wParam), 0};
unsigned int len = UTF8Length(wcs, 1);
UTF8FromUTF16(wcs, 1, utfval, len);
AddCharUTF(utfval, len);
return 1;
} else {
return 0;
}
}
case WM_SYSKEYDOWN:
case WM_KEYDOWN: {
//Platform::DebugPrintf("S keydown %d %x %x %x %x\n",iMessage, wParam, lParam, ::IsKeyDown(VK_SHIFT), ::IsKeyDown(VK_CONTROL));
lastKeyDownConsumed = false;
int ret = KeyDown(KeyTranslate(wParam),
Platform::IsKeyDown(VK_SHIFT),
Platform::IsKeyDown(VK_CONTROL),
Platform::IsKeyDown(VK_MENU),
&lastKeyDownConsumed);
if (!ret && !lastKeyDownConsumed) {
return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
}
break;
}
case WM_IME_KEYDOWN:
return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
case WM_KEYUP:
//Platform::DebugPrintf("S keyup %d %x %x\n",iMessage, wParam, lParam);
return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
case WM_SETTINGCHANGE:
//Platform::DebugPrintf("Setting Changed\n");
InvalidateStyleData();
// Get Intellimouse scroll line parameters
GetIntelliMouseParameters();
break;
case WM_GETDLGCODE:
return DLGC_HASSETSEL | DLGC_WANTALLKEYS;
case WM_KILLFOCUS: {
HWND wOther = reinterpret_cast<HWND>(wParam);
HWND wThis = MainHWND();
HWND wCT = reinterpret_cast<HWND>(ct.wCallTip.GetID());
if (!wParam ||
!(::IsChild(wThis,wOther) || (wOther == wCT))) {
SetFocusState(false);
DestroySystemCaret();
}
}
//RealizeWindowPalette(true);
break;
case WM_SETFOCUS:
SetFocusState(true);
RealizeWindowPalette(false);
DestroySystemCaret();
CreateSystemCaret();
break;
case WM_SYSCOLORCHANGE:
//Platform::DebugPrintf("Setting Changed\n");
InvalidateStyleData();
break;
case WM_PALETTECHANGED:
if (wParam != reinterpret_cast<uptr_t>(MainHWND())) {
//Platform::DebugPrintf("** Palette Changed\n");
RealizeWindowPalette(true);
}
break;
case WM_QUERYNEWPALETTE:
//Platform::DebugPrintf("** Query palette\n");
RealizeWindowPalette(false);
break;
case WM_IME_STARTCOMPOSITION: // dbcs
ImeStartComposition();
return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
case WM_IME_ENDCOMPOSITION: // dbcs
ImeEndComposition();
return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
case WM_IME_COMPOSITION:
return HandleComposition(wParam, lParam);
case WM_IME_CHAR: {
AddCharBytes(HIBYTE(wParam), LOBYTE(wParam));
return 0;
}
case WM_CONTEXTMENU:
#ifdef TOTAL_CONTROL
if (displayPopupMenu) {
Point pt = Point::FromLong(lParam);
if ((pt.x == -1) && (pt.y == -1)) {
// Caused by keyboard so display menu near caret
pt = LocationFromPosition(currentPos);
POINT spt = {pt.x, pt.y};
::ClientToScreen(MainHWND(), &spt);
pt = Point(spt.x, spt.y);
}
ContextMenu(pt);
return 0;
}
#endif
return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
case WM_INPUTLANGCHANGE:
//::SetThreadLocale(LOWORD(lParam));
return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
case WM_INPUTLANGCHANGEREQUEST:
return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
case WM_ERASEBKGND:
return 1; // Avoid any background erasure as whole window painted.
case WM_CAPTURECHANGED:
capturedMouse = false;
return 0;
// These are not handled in Scintilla and its faster to dispatch them here.
// Also moves time out to here so profile doesn't count lots of empty message calls.
case WM_MOVE:
case WM_MOUSEACTIVATE:
case WM_NCHITTEST:
case WM_NCCALCSIZE:
case WM_NCPAINT:
case WM_NCMOUSEMOVE:
case WM_NCLBUTTONDOWN:
case WM_IME_SETCONTEXT:
case WM_IME_NOTIFY:
case WM_SYSCOMMAND:
case WM_WINDOWPOSCHANGING:
case WM_WINDOWPOSCHANGED:
return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
case EM_LINEFROMCHAR:
if (static_cast<int>(wParam) < 0) {
wParam = SelectionStart();
}
return pdoc->LineFromPosition(wParam);
case EM_EXLINEFROMCHAR:
return pdoc->LineFromPosition(lParam);
case EM_GETSEL:
if (wParam) {
*reinterpret_cast<int *>(wParam) = SelectionStart();
}
if (lParam) {
*reinterpret_cast<int *>(lParam) = SelectionEnd();
}
return MAKELONG(SelectionStart(), SelectionEnd());
case EM_EXGETSEL: {
if (lParam == 0) {
return 0;
}
CharacterRange *pCR = reinterpret_cast<CharacterRange *>(lParam);
pCR->cpMin = SelectionStart();
pCR->cpMax = SelectionEnd();
}
break;
case EM_SETSEL: {
int nStart = static_cast<int>(wParam);
int nEnd = static_cast<int>(lParam);
if (nStart == 0 && nEnd == -1) {
nEnd = pdoc->Length();
}
if (nStart == -1) {
nStart = nEnd; // Remove selection
}
if (nStart > nEnd) {
SetSelection(nEnd, nStart);
} else {
SetSelection(nStart, nEnd);
}
EnsureCaretVisible();
}
break;
case EM_EXSETSEL: {
if (lParam == 0) {
return 0;
}
CharacterRange *pCR = reinterpret_cast<CharacterRange *>(lParam);
selType = selStream;
if (pCR->cpMin == 0 && pCR->cpMax == -1) {
SetSelection(pCR->cpMin, pdoc->Length());
} else {
SetSelection(pCR->cpMin, pCR->cpMax);
}
EnsureCaretVisible();
return pdoc->LineFromPosition(SelectionStart());
}
case SCI_GETDIRECTFUNCTION:
return reinterpret_cast<sptr_t>(DirectFunction);
case SCI_GETDIRECTPOINTER:
return reinterpret_cast<sptr_t>(this);
case SCI_GRABFOCUS:
::SetFocus(MainHWND());
break;
#ifdef SCI_LEXER
case SCI_LOADLEXERLIBRARY:
LexerManager::GetInstance()->Load(reinterpret_cast<const char*>(lParam));
break;
#endif
default:
return ScintillaBase::WndProc(iMessage, wParam, lParam);
}
return 0l;
}
bool ScintillaWin::ValidCodePage(int codePage) const {
return codePage == 0 || codePage == SC_CP_UTF8 ||
codePage == 932 || codePage == 936 || codePage == 949 ||
codePage == 950 || codePage == 1361;
}
sptr_t ScintillaWin::DefWndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam) {
return ::DefWindowProc(MainHWND(), iMessage, wParam, lParam);
}
void ScintillaWin::SetTicking(bool on) {
if (timer.ticking != on) {
timer.ticking = on;
if (timer.ticking) {
timer.tickerID = ::SetTimer(MainHWND(), standardTimerID, timer.tickSize, NULL)
? reinterpret_cast<TickerID>(standardTimerID) : 0;
} else {
::KillTimer(MainHWND(), reinterpret_cast<uptr_t>(timer.tickerID));
timer.tickerID = 0;
}
}
timer.ticksToWait = caret.period;
}
bool ScintillaWin::SetIdle(bool on) {
// On Win32 the Idler is implemented as a Timer on the Scintilla window. This
// takes advantage of the fact that WM_TIMER messages are very low priority,
// and are only posted when the message queue is empty, i.e. during idle time.
if (idler.state != on) {
if (on) {
idler.idlerID = ::SetTimer(MainHWND(), idleTimerID, 10, NULL)
? reinterpret_cast<IdlerID>(idleTimerID) : 0;
} else {
::KillTimer(MainHWND(), reinterpret_cast<uptr_t>(idler.idlerID));
idler.idlerID = 0;
}
idler.state = idler.idlerID != 0;
}
return idler.state;
}
void ScintillaWin::SetMouseCapture(bool on) {
if (mouseDownCaptures) {
if (on) {
::SetCapture(MainHWND());
} else {
::ReleaseCapture();
}
}
capturedMouse = on;
}
bool ScintillaWin::HaveMouseCapture() {
// Cannot just see if GetCapture is this window as the scroll bar also sets capture for the window
return capturedMouse;
//return capturedMouse && (::GetCapture() == MainHWND());
}
bool ScintillaWin::PaintContains(PRectangle rc) {
bool contains = true;
if ((paintState == painting) && (!rc.Empty())) {
if (!rcPaint.Contains(rc)) {
contains = false;
} else {
// In bounding rectangle so check more accurately using region
HRGN hRgnRange = ::CreateRectRgn(rc.left, rc.top, rc.right, rc.bottom);
if (hRgnRange) {
HRGN hRgnDest = ::CreateRectRgn(0, 0, 0, 0);
if (hRgnDest) {
int combination = ::CombineRgn(hRgnDest, hRgnRange, hRgnUpdate, RGN_DIFF);
if (combination != NULLREGION) {
contains = false;
}
::DeleteRgn(hRgnDest);
}
::DeleteRgn(hRgnRange);
}
}
}
return contains;
}
void ScintillaWin::ScrollText(int linesToMove) {
//Platform::DebugPrintf("ScintillaWin::ScrollText %d\n", linesToMove);
::ScrollWindow(MainHWND(), 0,
vs.lineHeight * linesToMove, 0, 0);
::UpdateWindow(MainHWND());
}
void ScintillaWin::UpdateSystemCaret() {
if (hasFocus) {
if (HasCaretSizeChanged()) {
DestroySystemCaret();
CreateSystemCaret();
}
Point pos = LocationFromPosition(currentPos);
::SetCaretPos(pos.x, pos.y);
}
}
int ScintillaWin::SetScrollInfo(int nBar, LPCSCROLLINFO lpsi, BOOL bRedraw) {
return ::SetScrollInfo(MainHWND(), nBar, lpsi, bRedraw);
}
bool ScintillaWin::GetScrollInfo(int nBar, LPSCROLLINFO lpsi) {
return ::GetScrollInfo(MainHWND(), nBar, lpsi) ? true : false;
}
// Change the scroll position but avoid repaint if changing to same value
void ScintillaWin::ChangeScrollPos(int barType, int pos) {
SCROLLINFO sci = {
sizeof(sci),0,0,0,0,0,0
};
sci.fMask = SIF_POS;
GetScrollInfo(barType, &sci);
if (sci.nPos != pos) {
DwellEnd(true);
sci.nPos = pos;
SetScrollInfo(barType, &sci, TRUE);
}
}
void ScintillaWin::SetVerticalScrollPos() {
ChangeScrollPos(SB_VERT, topLine);
}
void ScintillaWin::SetHorizontalScrollPos() {
ChangeScrollPos(SB_HORZ, xOffset);
}
bool ScintillaWin::ModifyScrollBars(int nMax, int nPage) {
bool modified = false;
SCROLLINFO sci = {
sizeof(sci),0,0,0,0,0,0
};
sci.fMask = SIF_PAGE | SIF_RANGE;
GetScrollInfo(SB_VERT, &sci);
int vertEndPreferred = nMax;
if (!verticalScrollBarVisible)
vertEndPreferred = 0;
if ((sci.nMin != 0) ||
(sci.nMax != vertEndPreferred) ||
(sci.nPage != static_cast<unsigned int>(nPage)) ||
(sci.nPos != 0)) {
//Platform::DebugPrintf("Scroll info changed %d %d %d %d %d\n",
// sci.nMin, sci.nMax, sci.nPage, sci.nPos, sci.nTrackPos);
sci.fMask = SIF_PAGE | SIF_RANGE;
sci.nMin = 0;
sci.nMax = vertEndPreferred;
sci.nPage = nPage;
sci.nPos = 0;
sci.nTrackPos = 1;
SetScrollInfo(SB_VERT, &sci, TRUE);
modified = true;
}
PRectangle rcText = GetTextRectangle();
int horizEndPreferred = scrollWidth;
if (horizEndPreferred < 0)
horizEndPreferred = 0;
if (!horizontalScrollBarVisible || (wrapState != eWrapNone))
horizEndPreferred = 0;
unsigned int pageWidth = rcText.Width();
sci.fMask = SIF_PAGE | SIF_RANGE;
GetScrollInfo(SB_HORZ, &sci);
if ((sci.nMin != 0) ||
(sci.nMax != horizEndPreferred) ||
(sci.nPage != pageWidth) ||
(sci.nPos != 0)) {
sci.fMask = SIF_PAGE | SIF_RANGE;
sci.nMin = 0;
sci.nMax = horizEndPreferred;
sci.nPage = pageWidth;
sci.nPos = 0;
sci.nTrackPos = 1;
SetScrollInfo(SB_HORZ, &sci, TRUE);
modified = true;
if (scrollWidth < static_cast<int>(pageWidth)) {
HorizontalScrollTo(0);
}
}
return modified;
}
void ScintillaWin::NotifyChange() {
::SendMessage(::GetParent(MainHWND()), WM_COMMAND,
MAKELONG(GetCtrlID(), SCEN_CHANGE),
reinterpret_cast<LPARAM>(MainHWND()));
}
void ScintillaWin::NotifyFocus(bool focus) {
::SendMessage(::GetParent(MainHWND()), WM_COMMAND,
MAKELONG(GetCtrlID(), focus ? SCEN_SETFOCUS : SCEN_KILLFOCUS),
reinterpret_cast<LPARAM>(MainHWND()));
}
int ScintillaWin::GetCtrlID() {
return ::GetDlgCtrlID(reinterpret_cast<HWND>(wMain.GetID()));
}
void ScintillaWin::NotifyParent(SCNotification scn) {
scn.nmhdr.hwndFrom = MainHWND();
scn.nmhdr.idFrom = GetCtrlID();
::SendMessage(::GetParent(MainHWND()), WM_NOTIFY,
GetCtrlID(), reinterpret_cast<LPARAM>(&scn));
}
void ScintillaWin::NotifyDoubleClick(Point pt, bool shift, bool ctrl, bool alt) {
//Platform::DebugPrintf("ScintillaWin Double click 0\n");
ScintillaBase::NotifyDoubleClick(pt, shift, ctrl, alt);
// Send myself a WM_LBUTTONDBLCLK, so the container can handle it too.
::SendMessage(MainHWND(),
WM_LBUTTONDBLCLK,
shift ? MK_SHIFT : 0,
MAKELPARAM(pt.x, pt.y));
}
void ScintillaWin::Copy() {
//Platform::DebugPrintf("Copy\n");
if (currentPos != anchor) {
SelectionText selectedText;
CopySelectionRange(&selectedText);
CopyToClipboard(selectedText);
}
}
void ScintillaWin::CopyAllowLine() {
SelectionText selectedText;
CopySelectionRange(&selectedText, true);
CopyToClipboard(selectedText);
}
bool ScintillaWin::CanPaste() {
if (!Editor::CanPaste())
return false;
if (::IsClipboardFormatAvailable(CF_TEXT))
return true;
if (IsUnicodeMode())
return ::IsClipboardFormatAvailable(CF_UNICODETEXT) != 0;
return false;
}
class GlobalMemory {
HGLOBAL hand;
public:
void *ptr;
GlobalMemory() : hand(0), ptr(0) {
}
GlobalMemory(HGLOBAL hand_) : hand(hand_), ptr(0) {
if (hand) {
ptr = ::GlobalLock(hand);
}
}
~GlobalMemory() {
PLATFORM_ASSERT(!ptr);
}
void Allocate(size_t bytes) {
hand = ::GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, bytes);
if (hand) {
ptr = ::GlobalLock(hand);
}
}
HGLOBAL Unlock() {
PLATFORM_ASSERT(ptr);
HGLOBAL handCopy = hand;
::GlobalUnlock(hand);
ptr = 0;
hand = 0;
return handCopy;
}
void SetClip(UINT uFormat) {
::SetClipboardData(uFormat, Unlock());
}
operator bool() {
return ptr != 0;
}
SIZE_T Size() {
return ::GlobalSize(hand);
}
};
void ScintillaWin::InsertPasteText(const char *text, int len, int selStart, bool isRectangular, bool isLine) {
if (isRectangular) {
PasteRectangular(selStart, text, len);
} else {
char *convertedText = 0;
if (convertPastes) {
// Convert line endings of the paste into our local line-endings mode
convertedText = Document::TransformLineEnds(&len, text, len, pdoc->eolMode);
text = convertedText;
}
if (isLine) {
int insertPos = pdoc->LineStart(pdoc->LineFromPosition(currentPos));
pdoc->InsertString(insertPos, text, len);
// add the newline if necessary
if ((len > 0) && (text[len-1] != '\n' && text[len-1] != '\r')) {
const char *endline = StringFromEOLMode(pdoc->eolMode);
pdoc->InsertString(insertPos + len, endline, strlen(endline));
len += strlen(endline);
}
if (currentPos == insertPos) {
SetEmptySelection(currentPos + len);
}
} else if (pdoc->InsertString(currentPos, text, len)) {
SetEmptySelection(currentPos + len);
}
delete []convertedText;
}
}
void ScintillaWin::Paste() {
if (!::OpenClipboard(MainHWND()))
return;
pdoc->BeginUndoAction();
bool isLine = SelectionEmpty() && (::IsClipboardFormatAvailable(cfLineSelect) != 0);
ClearSelection();
int selStart = SelectionStart();
bool isRectangular = ::IsClipboardFormatAvailable(cfColumnSelect) != 0;
// Always use CF_UNICODETEXT if available
GlobalMemory memUSelection(::GetClipboardData(CF_UNICODETEXT));
if (memUSelection) {
wchar_t *uptr = static_cast<wchar_t *>(memUSelection.ptr);
if (uptr) {
unsigned int len;
char *putf;
// Default Scintilla behaviour in Unicode mode
if (IsUnicodeMode()) {
unsigned int bytes = memUSelection.Size();
len = UTF8Length(uptr, bytes / 2);
putf = new char[len + 1];
if (putf) {
UTF8FromUTF16(uptr, bytes / 2, putf, len);
}
} else {
// CF_UNICODETEXT available, but not in Unicode mode
// Convert from Unicode to current Scintilla code page
UINT cpDest = CodePageFromCharSet(
vs.styles[STYLE_DEFAULT].characterSet, pdoc->dbcsCodePage);
len = ::WideCharToMultiByte(cpDest, 0, uptr, -1,
NULL, 0, NULL, NULL) - 1; // subtract 0 terminator
putf = new char[len + 1];
if (putf) {
::WideCharToMultiByte(cpDest, 0, uptr, -1,
putf, len + 1, NULL, NULL);
}
}
if (putf) {
InsertPasteText(putf, len, selStart, isRectangular, isLine);
delete []putf;
}
}
memUSelection.Unlock();
} else {
// CF_UNICODETEXT not available, paste ANSI text
GlobalMemory memSelection(::GetClipboardData(CF_TEXT));
if (memSelection) {
char *ptr = static_cast<char *>(memSelection.ptr);
if (ptr) {
unsigned int bytes = memSelection.Size();
unsigned int len = bytes;
for (unsigned int i = 0; i < bytes; i++) {
if ((len == bytes) && (0 == ptr[i]))
len = i;
}
// In Unicode mode, convert clipboard text to UTF-8
if (IsUnicodeMode()) {
wchar_t *uptr = new wchar_t[len+1];
unsigned int ulen = ::MultiByteToWideChar(CP_ACP, 0,
ptr, len, uptr, len+1);
unsigned int mlen = UTF8Length(uptr, ulen);
char *putf = new char[mlen + 1];
if (putf) {
// CP_UTF8 not available on Windows 95, so use UTF8FromUTF16()
UTF8FromUTF16(uptr, ulen, putf, mlen);
}
delete []uptr;
if (putf) {
InsertPasteText(putf, mlen, selStart, isRectangular, isLine);
delete []putf;
}
} else {
InsertPasteText(ptr, len, selStart, isRectangular, isLine);
}
}
memSelection.Unlock();
}
}
::CloseClipboard();
pdoc->EndUndoAction();
NotifyChange();
Redraw();
}
void ScintillaWin::CreateCallTipWindow(PRectangle) {
#ifdef TOTAL_CONTROL
if (!ct.wCallTip.Created()) {
ct.wCallTip = ::CreateWindow(callClassName, TEXT("ACallTip"),
WS_POPUP, 100, 100, 150, 20,
MainHWND(), 0,
GetWindowInstance(MainHWND()),
this);
ct.wDraw = ct.wCallTip;
}
#endif
}
void ScintillaWin::AddToPopUp(const char *label, int cmd, bool enabled) {
#ifdef TOTAL_CONTROL
HMENU hmenuPopup = reinterpret_cast<HMENU>(popup.GetID());
if (!label[0])
::AppendMenuA(hmenuPopup, MF_SEPARATOR, 0, "");
else if (enabled)
::AppendMenuA(hmenuPopup, MF_STRING, cmd, label);
else
::AppendMenuA(hmenuPopup, MF_STRING | MF_DISABLED | MF_GRAYED, cmd, label);
#endif
}
void ScintillaWin::ClaimSelection() {
// Windows does not have a primary selection
}
#ifdef SCI_LEXER
/*
Initial Windows-Only implementation of the external lexer
system in ScintillaWin class. Intention is to create a LexerModule
subclass (?) to have lex and fold methods which will call out to their
relevant DLLs...
*/
void ScintillaWin::SetLexer(uptr_t wParam) {
lexLanguage = wParam;
lexCurrent = LexerModule::Find(lexLanguage);
if (!lexCurrent)
lexCurrent = LexerModule::Find(SCLEX_NULL);
}
void ScintillaWin::SetLexerLanguage(const char *languageName) {
lexLanguage = SCLEX_CONTAINER;
lexCurrent = LexerModule::Find(languageName);
if (!lexCurrent)
lexCurrent = LexerModule::Find(SCLEX_NULL);
if (lexCurrent)
lexLanguage = lexCurrent->GetLanguage();
}
#endif
/// Implement IUnknown
STDMETHODIMP_(ULONG)FormatEnumerator_AddRef(FormatEnumerator *fe);
STDMETHODIMP FormatEnumerator_QueryInterface(FormatEnumerator *fe, REFIID riid, PVOID *ppv) {
//Platform::DebugPrintf("EFE QI");
*ppv = NULL;
if (riid == IID_IUnknown)
*ppv = reinterpret_cast<IEnumFORMATETC *>(fe);
if (riid == IID_IEnumFORMATETC)
*ppv = reinterpret_cast<IEnumFORMATETC *>(fe);
if (!*ppv)
return E_NOINTERFACE;
FormatEnumerator_AddRef(fe);
return S_OK;
}
STDMETHODIMP_(ULONG)FormatEnumerator_AddRef(FormatEnumerator *fe) {
return ++fe->ref;
}
STDMETHODIMP_(ULONG)FormatEnumerator_Release(FormatEnumerator *fe) {
fe->ref--;
if (fe->ref > 0)
return fe->ref;
delete fe;
return 0;
}
/// Implement IEnumFORMATETC
STDMETHODIMP FormatEnumerator_Next(FormatEnumerator *fe, ULONG celt, FORMATETC *rgelt, ULONG *pceltFetched) {
//Platform::DebugPrintf("EFE Next %d %d", fe->pos, celt);
if (rgelt == NULL) return E_POINTER;
// We only support one format, so this is simple.
unsigned int putPos = 0;
while ((fe->pos < fe->formatsLen) && (putPos < celt)) {
rgelt->cfFormat = fe->formats[fe->pos];
rgelt->ptd = 0;
rgelt->dwAspect = DVASPECT_CONTENT;
rgelt->lindex = -1;
rgelt->tymed = TYMED_HGLOBAL;
fe->pos++;
putPos++;
}
if (pceltFetched)
*pceltFetched = putPos;
return putPos ? S_OK : S_FALSE;
}
STDMETHODIMP FormatEnumerator_Skip(FormatEnumerator *fe, ULONG celt) {
fe->pos += celt;
return S_OK;
}
STDMETHODIMP FormatEnumerator_Reset(FormatEnumerator *fe) {
fe->pos = 0;
return S_OK;
}
STDMETHODIMP FormatEnumerator_Clone(FormatEnumerator *fe, IEnumFORMATETC **ppenum) {
FormatEnumerator *pfe = new FormatEnumerator(fe->pos, fe->formats, fe->formatsLen);
return FormatEnumerator_QueryInterface(pfe, IID_IEnumFORMATETC,
reinterpret_cast<void **>(ppenum));
}
static void *vtFormatEnumerator[] = {
(void *)(FormatEnumerator_QueryInterface),
(void *)(FormatEnumerator_AddRef),
(void *)(FormatEnumerator_Release),
(void *)(FormatEnumerator_Next),
(void *)(FormatEnumerator_Skip),
(void *)(FormatEnumerator_Reset),
(void *)(FormatEnumerator_Clone)
};
FormatEnumerator::FormatEnumerator(int pos_, CLIPFORMAT formats_[], int formatsLen_) {
vtbl = vtFormatEnumerator;
ref = 0; // First QI adds first reference...
pos = pos_;
formatsLen = formatsLen_;
for (int i=0;i<formatsLen;i++)
formats[i] = formats_[i];
}
/// Implement IUnknown
STDMETHODIMP DropSource_QueryInterface(DropSource *ds, REFIID riid, PVOID *ppv) {
return ds->sci->QueryInterface(riid, ppv);
}
STDMETHODIMP_(ULONG)DropSource_AddRef(DropSource *ds) {
return ds->sci->AddRef();
}
STDMETHODIMP_(ULONG)DropSource_Release(DropSource *ds) {
return ds->sci->Release();
}
/// Implement IDropSource
STDMETHODIMP DropSource_QueryContinueDrag(DropSource *, BOOL fEsc, DWORD grfKeyState) {
if (fEsc)
return DRAGDROP_S_CANCEL;
if (!(grfKeyState & MK_LBUTTON))
return DRAGDROP_S_DROP;
return S_OK;
}
STDMETHODIMP DropSource_GiveFeedback(DropSource *, DWORD) {
return DRAGDROP_S_USEDEFAULTCURSORS;
}
static void *vtDropSource[] = {
(void *)(DropSource_QueryInterface),
(void *)(DropSource_AddRef),
(void *)(DropSource_Release),
(void *)(DropSource_QueryContinueDrag),
(void *)(DropSource_GiveFeedback)
};
DropSource::DropSource() {
vtbl = vtDropSource;
sci = 0;
}
/// Implement IUnkown
STDMETHODIMP DataObject_QueryInterface(DataObject *pd, REFIID riid, PVOID *ppv) {
//Platform::DebugPrintf("DO QI %x\n", pd);
return pd->sci->QueryInterface(riid, ppv);
}
STDMETHODIMP_(ULONG)DataObject_AddRef(DataObject *pd) {
return pd->sci->AddRef();
}
STDMETHODIMP_(ULONG)DataObject_Release(DataObject *pd) {
return pd->sci->Release();
}
/// Implement IDataObject
STDMETHODIMP DataObject_GetData(DataObject *pd, FORMATETC *pFEIn, STGMEDIUM *pSTM) {
return pd->sci->GetData(pFEIn, pSTM);
}
STDMETHODIMP DataObject_GetDataHere(DataObject *, FORMATETC *, STGMEDIUM *) {
//Platform::DebugPrintf("DOB GetDataHere\n");
return E_NOTIMPL;
}
STDMETHODIMP DataObject_QueryGetData(DataObject *pd, FORMATETC *pFE) {
if (pd->sci->DragIsRectangularOK(pFE->cfFormat) &&
pFE->ptd == 0 &&
(pFE->dwAspect & DVASPECT_CONTENT) != 0 &&
pFE->lindex == -1 &&
(pFE->tymed & TYMED_HGLOBAL) != 0
) {
return S_OK;
}
bool formatOK = (pFE->cfFormat == CF_TEXT) ||
((pFE->cfFormat == CF_UNICODETEXT) && pd->sci->IsUnicodeMode());
if (!formatOK ||
pFE->ptd != 0 ||
(pFE->dwAspect & DVASPECT_CONTENT) == 0 ||
pFE->lindex != -1 ||
(pFE->tymed & TYMED_HGLOBAL) == 0
) {
//Platform::DebugPrintf("DOB QueryGetData No %x\n",pFE->cfFormat);
//return DATA_E_FORMATETC;
return S_FALSE;
}
//Platform::DebugPrintf("DOB QueryGetData OK %x\n",pFE->cfFormat);
return S_OK;
}
STDMETHODIMP DataObject_GetCanonicalFormatEtc(DataObject *pd, FORMATETC *, FORMATETC *pFEOut) {
//Platform::DebugPrintf("DOB GetCanon\n");
if (pd->sci->IsUnicodeMode())
pFEOut->cfFormat = CF_UNICODETEXT;
else
pFEOut->cfFormat = CF_TEXT;
pFEOut->ptd = 0;
pFEOut->dwAspect = DVASPECT_CONTENT;
pFEOut->lindex = -1;
pFEOut->tymed = TYMED_HGLOBAL;
return S_OK;
}
STDMETHODIMP DataObject_SetData(DataObject *, FORMATETC *, STGMEDIUM *, BOOL) {
//Platform::DebugPrintf("DOB SetData\n");
return E_FAIL;
}
STDMETHODIMP DataObject_EnumFormatEtc(DataObject *pd, DWORD dwDirection, IEnumFORMATETC **ppEnum) {
//Platform::DebugPrintf("DOB EnumFormatEtc %d\n", dwDirection);
if (dwDirection != DATADIR_GET) {
*ppEnum = 0;
return E_FAIL;
}
FormatEnumerator *pfe;
if (pd->sci->IsUnicodeMode()) {
CLIPFORMAT formats[] = {CF_UNICODETEXT, CF_TEXT};
pfe = new FormatEnumerator(0, formats, 2);
} else {
CLIPFORMAT formats[] = {CF_TEXT};
pfe = new FormatEnumerator(0, formats, 1);
}
return FormatEnumerator_QueryInterface(pfe, IID_IEnumFORMATETC,
reinterpret_cast<void **>(ppEnum));
}
STDMETHODIMP DataObject_DAdvise(DataObject *, FORMATETC *, DWORD, IAdviseSink *, PDWORD) {
//Platform::DebugPrintf("DOB DAdvise\n");
return E_FAIL;
}
STDMETHODIMP DataObject_DUnadvise(DataObject *, DWORD) {
//Platform::DebugPrintf("DOB DUnadvise\n");
return E_FAIL;
}
STDMETHODIMP DataObject_EnumDAdvise(DataObject *, IEnumSTATDATA **) {
//Platform::DebugPrintf("DOB EnumDAdvise\n");
return E_FAIL;
}
static void *vtDataObject[] = {
(void *)(DataObject_QueryInterface),
(void *)(DataObject_AddRef),
(void *)(DataObject_Release),
(void *)(DataObject_GetData),
(void *)(DataObject_GetDataHere),
(void *)(DataObject_QueryGetData),
(void *)(DataObject_GetCanonicalFormatEtc),
(void *)(DataObject_SetData),
(void *)(DataObject_EnumFormatEtc),
(void *)(DataObject_DAdvise),
(void *)(DataObject_DUnadvise),
(void *)(DataObject_EnumDAdvise)
};
DataObject::DataObject() {
vtbl = vtDataObject;
sci = 0;
}
/// Implement IUnknown
STDMETHODIMP DropTarget_QueryInterface(DropTarget *dt, REFIID riid, PVOID *ppv) {
//Platform::DebugPrintf("DT QI %x\n", dt);
return dt->sci->QueryInterface(riid, ppv);
}
STDMETHODIMP_(ULONG)DropTarget_AddRef(DropTarget *dt) {
return dt->sci->AddRef();
}
STDMETHODIMP_(ULONG)DropTarget_Release(DropTarget *dt) {
return dt->sci->Release();
}
/// Implement IDropTarget by forwarding to Scintilla
STDMETHODIMP DropTarget_DragEnter(DropTarget *dt, LPDATAOBJECT pIDataSource, DWORD grfKeyState,
POINTL pt, PDWORD pdwEffect) {
return dt->sci->DragEnter(pIDataSource, grfKeyState, pt, pdwEffect);
}
STDMETHODIMP DropTarget_DragOver(DropTarget *dt, DWORD grfKeyState, POINTL pt, PDWORD pdwEffect) {
return dt->sci->DragOver(grfKeyState, pt, pdwEffect);
}
STDMETHODIMP DropTarget_DragLeave(DropTarget *dt) {
return dt->sci->DragLeave();
}
STDMETHODIMP DropTarget_Drop(DropTarget *dt, LPDATAOBJECT pIDataSource, DWORD grfKeyState,
POINTL pt, PDWORD pdwEffect) {
return dt->sci->Drop(pIDataSource, grfKeyState, pt, pdwEffect);
}
static void *vtDropTarget[] = {
(void *)(DropTarget_QueryInterface),
(void *)(DropTarget_AddRef),
(void *)(DropTarget_Release),
(void *)(DropTarget_DragEnter),
(void *)(DropTarget_DragOver),
(void *)(DropTarget_DragLeave),
(void *)(DropTarget_Drop)
};
DropTarget::DropTarget() {
vtbl = vtDropTarget;
sci = 0;
}
/**
* DBCS: support Input Method Editor (IME).
* Called when IME Window opened.
*/
void ScintillaWin::ImeStartComposition() {
#ifndef __DMC__
// Digital Mars compiler does not include Imm library
if (caret.active) {
// Move IME Window to current caret position
HIMC hIMC = ::ImmGetContext(MainHWND());
Point pos = LocationFromPosition(currentPos);
COMPOSITIONFORM CompForm;
CompForm.dwStyle = CFS_POINT;
CompForm.ptCurrentPos.x = pos.x;
CompForm.ptCurrentPos.y = pos.y;
::ImmSetCompositionWindow(hIMC, &CompForm);
// Set font of IME window to same as surrounded text.
if (stylesValid) {
// Since the style creation code has been made platform independent,
// The logfont for the IME is recreated here.
int styleHere = (pdoc->StyleAt(currentPos)) & 31;
LOGFONTA lf = {0,0,0,0,0,0,0,0,0,0,0,0,0, ""};
int sizeZoomed = vs.styles[styleHere].size + vs.zoomLevel;
if (sizeZoomed <= 2) // Hangs if sizeZoomed <= 1
sizeZoomed = 2;
AutoSurface surface(this);
int deviceHeight = sizeZoomed;
if (surface) {
deviceHeight = (sizeZoomed * surface->LogPixelsY()) / 72;
}
// The negative is to allow for leading
lf.lfHeight = -(abs(deviceHeight));
lf.lfWeight = vs.styles[styleHere].bold ? FW_BOLD : FW_NORMAL;
lf.lfItalic = static_cast<BYTE>(vs.styles[styleHere].italic ? 1 : 0);
lf.lfCharSet = DEFAULT_CHARSET;
lf.lfFaceName[0] = '\0';
if (vs.styles[styleHere].fontName)
strcpy(lf.lfFaceName, vs.styles[styleHere].fontName);
::ImmSetCompositionFontA(hIMC, &lf);
}
::ImmReleaseContext(MainHWND(), hIMC);
// Caret is displayed in IME window. So, caret in Scintilla is useless.
DropCaret();
}
#endif
}
/** Called when IME Window closed. */
void ScintillaWin::ImeEndComposition() {
ShowCaretAtCurrentPosition();
}
void ScintillaWin::AddCharBytes(char b0, char b1) {
int inputCodePage = InputCodePage();
if (inputCodePage && IsUnicodeMode()) {
char utfval[4]="\0\0\0";
char ansiChars[3];
wchar_t wcs[2];
if (b0) { // Two bytes from IME
ansiChars[0] = b0;
ansiChars[1] = b1;
ansiChars[2] = '\0';
::MultiByteToWideChar(inputCodePage, 0, ansiChars, 2, wcs, 1);
} else {
ansiChars[0] = b1;
ansiChars[1] = '\0';
::MultiByteToWideChar(inputCodePage, 0, ansiChars, 1, wcs, 1);
}
unsigned int len = UTF8Length(wcs, 1);
UTF8FromUTF16(wcs, 1, utfval, len);
utfval[len] = '\0';
AddCharUTF(utfval, len ? len : 1);
} else if (b0) {
char dbcsChars[3];
dbcsChars[0] = b0;
dbcsChars[1] = b1;
dbcsChars[2] = '\0';
AddCharUTF(dbcsChars, 2, true);
} else {
AddChar(b1);
}
}
void ScintillaWin::GetIntelliMouseParameters() {
// This retrieves the number of lines per scroll as configured inthe Mouse Properties sheet in Control Panel
::SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0, &linesPerScroll, 0);
}
void ScintillaWin::CopyToClipboard(const SelectionText &selectedText) {
if (!::OpenClipboard(MainHWND()))
return ;
::EmptyClipboard();
GlobalMemory uniText;
// Default Scintilla behaviour in Unicode mode
if (IsUnicodeMode()) {
int uchars = UTF16Length(selectedText.s, selectedText.len);
uniText.Allocate(2 * uchars);
if (uniText) {
UTF16FromUTF8(selectedText.s, selectedText.len, static_cast<wchar_t *>(uniText.ptr), uchars);
}
} else {
// Not Unicode mode
// Convert to Unicode using the current Scintilla code page
UINT cpSrc = CodePageFromCharSet(
selectedText.characterSet, selectedText.codePage);
uniText.Allocate(2 * selectedText.len);
if (uniText) {
::MultiByteToWideChar(cpSrc, 0, selectedText.s, selectedText.len,
static_cast<wchar_t *>(uniText.ptr), selectedText.len);
}
}
if (uniText) {
if (!IsNT()) {
// Copy ANSI text to clipboard on Windows 9x
// Convert from Unicode text, so other ANSI programs can
// paste the text
// Windows NT, 2k, XP automatically generates CF_TEXT
GlobalMemory ansiText;
ansiText.Allocate(selectedText.len);
if (ansiText) {
::WideCharToMultiByte(CP_ACP, 0, static_cast<wchar_t *>(uniText.ptr), -1,
static_cast<char *>(ansiText.ptr), selectedText.len, NULL, NULL);
ansiText.SetClip(CF_TEXT);
}
}
uniText.SetClip(CF_UNICODETEXT);
} else {
// There was a failure - try to copy at least ANSI text
GlobalMemory ansiText;
ansiText.Allocate(selectedText.len);
if (ansiText) {
memcpy(static_cast<char *>(ansiText.ptr), selectedText.s, selectedText.len);
ansiText.SetClip(CF_TEXT);
}
}
if (selectedText.rectangular) {
::SetClipboardData(cfColumnSelect, 0);
}
if (selectedText.lineCopy) {
::SetClipboardData(cfLineSelect, 0);
}
::CloseClipboard();
}
void ScintillaWin::ScrollMessage(WPARAM wParam) {
//DWORD dwStart = timeGetTime();
//Platform::DebugPrintf("Scroll %x %d\n", wParam, lParam);
SCROLLINFO sci;
memset(&sci, 0, sizeof(sci));
sci.cbSize = sizeof(sci);
sci.fMask = SIF_ALL;
GetScrollInfo(SB_VERT, &sci);
//Platform::DebugPrintf("ScrollInfo %d mask=%x min=%d max=%d page=%d pos=%d track=%d\n", b,sci.fMask,
//sci.nMin, sci.nMax, sci.nPage, sci.nPos, sci.nTrackPos);
int topLineNew = topLine;
switch (LoWord(wParam)) {
case SB_LINEUP:
topLineNew -= 1;
break;
case SB_LINEDOWN:
topLineNew += 1;
break;
case SB_PAGEUP:
topLineNew -= LinesToScroll(); break;
case SB_PAGEDOWN: topLineNew += LinesToScroll(); break;
case SB_TOP: topLineNew = 0; break;
case SB_BOTTOM: topLineNew = MaxScrollPos(); break;
case SB_THUMBPOSITION: topLineNew = sci.nTrackPos; break;
case SB_THUMBTRACK: topLineNew = sci.nTrackPos; break;
}
ScrollTo(topLineNew);
}
void ScintillaWin::HorizontalScrollMessage(WPARAM wParam) {
int xPos = xOffset;
PRectangle rcText = GetTextRectangle();
int pageWidth = rcText.Width() * 2 / 3;
switch (LoWord(wParam)) {
case SB_LINEUP:
xPos -= 20;
break;
case SB_LINEDOWN: // May move past the logical end
xPos += 20;
break;
case SB_PAGEUP:
xPos -= pageWidth;
break;
case SB_PAGEDOWN:
xPos += pageWidth;
if (xPos > scrollWidth - rcText.Width()) { // Hit the end exactly
xPos = scrollWidth - rcText.Width();
}
break;
case SB_TOP:
xPos = 0;
break;
case SB_BOTTOM:
xPos = scrollWidth;
break;
case SB_THUMBPOSITION:
case SB_THUMBTRACK: {
// Do NOT use wParam, its 16 bit and not enough for very long lines. Its still possible to overflow the 32 bit but you have to try harder =]
SCROLLINFO si;
si.cbSize = sizeof(si);
si.fMask = SIF_TRACKPOS;
if (GetScrollInfo(SB_HORZ, &si)) {
xPos = si.nTrackPos;
}
}
break;
}
HorizontalScrollTo(xPos);
}
void ScintillaWin::RealizeWindowPalette(bool inBackGround) {
RefreshStyleData();
HDC hdc = ::GetDC(MainHWND());
// Select a stock font to prevent warnings from BoundsChecker
::SelectObject(hdc, GetStockFont(DEFAULT_GUI_FONT));
AutoSurface surfaceWindow(hdc, this);
if (surfaceWindow) {
int changes = surfaceWindow->SetPalette(&palette, inBackGround);
if (changes > 0)
Redraw();
surfaceWindow->Release();
}
::ReleaseDC(MainHWND(), hdc);
}
/**
* Redraw all of text area.
* This paint will not be abandoned.
*/
void ScintillaWin::FullPaint() {
HDC hdc = ::GetDC(MainHWND());
FullPaintDC(hdc);
::ReleaseDC(MainHWND(), hdc);
}
/**
* Redraw all of text area on the specified DC.
* This paint will not be abandoned.
*/
void ScintillaWin::FullPaintDC(HDC hdc) {
paintState = painting;
rcPaint = GetClientRectangle();
paintingAllText = true;
AutoSurface surfaceWindow(hdc, this);
if (surfaceWindow) {
Paint(surfaceWindow, rcPaint);
surfaceWindow->Release();
}
paintState = notPainting;
}
static bool CompareDevCap(HDC hdc, HDC hOtherDC, int nIndex) {
return ::GetDeviceCaps(hdc, nIndex) == ::GetDeviceCaps(hOtherDC, nIndex);
}
bool ScintillaWin::IsCompatibleDC(HDC hOtherDC) {
HDC hdc = ::GetDC(MainHWND());
bool isCompatible =
CompareDevCap(hdc, hOtherDC, TECHNOLOGY) &&
CompareDevCap(hdc, hOtherDC, LOGPIXELSY) &&
CompareDevCap(hdc, hOtherDC, LOGPIXELSX) &&
CompareDevCap(hdc, hOtherDC, BITSPIXEL) &&
CompareDevCap(hdc, hOtherDC, PLANES);
::ReleaseDC(MainHWND(), hdc);
return isCompatible;
}
DWORD ScintillaWin::EffectFromState(DWORD grfKeyState) {
// These are the Wordpad semantics.
DWORD dwEffect;
if (inDragDrop == ddDragging) // Internal defaults to move
dwEffect = DROPEFFECT_MOVE;
else
dwEffect = DROPEFFECT_COPY;
if (grfKeyState & MK_ALT)
dwEffect = DROPEFFECT_MOVE;
if (grfKeyState & MK_CONTROL)
dwEffect = DROPEFFECT_COPY;
return dwEffect;
}
/// Implement IUnknown
STDMETHODIMP ScintillaWin::QueryInterface(REFIID riid, PVOID *ppv) {
*ppv = NULL;
if (riid == IID_IUnknown)
*ppv = reinterpret_cast<IDropTarget *>(&dt);
if (riid == IID_IDropSource)
*ppv = reinterpret_cast<IDropSource *>(&ds);
if (riid == IID_IDropTarget)
*ppv = reinterpret_cast<IDropTarget *>(&dt);
if (riid == IID_IDataObject)
*ppv = reinterpret_cast<IDataObject *>(&dob);
if (!*ppv)
return E_NOINTERFACE;
return S_OK;
}
STDMETHODIMP_(ULONG) ScintillaWin::AddRef() {
return 1;
}
STDMETHODIMP_(ULONG) ScintillaWin::Release() {
return 1;
}
/// Implement IDropTarget
STDMETHODIMP ScintillaWin::DragEnter(LPDATAOBJECT pIDataSource, DWORD grfKeyState,
POINTL, PDWORD pdwEffect) {
if (pIDataSource == NULL)
return E_POINTER;
FORMATETC fmtu = {CF_UNICODETEXT, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
HRESULT hrHasUText = pIDataSource->QueryGetData(&fmtu);
hasOKText = (hrHasUText == S_OK);
if (!hasOKText) {
FORMATETC fmte = {CF_TEXT, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
HRESULT hrHasText = pIDataSource->QueryGetData(&fmte);
hasOKText = (hrHasText == S_OK);
}
if (!hasOKText) {
*pdwEffect = DROPEFFECT_NONE;
return S_OK;
}
*pdwEffect = EffectFromState(grfKeyState);
return S_OK;
}
STDMETHODIMP ScintillaWin::DragOver(DWORD grfKeyState, POINTL pt, PDWORD pdwEffect) {
if (!hasOKText || pdoc->IsReadOnly()) {
*pdwEffect = DROPEFFECT_NONE;
return S_OK;
}
*pdwEffect = EffectFromState(grfKeyState);
// Update the cursor.
POINT rpt = {pt.x, pt.y};
::ScreenToClient(MainHWND(), &rpt);
SetDragPosition(PositionFromLocation(Point(rpt.x, rpt.y)));
return S_OK;
}
STDMETHODIMP ScintillaWin::DragLeave() {
SetDragPosition(invalidPosition);
return S_OK;
}
STDMETHODIMP ScintillaWin::Drop(LPDATAOBJECT pIDataSource, DWORD grfKeyState,
POINTL pt, PDWORD pdwEffect) {
*pdwEffect = EffectFromState(grfKeyState);
if (pIDataSource == NULL)
return E_POINTER;
SetDragPosition(invalidPosition);
STGMEDIUM medium={0,{0},0};
char *data = 0;
bool dataAllocated = false;
FORMATETC fmtu = {CF_UNICODETEXT, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
HRESULT hr = pIDataSource->GetData(&fmtu, &medium);
if (SUCCEEDED(hr) && medium.hGlobal) {
wchar_t *udata = static_cast<wchar_t *>(::GlobalLock(medium.hGlobal));
if (IsUnicodeMode()) {
int tlen = ::GlobalSize(medium.hGlobal);
// Convert UTF-16 to UTF-8
int dataLen = UTF8Length(udata, tlen/2);
data = new char[dataLen+1];
if (data) {
UTF8FromUTF16(udata, tlen/2, data, dataLen);
dataAllocated = true;
}
} else {
// Convert UTF-16 to ANSI
//
// Default Scintilla behavior in Unicode mode
// CF_UNICODETEXT available, but not in Unicode mode
// Convert from Unicode to current Scintilla code page
UINT cpDest = CodePageFromCharSet(
vs.styles[STYLE_DEFAULT].characterSet, pdoc->dbcsCodePage);
int tlen = ::WideCharToMultiByte(cpDest, 0, udata, -1,
NULL, 0, NULL, NULL) - 1; // subtract 0 terminator
data = new char[tlen + 1];
if (data) {
memset(data, 0, (tlen+1));
::WideCharToMultiByte(cpDest, 0, udata, -1,
data, tlen + 1, NULL, NULL);
dataAllocated = true;
}
}
}
if (!data) {
FORMATETC fmte = {CF_TEXT, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
hr = pIDataSource->GetData(&fmte, &medium);
if (SUCCEEDED(hr) && medium.hGlobal) {
data = static_cast<char *>(::GlobalLock(medium.hGlobal));
}
}
if (!data) {
//Platform::DebugPrintf("Bad data format: 0x%x\n", hres);
return hr;
}
FORMATETC fmtr = {cfColumnSelect, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
HRESULT hrRectangular = pIDataSource->QueryGetData(&fmtr);
POINT rpt = {pt.x, pt.y};
::ScreenToClient(MainHWND(), &rpt);
int movePos = PositionFromLocation(Point(rpt.x, rpt.y));
DropAt(movePos, data, *pdwEffect == DROPEFFECT_MOVE, hrRectangular == S_OK);
::GlobalUnlock(medium.hGlobal);
// Free data
if (medium.pUnkForRelease != NULL)
medium.pUnkForRelease->Release();
else
::GlobalFree(medium.hGlobal);
if (dataAllocated)
delete []data;
return S_OK;
}
/// Implement important part of IDataObject
STDMETHODIMP ScintillaWin::GetData(FORMATETC *pFEIn, STGMEDIUM *pSTM) {
bool formatOK = (pFEIn->cfFormat == CF_TEXT) ||
((pFEIn->cfFormat == CF_UNICODETEXT) && IsUnicodeMode());
if (!formatOK ||
pFEIn->ptd != 0 ||
(pFEIn->dwAspect & DVASPECT_CONTENT) == 0 ||
pFEIn->lindex != -1 ||
(pFEIn->tymed & TYMED_HGLOBAL) == 0
) {
//Platform::DebugPrintf("DOB GetData No %d %x %x fmt=%x\n", lenDrag, pFEIn, pSTM, pFEIn->cfFormat);
return DATA_E_FORMATETC;
}
pSTM->tymed = TYMED_HGLOBAL;
//Platform::DebugPrintf("DOB GetData OK %d %x %x\n", lenDrag, pFEIn, pSTM);
GlobalMemory text;
if (pFEIn->cfFormat == CF_UNICODETEXT) {
int uchars = UTF16Length(drag.s, drag.len);
text.Allocate(2 * uchars);
if (text) {
UTF16FromUTF8(drag.s, drag.len, static_cast<wchar_t *>(text.ptr), uchars);
}
} else {
text.Allocate(drag.len);
if (text) {
memcpy(static_cast<char *>(text.ptr), drag.s, drag.len);
}
}
pSTM->hGlobal = text ? text.Unlock() : 0;
pSTM->pUnkForRelease = 0;
return S_OK;
}
bool ScintillaWin::Register(HINSTANCE hInstance_) {
hInstance = hInstance_;
bool result;
// Register the Scintilla class
if (IsNT()) {
// Register Scintilla as a wide character window
WNDCLASSEXW wndclass;
wndclass.cbSize = sizeof(wndclass);
wndclass.style = CS_GLOBALCLASS | CS_HREDRAW | CS_VREDRAW;
wndclass.lpfnWndProc = ::ScintillaWin::SWndProc;
wndclass.cbClsExtra = 0;
wndclass.cbWndExtra = sizeof(ScintillaWin *);
wndclass.hInstance = hInstance;
wndclass.hIcon = NULL;
wndclass.hCursor = NULL;
wndclass.hbrBackground = NULL;
wndclass.lpszMenuName = NULL;
wndclass.lpszClassName = L"Scintilla";
wndclass.hIconSm = 0;
result = ::RegisterClassExW(&wndclass) != 0;
} else {
// Register Scintilla as a normal character window
WNDCLASSEX wndclass;
wndclass.cbSize = sizeof(wndclass);
wndclass.style = CS_GLOBALCLASS | CS_HREDRAW | CS_VREDRAW;
wndclass.lpfnWndProc = ::ScintillaWin::SWndProc;
wndclass.cbClsExtra = 0;
wndclass.cbWndExtra = sizeof(ScintillaWin *);
wndclass.hInstance = hInstance;
wndclass.hIcon = NULL;
wndclass.hCursor = NULL;
wndclass.hbrBackground = NULL;
wndclass.lpszMenuName = NULL;
wndclass.lpszClassName = scintillaClassName;
wndclass.hIconSm = 0;
result = ::RegisterClassEx(&wndclass) != 0;
}
if (result) {
// Register the CallTip class
WNDCLASSEX wndclassc;
wndclassc.cbSize = sizeof(wndclassc);
wndclassc.style = CS_GLOBALCLASS | CS_HREDRAW | CS_VREDRAW;
wndclassc.cbClsExtra = 0;
wndclassc.cbWndExtra = sizeof(ScintillaWin *);
wndclassc.hInstance = hInstance;
wndclassc.hIcon = NULL;
wndclassc.hbrBackground = NULL;
wndclassc.lpszMenuName = NULL;
wndclassc.lpfnWndProc = ScintillaWin::CTWndProc;
wndclassc.hCursor = ::LoadCursor(NULL, IDC_ARROW);
wndclassc.lpszClassName = callClassName;
wndclassc.hIconSm = 0;
result = ::RegisterClassEx(&wndclassc) != 0;
}
return result;
}
bool ScintillaWin::Unregister() {
bool result = ::UnregisterClass(scintillaClassName, hInstance) != 0;
if (::UnregisterClass(callClassName, hInstance) == 0)
result = false;
return result;
}
bool ScintillaWin::HasCaretSizeChanged() {
if (
( (0 != vs.caretWidth) && (sysCaretWidth != vs.caretWidth) )
|| (0 != vs.lineHeight) && (sysCaretHeight != vs.lineHeight)
) {
return true;
}
return false;
}
BOOL ScintillaWin::CreateSystemCaret() {
sysCaretWidth = vs.caretWidth;
if (0 == sysCaretWidth) {
sysCaretWidth = 1;
}
sysCaretHeight = vs.lineHeight;
int bitmapSize = (((sysCaretWidth + 15) & ~15) >> 3) *
sysCaretHeight;
char *bits = new char[bitmapSize];
memset(bits, 0, bitmapSize);
sysCaretBitmap = ::CreateBitmap(sysCaretWidth, sysCaretHeight, 1,
1, reinterpret_cast<BYTE *>(bits));
delete []bits;
BOOL retval = ::CreateCaret(
MainHWND(), sysCaretBitmap,
sysCaretWidth, sysCaretHeight);
::ShowCaret(MainHWND());
return retval;
}
BOOL ScintillaWin::DestroySystemCaret() {
::HideCaret(MainHWND());
BOOL retval = ::DestroyCaret();
if (sysCaretBitmap) {
::DeleteObject(sysCaretBitmap);
sysCaretBitmap = 0;
}
return retval;
}
// Take care of 32/64 bit pointers
#ifdef GetWindowLongPtr
static void *PointerFromWindow(HWND hWnd) {
return reinterpret_cast<void *>(::GetWindowLongPtr(hWnd, 0));
}
static void SetWindowPointer(HWND hWnd, void *ptr) {
::SetWindowLongPtr(hWnd, 0, reinterpret_cast<LONG_PTR>(ptr));
}
#else
static void *PointerFromWindow(HWND hWnd) {
return reinterpret_cast<void *>(::GetWindowLong(hWnd, 0));
}
static void SetWindowPointer(HWND hWnd, void *ptr) {
::SetWindowLong(hWnd, 0, reinterpret_cast<LONG>(ptr));
}
#endif
sptr_t PASCAL ScintillaWin::CTWndProc(
HWND hWnd, UINT iMessage, WPARAM wParam, sptr_t lParam) {
// Find C++ object associated with window.
ScintillaWin *sciThis = reinterpret_cast<ScintillaWin *>(PointerFromWindow(hWnd));
// ctp will be zero if WM_CREATE not seen yet
if (sciThis == 0) {
if (iMessage == WM_CREATE) {
// Associate CallTip object with window
CREATESTRUCT *pCreate = reinterpret_cast<CREATESTRUCT *>(lParam);
SetWindowPointer(hWnd, pCreate->lpCreateParams);
return 0;
} else {
return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
}
} else {
if (iMessage == WM_NCDESTROY) {
::SetWindowLong(hWnd, 0, 0);
return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
} else if (iMessage == WM_PAINT) {
PAINTSTRUCT ps;
::BeginPaint(hWnd, &ps);
Surface *surfaceWindow = Surface::Allocate();
if (surfaceWindow) {
surfaceWindow->Init(ps.hdc, hWnd);
surfaceWindow->SetUnicodeMode(SC_CP_UTF8 == sciThis->ct.codePage);
surfaceWindow->SetDBCSMode(sciThis->ct.codePage);
sciThis->ct.PaintCT(surfaceWindow);
surfaceWindow->Release();
delete surfaceWindow;
}
::EndPaint(hWnd, &ps);
return 0;
} else if ((iMessage == WM_NCLBUTTONDOWN) || (iMessage == WM_NCLBUTTONDBLCLK)) {
POINT pt;
pt.x = static_cast<short>(LOWORD(lParam));
pt.y = static_cast<short>(HIWORD(lParam));
ScreenToClient(hWnd, &pt);
sciThis->ct.MouseClick(Point(pt.x, pt.y));
sciThis->CallTipClick();
return 0;
} else if (iMessage == WM_LBUTTONDOWN) {
// This does not fire due to the hit test code
sciThis->ct.MouseClick(Point::FromLong(lParam));
sciThis->CallTipClick();
return 0;
} else if (iMessage == WM_SETCURSOR) {
::SetCursor(::LoadCursor(NULL,IDC_ARROW));
return 0;
} else if (iMessage == WM_NCHITTEST) {
return HTCAPTION;
} else {
return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
}
}
}
sptr_t ScintillaWin::DirectFunction(
ScintillaWin *sci, UINT iMessage, uptr_t wParam, sptr_t lParam) {
PLATFORM_ASSERT(::GetCurrentThreadId() == ::GetWindowThreadProcessId(sci->MainHWND(), NULL));
return sci->WndProc(iMessage, wParam, lParam);
}
extern "C" __declspec(dllexport) sptr_t __stdcall Scintilla_DirectFunction(
ScintillaWin *sci, UINT iMessage, uptr_t wParam, sptr_t lParam) {
return sci->WndProc(iMessage, wParam, lParam);
}
sptr_t PASCAL ScintillaWin::SWndProc(
HWND hWnd, UINT iMessage, WPARAM wParam, sptr_t lParam) {
//Platform::DebugPrintf("S W:%x M:%x WP:%x L:%x\n", hWnd, iMessage, wParam, lParam);
// Find C++ object associated with window.
ScintillaWin *sci = reinterpret_cast<ScintillaWin *>(PointerFromWindow(hWnd));
// sci will be zero if WM_CREATE not seen yet
if (sci == 0) {
if (iMessage == WM_CREATE) {
// Create C++ object associated with window
sci = new ScintillaWin(hWnd);
SetWindowPointer(hWnd, sci);
return sci->WndProc(iMessage, wParam, lParam);
} else {
return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
}
} else {
if (iMessage == WM_NCDESTROY) {
sci->Finalise();
delete sci;
::SetWindowLong(hWnd, 0, 0);
return ::DefWindowProc(hWnd, iMessage, wParam, lParam);
} else {
return sci->WndProc(iMessage, wParam, lParam);
}
}
}
// This function is externally visible so it can be called from container when building statically.
// Must be called once only.
bool Scintilla_RegisterClasses(void *hInstance) {
Platform_Initialise(hInstance);
bool result = ScintillaWin::Register(reinterpret_cast<HINSTANCE>(hInstance));
#ifdef SCI_LEXER
Scintilla_LinkLexers();
#endif
return result;
}
// This function is externally visible so it can be called from container when building statically.
bool Scintilla_ReleaseResources() {
bool result = ScintillaWin::Unregister();
Platform_Finalise();
return result;
}
#ifndef STATIC_BUILD
extern "C" int APIENTRY DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID) {
//Platform::DebugPrintf("Scintilla::DllMain %d %d\n", hInstance, dwReason);
if (dwReason == DLL_PROCESS_ATTACH) {
if (!Scintilla_RegisterClasses(hInstance))
return FALSE;
} else if (dwReason == DLL_PROCESS_DETACH) {
Scintilla_ReleaseResources();
}
return TRUE;
}
#endif
| [
"[email protected]"
]
| [
[
[
1,
2486
]
]
]
|
2341cf290d2b8bd237e910d8df9af29b7ca91ea3 | 4f89f1c71575c7a5871b2a00de68ebd61f443dac | /src/applications/visual_odometry/VisualOdometryApplication.cpp | d116ada9eee9cbab888adb2321f6ea52a1e13147 | []
| no_license | inayatkh/uniclop | 1386494231276c63eb6cdbe83296cdfd0692a47c | 487a5aa50987f9406b3efb6cdc656d76f15957cb | refs/heads/master | 2021-01-10T09:43:09.416338 | 2009-09-03T16:26:15 | 2009-09-03T16:26:15 | 50,645,836 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 25,309 | cpp |
#include "VisualOdometryApplication.hpp"
#include "devices/video/GstVideoInput.hpp"
#include "vtkConeSource.h"
#include "vtkPolyDataMapper.h"
#include "vtkRenderWindow.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkCamera.h"
#include "vtkActor.h"
#include "vtkRenderer.h"
#include "vtkCommand.h"
#include "vtkBoxWidget.h"
#include "vtkTransform.h"
#include "vtkInteractorStyleTrackballCamera.h"
namespace uniclop
{
int vtk_main(); // forward declaration see bottom of file
string VisualOdometryApplication::get_application_title() const
{
return "Visual odometry. A features based approach. Uniclop 2009";
}
program_options::options_description VisualOdometryApplication::get_command_line_options(void) const
{
program_options::options_description desc;
desc.add(GstVideoInput::get_options_description());
return desc;
}
int VisualOdometryApplication::main_loop(program_options::variables_map &options)
{
printf("VisualOdometryApplication::main_loop says hello world !\n");
return vtk_main();
}
class vtkMyCallback : public vtkCommand
{
public:
static vtkMyCallback *New()
{
return new vtkMyCallback;
}
virtual void Execute(vtkObject *caller, unsigned long, void*)
{
vtkTransform *t = vtkTransform::New();
vtkBoxWidget *widget = reinterpret_cast<vtkBoxWidget*>(caller);
widget->GetTransform(t);
widget->GetProp3D()->SetUserTransform(t);
t->Delete();
}
};
int vtk_main()
{
//
// Next we create an instance of vtkConeSource and set some of its
// properties. The instance of vtkConeSource "cone" is part of a
// visualization pipeline (it is a source process object); it produces data
// (output type is vtkPolyData) which other filters may process.
//
vtkConeSource *cone = vtkConeSource::New();
cone->SetHeight( 3.0 );
cone->SetRadius( 1.0 );
cone->SetResolution( 10 );
//
// In this example we terminate the pipeline with a mapper process object.
// (Intermediate filters such as vtkShrinkPolyData could be inserted in
// between the source and the mapper.) We create an instance of
// vtkPolyDataMapper to map the polygonal data into graphics primitives. We
// connect the output of the cone souece to the input of this mapper.
//
vtkPolyDataMapper *coneMapper = vtkPolyDataMapper::New();
coneMapper->SetInputConnection( cone->GetOutputPort() );
//
// Create an actor to represent the cone. The actor orchestrates rendering
// of the mapper's graphics primitives. An actor also refers to properties
// via a vtkProperty instance, and includes an internal transformation
// matrix. We set this actor's mapper to be coneMapper which we created
// above.
//
vtkActor *coneActor = vtkActor::New();
coneActor->SetMapper( coneMapper );
//
// Create the Renderer and assign actors to it. A renderer is like a
// viewport. It is part or all of a window on the screen and it is
// responsible for drawing the actors it has. We also set the background
// color here.
//
vtkRenderer *ren1= vtkRenderer::New();
ren1->AddActor( coneActor );
ren1->SetBackground( 0.1, 0.2, 0.4 );
//
// Finally we create the render window which will show up on the screen.
// We put our renderer into the render window using AddRenderer. We also
// set the size to be 300 pixels by 300.
//
vtkRenderWindow *renWin = vtkRenderWindow::New();
renWin->AddRenderer( ren1 );
renWin->SetSize( 300, 300 );
//
// The vtkRenderWindowInteractor class watches for events (e.g., keypress,
// mouse) in the vtkRenderWindow. These events are translated into
// event invocations that VTK understands (see VTK/Common/vtkCommand.h
// for all events that VTK processes). Then observers of these VTK
// events can process them as appropriate.
vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New();
iren->SetRenderWindow(renWin);
//
// By default the vtkRenderWindowInteractor instantiates an instance
// of vtkInteractorStyle. vtkInteractorStyle translates a set of events
// it observes into operations on the camera, actors, and/or properties
// in the vtkRenderWindow associated with the vtkRenderWinodwInteractor.
// Here we specify a particular interactor style.
vtkInteractorStyleTrackballCamera *style =
vtkInteractorStyleTrackballCamera::New();
iren->SetInteractorStyle(style);
//
// Here we use a vtkBoxWidget to transform the underlying coneActor (by
// manipulating its transformation matrix). Many other types of widgets
// are available for use, see the documentation for more details.
//
// The SetInteractor method is how 3D widgets are associated with the render
// window interactor. Internally, SetInteractor sets up a bunch of callbacks
// using the Command/Observer mechanism (AddObserver()). The place factor
// controls the initial size of the widget with respect to the bounding box
// of the input to the widget.
vtkBoxWidget *boxWidget = vtkBoxWidget::New();
boxWidget->SetInteractor(iren);
boxWidget->SetPlaceFactor(1.25);
//
// Place the interactor initially. The input to a 3D widget is used to
// initially position and scale the widget. The EndInteractionEvent is
// observed which invokes the SelectPolygons callback.
//
boxWidget->SetProp3D(coneActor);
boxWidget->PlaceWidget();
vtkMyCallback *callback = vtkMyCallback::New();
boxWidget->AddObserver(vtkCommand::InteractionEvent, callback);
//
// Normally the user presses the "i" key to bring a 3D widget to life. Here
// we will manually enable it so it appears with the cone.
//
boxWidget->On();
//
// Start the event loop.
//
iren->Initialize();
iren->Start();
//
// Free up any objects we created. All instances in VTK are deleted by
// using the Delete() method.
//
cone->Delete();
coneMapper->Delete();
coneActor->Delete();
callback->Delete();
boxWidget->Delete();
ren1->Delete();
renWin->Delete();
iren->Delete();
style->Delete();
return 0;
}
}
/*
Implementation of an efficient features matcher based on
FAST features detection and matching by Edward Rosten and Tom Drummond
PROSAC robust estimation by Ondřej Chum and Jiří Matas
*/
/*
// ~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=
// Headers
#define PROGRAM_TITLE "Features matching demonstration. R.Benenson 2007."
// Cimg http://cimg.sf.net
#if defined(_MSC_VER)
#define cimg_imagemagick_path "C:\\ImageMagick-6.3.5-Q16\\convert.exe"
#endif
#include <CImg/CImg.h>
using namespace cimg_library;
// Boost http://boost.org
#include <boost/program_options.hpp>
namespace args = boost::program_options;
#include <boost/scoped_ptr.hpp>
#include <boost/numeric/ublas/io.hpp>
// C++ standard includes
#include <iostream> // cout definition
using namespace std;
#include "images_input.hpp"
#include "features_detection.hpp"
#include "features_matching.hpp"
#include "model_estimation.hpp"
#include "dense_ensemble_estimation.hpp"
// ~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=
// Demonstration application
template<typename F>
int main_loop(args::variables_map &options, IFeaturesDetector<F> &features_detector);
// part of the code needs to be templated...
int main(int argc, char *argv[])
{
// demonstration application search features of a template into a changing image
try
{
cout << endl << PROGRAM_TITLE << endl << endl;
// input arguments --
args::options_description desc("Application options");
desc.add_options()
("help", "produce help message")
("cimg_info", args::value< vector<string> >()->zero_tokens(),
"print some informations about the CImg lbirary and exit")
("features_detection_method", args::value<string>()->default_value("FAST"),
"choose the features detection method: FAST, Harris or SIFT")
("model", args::value<string>()->default_value("homography"),
"choose the model to use: homography or fundamental_matrix")
("estimation_method", args::value<string>()->default_value("none"),
"choose the robust estimation method: none, RANSAC, PROSAC, Ensemble or DenseEnsemble")
("show_features_points", args::value<bool>()->default_value(false),
"show the detected features")
("show_matching_result", args::value<bool>()->default_value(false),
"show the matching result (inliers and outliers matches)")
;
desc.add( ImagesInput<uint8_t>::get_options_description() );
desc.add( SimpleFAST::get_options_description() );
desc.add( SimpleSIFT::get_options_description() );
desc.add( FASTFeaturesMatcher::get_options_description() );
desc.add( SimpleFeaturesMatcher<FASTFeature>::get_options_description() );
desc.add( EnsembleMethod< ScoredMatch<FASTFeature> >::get_options_description() );
desc.add( PROSAC< ScoredMatch<FASTFeature> >::get_options_description() );
desc.add( RANSAC< ScoredMatch<FASTFeature> >::get_options_description() );
args::variables_map options;
args::store(args::parse_command_line(argc, argv, desc), options);
args::notify(options);
if ( options.count("help") )
{
cout << desc << endl;
return 0;
}
if ( options.count("cimg_info") )
{
cimg::info(); // print some information about the environment configuration
return 0;
}
// select the features detection method ---
// the features type will determinate the features type required
// to specialize the rest of the code
string features_detection_method = "none";
if (options.count("features_detection_method"))
features_detection_method = options["features_detection_method"].as<string>();
if (features_detection_method == "FAST")
{
boost::scoped_ptr< IFeaturesDetector<SimpleFAST::features_type> > features_detector_p;
features_detector_p.reset( new SimpleFAST(options) );
return main_loop(options, *features_detector_p);
}
else if (features_detection_method == "Harris")
{
throw runtime_error("Harris features detector not yet implemented");
}
else if (features_detection_method == "SIFT")
{
boost::scoped_ptr< IFeaturesDetector<SimpleSIFT::features_type> > features_detector_p;
features_detector_p.reset( new SimpleSIFT(options) );
return main_loop(options, *features_detector_p);
}
else
{
throw runtime_error("No known features detector selected");
}
} // end of initial 'try'
catch (exception &e)
{
cout << "An exception was raised: " << e.what() << endl;
}
return 0;
}
// ~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=
template<typename FeatureType>
int main_loop(args::variables_map &options, IFeaturesDetector<FeatureType> &features_detector)
{
// part of the code needs to be templated...
// get display options --
bool show_features_points = false;
if ( options.count( "show_features_points" ) )
show_features_points = options["show_features_points"].as<bool>();
bool show_matching_result = false;
if ( options.count( "show_matching_result" ) )
show_matching_result = options["show_matching_result"].as<bool>();
// get template image --
ImagesInput<uint8_t> images_input(options);
const CImg<uint8_t> ¤t_image = images_input.get_new_image();
const CImg<uint8_t> template_image( current_image ); // copy
// obtain features to match with...
const vector<FeatureType> template_features =
features_detector.detect_features(template_image); // copy the results
if (true)
{
cout << "template_features.size() == " << template_features.size() << endl;
}
// create the features matcher, and model estimator objects --
SimpleFeaturesMatcher<FeatureType> simple_features_matcher(options);
string estimation_method;
if (options.count("estimation_method"))
estimation_method = options["estimation_method"].as<string>();
//FundamentalMatrixModel fundamental_matrix_model(options);
typedef ScoredMatch<FeatureType> MatchType;
FundamentalMatrixModel< FeatureType > fundamental_matrix_model;
HomographyModel<FeatureType> homography_model;
IParametricModel< MatchType > *model_p = NULL;
string model_name;
if (options.count("model"))
model_name = options["model"].as<string>();
if (model_name == "homography")
model_p = &homography_model;
else if (model_name == "fundamental_matrix")
model_p = &fundamental_matrix_model;
if (model_p == NULL)
throw runtime_error("No model was specified");
IParametricModel< MatchType > &model = *model_p;
boost::scoped_ptr< IModelEstimator< MatchType > > estimator_p;
if (estimation_method == "RANSAC")
estimator_p.reset( new RANSAC< MatchType >(options, model) );
else if (estimation_method == "PROSAC")
estimator_p.reset( new PROSAC< MatchType >(options, model) );
else if (estimation_method == "Ensemble")
{
EnsembleMethod< MatchType > *t_ensemble_method_p = new EnsembleMethod< MatchType >(options, model);
// Homography and FundamentalMatrix models compute the residuals
// as distances in pixels
const double min_error_value = 0.1; // smaller than a pixel of distance
const double max_error_value = max(current_image.dimx(), current_image.dimy()) / 1; // 2;
t_ensemble_method_p->set_min_max_values(min_error_value, max_error_value);
estimator_p.reset( t_ensemble_method_p ); // the smart pointer is in charge of deallication
}
else if (estimation_method == "DenseEnsemble")
estimator_p.reset( new DenseEnsembleMethod< MatchType >(options, model) );
if ( estimator_p == NULL && estimation_method != "none")
throw runtime_error("No valid estimation method available");
IModelEstimator< MatchType > &estimator = *estimator_p;
// create the output displays --
CImgDisplay video_display(current_image.dimx(), current_image.dimy(), "Video stream");
video_display.show();
video_display.display(current_image);
CImg<uint8_t> matchings_image(current_image.dimx(), 2*current_image.dimy(), 1, 3);
CImgDisplay matching_display(matchings_image.dimx(), matchings_image.dimy(), "Matching results");
matching_display.close();
if (show_matching_result)
{
matching_display.show();
video_display.close(); // not used
}
// video input, main loop --
do
{
// retrieve new image -
CImg<uint8_t> ¤t_image = images_input.get_new_image();
// compute features -
const vector<FeatureType> ¤t_features = features_detector.detect_features(current_image);
// obtain features matches candidates -
vector< MatchType > & matches =
simple_features_matcher.match(template_features, current_features);
sort(matches.begin(), matches.end());
// introsort C++ standard algorithm O(NlogN)
// estimate model parameters -
//const ublas::vector<double> & parameters =
if (&estimator != NULL)
{
{ // DenseEnsembleMethod special code
DenseEnsembleMethod<MatchType> * dense_ensemble_method_estimator_p = NULL;
dense_ensemble_method_estimator_p = dynamic_cast< DenseEnsembleMethod<MatchType> * >(&estimator);
if ( dense_ensemble_method_estimator_p != NULL)
{
float blur_sigma = -1.0f; // negative value indicates no blurring
if (options.count("blur_sigma"))
{
blur_sigma = options["blur_sigma"].as<double>();
cout << "Blurring the images for dense estimation with sigma value "
<< blur_sigma << endl;
}
dense_ensemble_method_estimator_p->set_images_pair(template_image, current_image, blur_sigma);
}
}
// estimate the parameters
const ublas::vector<float> &p = estimator.estimate_model_parameters(matches);
if (false)
{
cout << "estimator.estimate_model_parameters(matches) == " << p << endl;
}
}
// draw results --
if (show_matching_result)
{
// draw the two images --
const int y_offset = current_image.dimy();
{
CImg<uint8_t> t_color_image(template_image.dimx(), template_image.dimy(), 1, 3);
cimg_forXY(template_image, x,y)
{
t_color_image(x,y, 0, 0) = template_image(x,y);
t_color_image(x,y, 0, 1) = template_image(x,y);
t_color_image(x,y, 0, 2) = template_image(x,y);
}
matchings_image.draw_image(t_color_image, 0, 0);
}
{
CImg<uint8_t> t_color_image(current_image.dimx(), current_image.dimy(), 1, 3);
cimg_forXY(current_image, x,y)
{
t_color_image(x,y, 0, 0) = current_image(x,y);
t_color_image(x,y, 0, 1) = current_image(x,y);
t_color_image(x,y, 0, 2) = current_image(x,y);
}
matchings_image.draw_image(t_color_image, 0, y_offset);
}
// draw the matching lines --
//const uint8_t outliers_color = 0; // black lines...
//const uint8_t inliers_color = 255; // white lines...
const uint8_t outliers_color[3] = {255, 155, 0}; // red lines...
const uint8_t inliers_color[3] = {0, 155, 255}; // blue lines...
vector< bool > dummy_is_inlier;
const vector< bool > *is_inlier_p = NULL;
if (&estimator != NULL)
is_inlier_p = &estimator.get_is_inlier();
else
{
dummy_is_inlier.assign(matches.size(), false);
// fill with false values
is_inlier_p = &dummy_is_inlier;
}
const vector< bool > &is_inlier = *is_inlier_p;
vector< bool >::const_iterator is_inlier_it;
// draw inliers and outliers -
// first outliers
typename vector< MatchType >::const_iterator matches_it;
for (matches_it = matches.begin(), is_inlier_it = is_inlier.begin();
matches_it != matches.end() && is_inlier_it != is_inlier.end();
++matches_it, ++is_inlier_it)
{
const int x0 = matches_it->feature_a->x;
const int y0 = matches_it->feature_a->y;
const int x1 = matches_it->feature_b->x;
const int y1 = matches_it->feature_b->y + y_offset;
if (*is_inlier_it)
continue; // skip inliers
else
matchings_image.draw_line(x0, y0, x1, y1, outliers_color);
}
// then inliers
for (matches_it = matches.begin(), is_inlier_it = is_inlier.begin();
matches_it != matches.end() && is_inlier_it != is_inlier.end();
++matches_it, ++is_inlier_it)
{
const int x0 = matches_it->feature_a->x;
const int y0 = matches_it->feature_a->y;
const int x1 = matches_it->feature_b->x;
const int y1 = matches_it->feature_b->y + y_offset;
if (*is_inlier_it)
matchings_image.draw_line(x0, y0, x1, y1, inliers_color);
else
continue; // skip outliers
}
if ( show_features_points )
{ // if required overlap the features points found
typename vector<FeatureType>::const_iterator features_it;
for (features_it = current_features.begin();
features_it != current_features.end();
++features_it)
{
//const uint8_t feature_color = 255; // white dots...
const uint8_t feature_color[3] = {255, 255, 255}; // white dots...
matchings_image.draw_point(features_it->x, features_it->y + y_offset, feature_color);
}
}
// show the result
matching_display.display(matchings_image);
}
else if ( show_features_points )
{
typename vector<FeatureType>::const_iterator features_it;
for (features_it = current_features.begin();
features_it != current_features.end();
++features_it)
{
const uint8_t feature_color = 255; // white dots...
current_image.draw_point(features_it->x, features_it->y, &feature_color);
}
video_display.display(current_image); // show the image with dots !
}
else
{
// nothing special to show
video_display.display(current_image);
}
// estimated models
// inlier and outlier matches
}
while ( (images_input.reached_last_image() == false)
&& (video_display.is_closed == false || matching_display.is_closed == false));
if (estimation_method != "Ensemble")
{
// show the last frame obtained
while ( video_display.is_closed == false || matching_display.is_closed == false )
{
CImgDisplay::wait(video_display, matching_display);
}
}
else
{ // show the last frame AND the kurtosis estimates sources
EnsembleMethod<MatchType> * ensemble_method_estimator_p = NULL;
ensemble_method_estimator_p = dynamic_cast< EnsembleMethod<MatchType> * >(&estimator);
if ( ensemble_method_estimator_p == NULL)
throw runtime_error("Estimation method does not compute histograms");
const vector< HistogramKurtosis<double> > &hk_estimators =
ensemble_method_estimator_p->histogram_kurtosis_estimators;
const vector<double> &kurtosis_values =
ensemble_method_estimator_p->kurtosis_values;
if ( hk_estimators.empty() == false )
{
unsigned int h_index = 0; // index to one of the histograms
int graphs_max_val = 0;
const vector<int> &t_bins = hk_estimators[h_index].get_bins();
graphs_max_val = max(*max_element(t_bins.begin(), t_bins.end()), graphs_max_val);
const float t_kurtosis = static_cast<float>(kurtosis_values[h_index]);
CImgDisplay histograms_display;
HistogramKurtosis<>::display_histogram(t_kurtosis,
t_bins, graphs_max_val, histograms_display);
histograms_display.set_title("Generated histogram");
histograms_display.show();
// show the last frame obtained
while ( video_display.is_closed == false
|| matching_display.is_closed == false
|| histograms_display.is_closed == false )
{
if (histograms_display.button)
{
h_index += 1;
if (h_index == hk_estimators.size() ) h_index = 0;
const vector<int> &t_bins = hk_estimators[h_index].get_bins();
graphs_max_val = max(*max_element(t_bins.begin(), t_bins.end()), graphs_max_val);
const float t_kurtosis = static_cast<float>(kurtosis_values[h_index]);
HistogramKurtosis<>::display_histogram(t_kurtosis,
t_bins, graphs_max_val, histograms_display);
} // end of 'if histograms_display.button'
CImgDisplay::wait(video_display, matching_display, histograms_display);
} // end of 'while windows are open'
}
else
{ // hk_estimators.empty() == true
//throw runtime_error("No histograms to show");
cout << "No histograms to show" << endl;
}
} // end of 'if (estimation_method != "Ensemble") '
return 0;
}
*/
// ~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=
| [
"rodrigo.benenson@gmailcom"
]
| [
[
[
1,
699
]
]
]
|
5a6ec0395e725faf13b63119505f1ab861a6ff12 | 3276915b349aec4d26b466d48d9c8022a909ec16 | /c++/模板/函数模板的使用.cpp | d21c8b31a3fe2594fcaa2ed8474b8f898cd0f3f1 | []
| no_license | flyskyosg/3dvc | c10720b1a7abf9cf4fa1a66ef9fc583d23e54b82 | 0279b1a7ae097b9028cc7e4aa2dcb67025f096b9 | refs/heads/master | 2021-01-10T11:39:45.352471 | 2009-07-31T13:13:50 | 2009-07-31T13:13:50 | 48,670,844 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 974 | cpp | #include<iostream>
#include<string>
using namespace std;
template <class t,class r> //类型参数表可以是两个也可以使多个//
t max(t a,r b )
{
return a>b?a:b;
}
template <class t>
t max(t a,t b, t c) //和参数为2个的函数模板重载//
{
return (a>b?a>c?a:c:b>c?b:c);
}
template <typename T ,int m>
void alloc(T * & n)
{
n=new T [m];
cout<<"分配"<<m<<"个空间成功"<<endl;
}
void max(int a) //一般函数和函数模板重载//
{
cout<<a*a<<endl;
}int main()
{
int a=10,b=20,e=30;
double c=10.23,d=12.32,f=23.21;
char g='a',h='b'; //字符型数据在比较的时候是比较其asc码值//
cout<<max(a,b)<<endl;
cout<<max(c,d)<<endl;
cout<<max(a,b,e)<<endl;
cout<<max(c,d,f)<<endl;
cout<<max(g,h)<<endl;
max(a);
int * n;
alloc<int,10>(n);
system("pause");
return 0;
}
| [
"[email protected]"
]
| [
[
[
1,
50
]
]
]
|
b2d85aff55efab373b929867e1526c2bc8eb2b3a | ebef60901995677623e5e845c9acb6c8b11bb36e | /core/StateMap.cpp | ce9e5e70ee8d639b565067e62f2cf55cdb540370 | []
| no_license | oliverzheng/EyeOh | 9654a96a8c5e8c4e428767623006590d167db708 | 6c7a4e268fb37f79c75f6c1eb7dfd4b52bc33bf9 | refs/heads/master | 2021-01-01T20:05:19.721229 | 2010-06-03T02:39:48 | 2010-06-03T02:39:48 | 696,316 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,018 | cpp | #include "StateMap.h"
using namespace eyeoh;
using namespace std;
NoOutput::NoOutput()
: logic_error("No output available for this state")
{
}
StateMap::StateMap()
: root(NULL), current(NULL), output(NULL)
{
root = this;
current = this;
}
StateMap & StateMap::operator<<(Key & key)
{
map<Key, StateMap *>::iterator it = this->keys.find(key);
if (it != this->keys.end())
{
return *(it->second);
}
else
{
StateMap * statemap = new StateMap();
this->keys[key] = statemap;
return *statemap;
}
}
StateMap & StateMap::operator<<(IOutput & output)
{
this->current->output = &output;
return *(this->current);
}
bool StateMap::HasOutput() const
{
return this->current->output != NULL;
}
IOutput & StateMap::GetOutput() const
{
if (this->current->output != NULL)
return *(this->current->output);
else
throw NoOutput();
}
bool StateMap::IsEnd() const
{
return this->current->keys.empty();
}
StateMap & StateMap::operator[](Key & key) const
{
map<Key, StateMap *>::const_iterator it = this->keys.find(key);
if (it != this->keys.end())
return *(it->second);
else
throw NoSuchKey();
}
pair<StateMap::ChangeResult, StateMap::OutputResult> StateMap::OnPress(Key & key)
{
pair<StateMap::ChangeResult, StateMap::OutputResult> result;
map<Key, StateMap *>::iterator it = this->current->keys.find(key);
if (it != this->current->keys.end())
{
this->current = it->second;
if (this->HasOutput())
{
result.second = StateMap::OUTPUT;
this->GetOutput().Do();
}
else
{
result.second = StateMap::NO_OUTPUT;
}
if (this->current->keys.empty())
{
this->current = this->root;
result.first = StateMap::RESET;
}
else
{
result.first = StateMap::CHANGED;
}
}
else
{
this->current = this->root;
result.first = StateMap::RESET;
result.second = StateMap::NO_OUTPUT;
}
return result;
}
void StateMap::Reset()
{
this->current = this->root;
} | [
"[email protected]"
]
| [
[
[
1,
108
]
]
]
|
1f820296ca7f6b88564aaafbea4d013f97b0a828 | 9fb229975cc6bd01eb38c3e96849d0c36985fa1e | /src/Lib2D/UnicodeFont.cpp | 1451c336d68801961cf656c291342df74d066609 | []
| no_license | Danewalker/ahr | 3758bf3219f407ed813c2bbed5d1d86291b9237d | 2af9fd5a866c98ef1f95f4d1c3d9b192fee785a6 | refs/heads/master | 2016-09-13T08:03:43.040624 | 2010-07-21T15:44:41 | 2010-07-21T15:44:41 | 56,323,321 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 15,852 | cpp | /******************************************************************************
@Author: Nguyen Trung Hung
@Email: [email protected]
@Date create: 2006-10-20
@Modified by: Radoslav Daskalov
@Date modify:
@Description: This class is created to make the using of new bitmap font easier
@
@
@ NOTE : The original class is for java, this is a C++ version
@
******************************************************************************/
#include "GenDef.h"
#include "UnicodeFont.h"
#include "HG/HighGear.h"
CUnicodeFont::CUnicodeFont() :
_BITS_SYSTEM_(1),
_BIT_SHIFT_(0),
_BIT_AND_(0),
_BIT_CHECK_(0),
_SCALE_(0),
m_fontHeight(0),
m_frontColor(0),
m_borderColor(0),
m_currentColor(0),
lineSpacing(DEFAULT_LINE_SPACING),
charSpacing(0),
globalAlpha(0xF)
{
}
CUnicodeFont::CUnicodeFont(const char* strPackageName) :
_BITS_SYSTEM_(1),
_BIT_SHIFT_(0),
_BIT_AND_(0),
_BIT_CHECK_(0),
_SCALE_(0),
m_fontHeight(0),
m_frontColor(0),
m_borderColor(0),
m_currentColor(0),
lineSpacing(DEFAULT_LINE_SPACING),
charSpacing(0),
globalAlpha(0xF)
{
LoadFont(strPackageName);
}
short CUnicodeFont::clipX = -1;
short CUnicodeFont::clipY = -1;
short CUnicodeFont::clipWidth = -1;
short CUnicodeFont::clipHeight = -1;
bool CUnicodeFont::m_bDontUseUnicodeFont = false;
CUnicodeFont::~CUnicodeFont()
{
if (m_sCharEnum)
{
DELETE_ARRAY m_sCharEnum;
}
if (m_fontCharWidth)
{
DELETE_ARRAY m_fontCharWidth;
}
if (m_sCharImageData)
{
DELETE_ARRAY m_sCharImageData;
}
if (m_fontPackageData)
{
for (int i = 0; i < m_fontCharCount; i++)
{
DELETE_ARRAY m_fontPackageData[i];
}
DELETE_ARRAY m_fontPackageData;
}
if (m_colorGradients)
{
for (int i = 0; i < NUMBER_COLORS; i++)
{
DELETE_ARRAY m_colorGradients[i];
}
DELETE_ARRAY m_colorGradients;
}
if (m_colorBorders)
{
DELETE_ARRAY m_colorBorders;
}
}
bool CUnicodeFont::LoadFont(const char* strPackageName)
{
A_IFile* inputFile = A_IFile::Open(strPackageName, A_IFile::OPEN_BINARY | A_IFile::OPEN_READ, false);
A_ASSERT(inputFile);
if (inputFile)
{
char readChar;
short readShort;
//get num of character
inputFile->Read(&readShort, sizeof(readShort));
m_fontCharCount = readShort;
//allocate mem
m_sCharEnum = NEW unsigned short [m_fontCharCount];
m_fontCharWidth = NEW char [m_fontCharCount];
m_fontPackageData = NEW char* [m_fontCharCount];
//get height of font
inputFile->Read(&readChar, sizeof(readChar));
m_fontHeight = readChar;
//allocate mem for decoded data buffer
m_sCharImageData = NEW unsigned short[m_fontHeight*m_fontHeight*2];
//get bits system
inputFile->Read(&readChar, sizeof(readChar));
_BITS_SYSTEM_ = readChar;
_BIT_SHIFT_ = 4 - _BITS_SYSTEM_;
if (_BITS_SYSTEM_ == 1)
{
_BIT_AND_ = 0x07;
_BIT_CHECK_ = 0x01;
_SCALE_ = 0;
}
else
{
_BIT_AND_ = 0x03;
_BIT_CHECK_ = 0x03;
_SCALE_ = 1;
}
//get data of each character
int dataSize;
for (int i=0 ; i < m_fontCharCount ; i++)
{
//Read Unicode of character
inputFile->Read(&readShort, sizeof(readShort));
m_sCharEnum[i] = readShort;
//Read width of character in this font
inputFile->Read(&readChar, sizeof(readChar));
m_fontCharWidth[i] = readChar;
//Read font data of character
dataSize = 1 + ((m_fontCharWidth[i]*m_fontHeight)>>_BIT_SHIFT_);
m_fontPackageData[i] = NEW char[dataSize];
inputFile->Read(m_fontPackageData[i], dataSize);
}
}
A_IFile::Close(inputFile);
CreateColorTable();
SetColor(CUnicodeFont::CLR_DEFAULT);
ResetCharSpacing();
return true;
}
void CUnicodeFont::SetColor(unsigned short sNewColor, unsigned short sNewBorderColor)
{
m_currentColor = -1;
m_frontColor = sNewColor;
m_borderColor = sNewBorderColor;
}
void CUnicodeFont::SetColor(Color bitmapColor)
{
m_currentColor = bitmapColor;
}
int CUnicodeFont::DrawChar(CLib2D& lib2d, unsigned short in_sChar, int x, int y)
{
if ((in_sChar>>8) == FAKE_ZERO)
{
in_sChar = in_sChar & 0x00FF;
}
if ((in_sChar&0xFF) == FAKE_ZERO_CHINESE)
{
in_sChar = in_sChar & 0xFF00;
}
int int_lCharIndex = MapChar(in_sChar);
if (int_lCharIndex == -1)
{
//TRACE2("%d char not found", in_sChar);
return 0;
}
int int_lCharWidth = m_fontCharWidth[int_lCharIndex];
int srcStartX = 0;
int srcStartY = 0;
int srcWidth = int_lCharWidth;
int srcHeight = m_fontHeight;
int destWidth = lib2d.GetDestWidth();
int destHeight = lib2d.GetDestHeight();
if(CUnicodeFont::clipX == -1)
{
CUnicodeFont::clipX = 0;
CUnicodeFont::clipY = 0;
CUnicodeFont::clipWidth = destWidth;
CUnicodeFont::clipHeight= destHeight;
}
int clipStartX = CUnicodeFont::clipX, clipEndX = CUnicodeFont::clipX + CUnicodeFont::clipWidth;
int clipStartY = CUnicodeFont::clipY, clipEndY = CUnicodeFont::clipY + CUnicodeFont::clipHeight;
if(x < clipStartX)
{
int clipped = (clipStartX - x);
srcWidth -= clipped;
srcStartX += clipped;
x = clipStartX;
}
if(y < clipStartY)
{
int clipped = (clipStartY - y);
srcHeight -= clipped;
srcStartY += clipped;
y = clipStartY;
}
if(x + srcWidth > clipEndX)
{
int clipped = ((x + srcWidth) - clipEndX);
srcWidth -= clipped;
}
if(y + srcHeight > clipEndY)
{
int clipped = ((y + srcHeight) - clipEndY);
srcHeight -= clipped;
}
// Completely outside of the screen
if((srcWidth <= 0) || (srcHeight <= 0))
return int_lCharWidth;
//////////////////////////////////////////////////////////////////////////////////////////
DecodeFont(int_lCharIndex, m_sCharImageData);
unsigned short * pScreen = (unsigned short *) lib2d.GetDestPtr();
unsigned short * pImage = m_sCharImageData;
pScreen += y * destWidth + x;
pImage += srcStartY * int_lCharWidth + srcStartX;
for (int i = 0; i < srcHeight; i++)
{
for (int j = 0; j < srcWidth; j++)
{
if (pImage[j] != kUnicodeFontTransparentColor)
{
pScreen[j] = CLib2D::MixColor(pImage[j], pScreen[j], globalAlpha);
}
}
pScreen += destWidth;
pImage += int_lCharWidth;
}
return int_lCharWidth;
}
int CUnicodeFont::GetFontHeight()
{
return m_fontHeight;
}
int CUnicodeFont::GetFontCharWidth(unsigned short in_sChar)
{
if ((in_sChar>>8) == FAKE_ZERO)
{
in_sChar = in_sChar & 0xFF;
}
if ((in_sChar&0xFF) == FAKE_ZERO_CHINESE)
{
in_sChar = in_sChar & 0xFF00;
}
int int_lCharIndex = MapChar(in_sChar);
if(in_sChar == SPACE_CHAR)
{
return SPACE_WIDTH;
}
if (int_lCharIndex == -1)
{
return 0;
}
return m_fontCharWidth[int_lCharIndex];
}
int CUnicodeFont::GetStringWidth(const unsigned short* in_cStr)
{
if (*in_cStr)
{
MeasureString(in_cStr);
return m_lastStringWidth;
}
return 0;
}
int CUnicodeFont::GetStringHeight(const unsigned short* in_cStr)
{
if (*in_cStr)
{
MeasureString(in_cStr);
return m_lastStringHeight;
}
return 0;
}
void CUnicodeFont::MeasureString(const unsigned short* in_sStr, const unsigned short* in_lastChar)
{
int w = 0, lines = 1;
m_lastStringWidth = 0;
const unsigned short* s = in_sStr;
unsigned short c = NEW_LINE_CHAR;
while ((s != in_lastChar) && (*s) & 0xFF00 && (*s) & 0x00FF)
{
if ( *s == SPACE_CHAR)
{
w += (SPACE_WIDTH + charSpacing);
}
else if (*s == NEW_LINE_CHAR)
{
m_lastStringWidth = max(m_lastStringWidth, w);
w = 0;
lines++;
}
else
{
w += GetFontCharWidth(*s) + charSpacing;
}
s++;
}
m_lastStringWidth = max(m_lastStringWidth, w) - charSpacing;
m_lastStringHeight = lines * GetFontHeight() + (lines - 1) * lineSpacing;
}
#undef MAX_STRING_LENGTH
#define MAX_STRING_LENGTH 512
// Returns the number of lines
int CUnicodeFont::FormatStringWithLimitedWidth(const unsigned short* s, unsigned short* buf, int maxWidth, bool ignoreNewLines)
{
int nLines = 1;
int charLength = GetStringLength(s);
A_ASSERT(charLength < MAX_STRING_LENGTH);
memcpy(buf, s, (charLength + 1) * sizeof(unsigned short));
const int wordSpacing = SPACE_WIDTH + charSpacing;
int lineWidth = -wordSpacing;
for (int i = 0, j = -1; i <= charLength; i++)
{
if (buf[i] == SPACE_CHAR || buf[i] == 0 || buf[i] == NEW_LINE_CHAR)
{
MeasureString(buf + j + 1, buf + i);
lineWidth += m_lastStringWidth + charSpacing + wordSpacing;
if (lineWidth > maxWidth)
{
if(j!=-1)
{
buf[j] = NEW_LINE_CHAR;
++nLines;
}
lineWidth = m_lastStringWidth + charSpacing;
}
if (buf[i] == NEW_LINE_CHAR)
{
if (ignoreNewLines)
{
//i>0 is computed before the buf[i-1] part
if (i > 0 && buf[i-1] == SPACE_CHAR)
{
//Deletes the new line(s)
while (buf[i] == NEW_LINE_CHAR)
{
for (int idxMove = i; idxMove < charLength; idxMove++)
{
buf[idxMove] = buf[idxMove+1];
}
charLength--;
}
}
else
{
buf[i] = SPACE_CHAR;
}
}
else
{
lineWidth = -wordSpacing;
++nLines;
}
}
j = i;
}
}
return nLines;
}
int CUnicodeFont::GetStringWidthLimited(const unsigned short* s, int maxWidth, bool ignoreNewLines)
{
unsigned short buf[MAX_STRING_LENGTH];
FormatStringWithLimitedWidth(s, buf, maxWidth, ignoreNewLines);
return GetStringWidth(buf);
}
int CUnicodeFont::GetStringHeightLimited(const unsigned short* s, int maxWidth, bool ignoreNewLines)
{
unsigned short buf[MAX_STRING_LENGTH];
FormatStringWithLimitedWidth(s, buf, maxWidth, ignoreNewLines);
return GetStringHeight(buf);
}
int CUnicodeFont::GetStringLength(const unsigned short * in_cStr)
{
int len = 0;
while (*in_cStr++)
len++;
return len;
}
int CUnicodeFont::MapChar(unsigned short in_sChar)
{
int char_lLeft = 0;
int char_lRight = m_fontCharCount-1;
int char_lMid = 0;
while (char_lLeft <= char_lRight)
{
char_lMid = (char_lLeft + char_lRight)>>1;
if (m_sCharEnum[char_lMid] == in_sChar)
{
return char_lMid;
}
else if (m_sCharEnum[char_lMid] < in_sChar)
{
char_lLeft = char_lMid+1;
}
else
{
char_lRight = char_lMid-1;
}
}
return -1;
}
void CUnicodeFont::DecodeFont(int in_charID, unsigned short* out_sPixelData)
{
int size = m_fontHeight * m_fontCharWidth[in_charID];
int pack_byte_index = 0;
int bit_index = 0;
A_ASSERT(out_sPixelData);
const unsigned short * color = (m_currentColor != -1) ? m_colorGradients[m_currentColor] : &m_frontColor;
const unsigned short * border = (m_currentColor != -1) ? m_colorBorders + m_currentColor : &m_borderColor;
for (int i = 0, j = 0; i < size; i++, j++)
{
if (m_currentColor != -1 && j == m_fontCharWidth[in_charID])
{
j = 0;
color++;
}
pack_byte_index = i>>_BIT_SHIFT_;
bit_index = ((i&_BIT_AND_)<<_SCALE_);
if (((m_fontPackageData[in_charID][pack_byte_index]>>bit_index)&_BIT_CHECK_) == 1)
{
out_sPixelData[i] = *color;
}
else if (((m_fontPackageData[in_charID][pack_byte_index]>>bit_index)&_BIT_CHECK_) == 2)
{
out_sPixelData[i] = *border;
}
else
{
out_sPixelData[i] = kUnicodeFontTransparentColor;
}
}
}
void CUnicodeFont::DrawString(CLib2D& lib2d, const unsigned short* in_sStr, int x, int y, Align align)
{
const unsigned short * stringStart = in_sStr;
const unsigned short * stringEnd = in_sStr;
int yy = y;
int lineCount = 1;
while (*stringStart != 0)
{
if (*stringStart == NEW_LINE_CHAR)
lineCount++;
stringStart++;
}
if(align & VALIGN_CENTER)
yy -= (lineCount - 1) * (GetFontHeight() + lineSpacing) / 2;
else if(align & VALIGN_BOTTOM)
yy -= (lineCount - 1) * (GetFontHeight() + lineSpacing);
stringStart = in_sStr;
while (*stringStart != 0)
{
while(*stringEnd && *stringEnd != NEW_LINE_CHAR)
stringEnd++;
DrawString(lib2d, stringStart, stringEnd, x, yy, align);
yy += GetFontHeight() + lineSpacing;
if (*stringEnd == 0)
break;
stringEnd++;
stringStart = stringEnd;
}
}
void CUnicodeFont::DrawString(CLib2D& lib2d, const unsigned short* in_sStr, const unsigned short* in_sStrEnd, int x, int y, Align align)
{
MeasureString(in_sStr, in_sStrEnd);
int text_w = m_lastStringWidth;
int text_h = m_lastStringHeight;
// compute new x coordinate.
if ((align & HALIGN_RIGHT) != 0) { x -= text_w - 1; }
else if ((align & HALIGN_CENTER) != 0) { x -= text_w >> 1; }
// compute new y coordinate.
if ((align & VALIGN_BOTTOM) != 0) { y -= text_h; }
else if ((align & VALIGN_CENTER) != 0) { y -= text_h >> 1;}
int x_offset = 0;
// draw string
const unsigned short* s = in_sStr;
while ((s != in_sStrEnd) && (*s) & 0xFF00 && (*s) & 0x00FF)
{
if (*s == SPACE_CHAR)
{
x_offset += (SPACE_WIDTH + charSpacing);
}
else if (*s == NEW_LINE_CHAR)
{
y += (lineSpacing + m_fontHeight);
x_offset = 0;
}
else
{
x_offset += DrawChar(lib2d, *s, x + x_offset, y) + charSpacing;
}
s++;
}
}
int CUnicodeFont::DrawStringWithLimitedWidth(CLib2D& lib2d, const unsigned short* in_sStr, int x, int y, int maxWidth, bool ignoreNewLines, Align align)
{
unsigned short buf[MAX_STRING_LENGTH];
int nLines = FormatStringWithLimitedWidth(in_sStr, buf, maxWidth, ignoreNewLines);
DrawString(lib2d, buf, x, y, align);
return nLines;
}
void CUnicodeFont::CreateColorTable()
{
m_colorGradients = NEW unsigned short * [NUMBER_COLORS];
m_colorBorders = NEW unsigned short [NUMBER_COLORS];
for (int i = 0; i < NUMBER_COLORS; i++)
{
m_colorGradients[i] = NEW unsigned short [m_fontHeight];
}
InitColorWithGradient(CLR_WHITE, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0x000000);
InitColorWithGradient(CLR_PINK, 0xFFDBFF, 0xFFCBFF, 0xFFB2FF, 0x8C188C);
InitColorWithGradient(CLR_BLACK, 0x000000, 0x000000, 0x000000, 0x000000);
InitColorWithGradient(CLR_DARK_GRAY, 0x444444, 0x444444, 0x444444, 0x000000);
InitColorWithGradient(CLR_GRAY, 0x888888, 0x888888, 0x888888, 0x303030);
InitColorWithGradient(CLR_GREEN, 0xBBFFBB, 0x99FF99, 0x88FF88, 0x005500);
InitColorWithGradient(CLR_LIGHT_GRAY, 0xCCCCCC, 0xCCCCCC, 0xCCCCCC, 0x303030);
InitColorWithGradient(CLR_RED, 0xFF0000, 0xFF0000, 0xFF0000, 0x000000);
InitColorWithGradient(CLR_GOLDEN, 0xFFFFFF, 0xFFBA31, 0xFFC321, 0x000000);
InitColorWithGradient(CLR_AQUA, 0xFFFFFF, 0xFFFFFF, 0xA5FFFF, 0x4292D6);
}
void CUnicodeFont::InitColorWithGradient(int idx, int c1, int c2, int c3, int borderColor)
{
m_colorBorders[idx] = RGB888TO565(borderColor);
int r1 = ( c1 & 0xFF0000 ) >> 8;
int g1 = ( c1 & 0x00FF00 ) >> 0;
int b1 = ( c1 & 0x0000FF ) << 8;
int r2 = ( c2 & 0xFF0000 ) >> 8;
int g2 = ( c2 & 0x00FF00 ) >> 0;
int b2 = ( c2 & 0x0000FF ) << 8;
int r3 = ( c3 & 0xFF0000 ) >> 8;
int g3 = ( c3 & 0x00FF00 ) >> 0;
int b3 = ( c3 & 0x0000FF ) << 8;
int dr1 = ( r2 - r1 ) * 2 / m_fontHeight;
int dg1 = ( g2 - g1 ) * 2 / m_fontHeight;
int db1 = ( b2 - b1 ) * 2 / m_fontHeight;
int dr2 = ( r3 - r2 ) * 2 / m_fontHeight;
int dg2 = ( g3 - g2 ) * 2 / m_fontHeight;
int db2 = ( b3 - b2 ) * 2 / m_fontHeight;
int cr = r1;
int cg = g1;
int cb = b1;
int i = 0;
for( ; i < (m_fontHeight >> 1); i++)
{
m_colorGradients[idx][i] = ((cr >> 0) & 0xF800) | ((cg >> 5) & 0x07E0) | ((cb >> 11) & 0x001F);
cr += dr1;
cg += dg1;
cb += db1;
}
for( ; i < m_fontHeight; i++)
{
m_colorGradients[idx][i] = ((cr >> 0) & 0xF800) | ((cg >> 5) & 0x07E0) | ((cb >> 11) & 0x001F);
cr += dr2;
cg += dg2;
cb += db2;
}
}
| [
"jakesoul@c957e3ca-5ece-11de-8832-3f4c773c73ae"
]
| [
[
[
1,
666
]
]
]
|
80fcf6e30ad59a767f8fdf2b1470adf7dcbd1e3a | 4c6237dccf0d88085e1477c2678509cd75919fa0 | /src/raytracer/intersection_info.cxx | 5df1069fc9b9ef2090d39e5e15604f71f449998b | [
"BSD-3-Clause"
]
| permissive | tomka/copo-tracer | 7ebd4670067bf404b19990bcd83db55384e7b87a | 7a272acbf19acef9eea8330e503ad95e371bd9b3 | refs/heads/master | 2021-01-10T19:43:35.757275 | 2010-10-04T15:35:33 | 2010-10-04T15:35:33 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,289 | cxx | // Copyright: The original source code was provided by Sören König (Soeren.Koenig
// AT tu-dresden.de). You are free to modify and/or redistribute that code in
// terms of the BSD license.
#include "intersection_info.h"
#include <limits>
void intersection_info::set_lambda(float l)
{
lambda = l;
}
float intersection_info::get_lambda() const
{
return lambda;
}
void intersection_info::set_incoming_ray(const ray<float>& r)
{
incoming_ray = r;
}
ray<float> intersection_info::get_incoming_ray() const
{
return incoming_ray;
}
primitive* intersection_info::get_object() const
{
return object;
}
void intersection_info::set_object(primitive* obj)
{
object=obj;
}
tiny_vec<float,3> intersection_info::get_light_dir() const
{
return light_dir;
}
void intersection_info::set_light_dir(const tiny_vec<float,3>& l)
{
light_dir=l;
}
float intersection_info::get_light_distance()const
{
return light_distance;
}
void intersection_info::set_light_distance(float dist)
{
light_distance=dist;
}
tiny_vec<float,3> intersection_info::get_normal() const
{
return normal;
}
void intersection_info::set_normal(const tiny_vec<float,3>& nml)
{
normal=nml;
}
tiny_vec<float,3> intersection_info::get_location() const
{
return incoming_ray.eval_at(lambda);
}
tiny_vec<float,3> intersection_info::get_reflected_dir() const
{
tiny_vec<float,3> V = incoming_ray.get_direction();
float cosI = dot(normal, V);
return V - 2.0f * cosI*normal;
}
tiny_vec<float,3> intersection_info::get_refracted_dir(float n1, float n2,bool &total_reflection) const
{
tiny_vec<float,3> V = incoming_ray.get_direction();
float n = n1 / n2;
float cosI = dot(normal, V);
float sinT2 = n * n * (1.0f - cosI * cosI);
if (sinT2 > 1.0f)//total reflection
{
total_reflection = true;
return V - 2.0f * cosI*normal;//return reflected ray
}
else
{
total_reflection = false;
return n * V - (n + sqrt(1.0f - sinT2)) * normal;//return refracted ray
}
}
intersection_info::intersection_info():object(NULL),lambda(std::numeric_limits<float>::infinity())
{
}
intersection_info::intersection_info(const ray<float>& r, float l) : incoming_ray(r),lambda(l),object(NULL)
{
}
| [
"[email protected]"
]
| [
[
[
1,
109
]
]
]
|
b98d4dcf7d69c4e44650b3b8aa3dac5826541a70 | d39595c0c12a46ece1b1b41c92a9adcf7fe277ee | /Camera.cpp | d656097c0bbcfe199b05e798783bb7f47e4853f1 | []
| no_license | pandabear41/Breakout | e89b85708b960e7dd83c22df1552141b1c937af9 | 64967248274055117b3cf709c084818039ec8278 | refs/heads/master | 2021-01-17T05:55:34.279752 | 2011-07-15T05:08:02 | 2011-07-15T05:08:02 | 2,039,821 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,166 | cpp | #include "Camera.h"
using namespace std;
Camera Camera::cameraControl;
Camera::Camera() {
x = y = 0;
targetX = targetY = NULL;
targetMode = TARGET_MODE_NORMAL;
}
//==============================================================================
void Camera::onMove(int moveX, int moveY) {
x += moveX;
y += moveY;
}
//==============================================================================
int Camera::getX() {
if(targetX != NULL) {
if(targetMode == TARGET_MODE_CENTER) {
return *targetX - (320 / 2);
}
return *targetX;
}
return x;
}
//------------------------------------------------------------------------------
int Camera::getY() {
if(targetY != NULL) {
if(targetMode == TARGET_MODE_CENTER) {
return *targetY - (320 / 2);
}
return *targetY;
}
return y;
}
//==============================================================================
void Camera::setPos(int x, int y) {
this->x = x;
this->y = y;
}
//------------------------------------------------------------------------------
void Camera::setTarget(float* x, float* y) {
targetX = x;
targetY = y;
}
| [
"[email protected]"
]
| [
[
[
1,
57
]
]
]
|
57d11284a638008f0e2a212effa431eb945e88c9 | f13f46fbe8535a7573d0f399449c230a35cd2014 | /JelloMan/FluidsCharacterActor.h | 46f2309fca87b07b903135a29b26af41c507e3eb | []
| no_license | fangsunjian/jello-man | 354f1c86edc2af55045d8d2bcb58d9cf9b26c68a | 148170a4834a77a9e1549ad3bb746cb03470df8f | refs/heads/master | 2020-12-24T16:42:11.511756 | 2011-06-14T10:16:51 | 2011-06-14T10:16:51 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,672 | h | #pragma once
#include "Actor.h"
#include "ISerializable.h"
#include "ITriggerable.h"
#include "ICharacter.h"
#include "FollowCamera.h"
class Level;
struct Vector3;
class PhysX;
class Fluid;
class NxFluidEmitter;
struct UserData;
class FluidsCharacterActor : public Actor, public ICharacter, public ITriggerable
{
public:
/* CONSTRUCTOR - DESTRUCTOR */
FluidsCharacterActor(Level* pLevel);
virtual ~FluidsCharacterActor();
/* GENERAL */
void Init(ID3D10Device* pDXDevice, PhysX* pPhysXEngine,
Graphics::Camera::FollowCamera* pCamera,
Vector3 startPos);
void RotateMoveDirection(float rad);
void RotateGravityDirection(float rad);
void ChangeMoveSpeed(float speed);
/* ICharacter */
virtual bool IsDead() const { return m_IsDead; }
virtual void Respawn(const SpawnPoint* pSpawnPoint);
virtual void Tick(float dTime);
virtual void Draw(const RenderContext* pRenderContext);
/* ITriggerable */
virtual void OnTriggerEnter(const ITrigger* pTrigger);
virtual void OnTriggerLeave(const ITrigger* pTrigger);
private:
void CheckIfOnGround();
/* DATAMEMBERS */
PhysX* m_pPhysXEngine;
Level* m_pLevel;
UserData* m_pUserData;
Vector3 m_MoveDir;
Vector3 m_RightDir;
float m_MoveSpeed;
bool m_CanSwitchGravity;
float m_Radius;
float m_GravityRotation;
float m_MoveRotation;
Fluid* m_pFluid;
NxFluidEmitter* m_pEmitter;
bool m_bIsSelected;
Graphics::Camera::FollowCamera* m_pCamera;
bool m_IsTouchingGround;
bool m_IsDead;
UINT m_Score;
float m_ScoreTimer;
};
| [
"bastian.damman@0fb7bab5-1bf9-c5f3-09d9-7611b49293d6"
]
| [
[
[
1,
76
]
]
]
|
ef7d9280566faf8fc7fceabc80ba7c7574528083 | cd0987589d3815de1dea8529a7705caac479e7e9 | /webkit/WebKit/chromium/src/WebGraphicsContext3DDefaultImpl.cpp | b035db82e3fa39c7a13f6baace8ccd5a483b102e | [
"BSD-2-Clause"
]
| permissive | azrul2202/WebKit-Smartphone | 0aab1ff641d74f15c0623f00c56806dbc9b59fc1 | 023d6fe819445369134dee793b69de36748e71d7 | refs/heads/master | 2021-01-15T09:24:31.288774 | 2011-07-11T11:12:44 | 2011-07-11T11:12:44 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 44,800 | cpp | /*
* Copyright (C) 2010 Google Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#if ENABLE(3D_CANVAS)
#include "WebGraphicsContext3DDefaultImpl.h"
#include "app/gfx/gl/gl_bindings.h"
#include "app/gfx/gl/gl_context.h"
#include "NotImplemented.h"
#include <wtf/PassOwnPtr.h>
#include <stdio.h>
#include <string.h>
namespace WebKit {
WebGraphicsContext3DDefaultImpl::VertexAttribPointerState::VertexAttribPointerState()
: enabled(false)
, buffer(0)
, indx(0)
, size(0)
, type(0)
, normalized(false)
, stride(0)
, offset(0)
{
}
WebGraphicsContext3DDefaultImpl::WebGraphicsContext3DDefaultImpl()
: m_initialized(false)
, m_texture(0)
, m_fbo(0)
, m_depthStencilBuffer(0)
, m_multisampleFBO(0)
, m_multisampleDepthStencilBuffer(0)
, m_multisampleColorBuffer(0)
, m_boundFBO(0)
#ifdef FLIP_FRAMEBUFFER_VERTICALLY
, m_scanline(0)
#endif
, m_boundArrayBuffer(0)
{
}
WebGraphicsContext3DDefaultImpl::~WebGraphicsContext3DDefaultImpl()
{
if (m_initialized) {
makeContextCurrent();
if (m_attributes.antialias) {
glDeleteRenderbuffersEXT(1, &m_multisampleColorBuffer);
if (m_attributes.depth || m_attributes.stencil)
glDeleteRenderbuffersEXT(1, &m_multisampleDepthStencilBuffer);
glDeleteFramebuffersEXT(1, &m_multisampleFBO);
} else {
if (m_attributes.depth || m_attributes.stencil)
glDeleteRenderbuffersEXT(1, &m_depthStencilBuffer);
}
glDeleteTextures(1, &m_texture);
#ifdef FLIP_FRAMEBUFFER_VERTICALLY
if (m_scanline)
delete[] m_scanline;
#endif
glDeleteFramebuffersEXT(1, &m_fbo);
m_glContext->Destroy();
}
}
bool WebGraphicsContext3DDefaultImpl::initialize(WebGraphicsContext3D::Attributes attributes, WebView* webView)
{
if (!gfx::GLContext::InitializeOneOff())
return false;
m_glContext = WTF::adoptPtr(gfx::GLContext::CreateOffscreenGLContext(0));
if (!m_glContext)
return false;
m_attributes = attributes;
validateAttributes();
glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
m_initialized = true;
return true;
}
void WebGraphicsContext3DDefaultImpl::validateAttributes()
{
const char* extensions = reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS));
if (m_attributes.stencil) {
if (strstr(extensions, "GL_EXT_packed_depth_stencil")) {
if (!m_attributes.depth)
m_attributes.depth = true;
} else
m_attributes.stencil = false;
}
if (m_attributes.antialias) {
bool isValidVendor = true;
#if PLATFORM(CG)
// Currently in Mac we only turn on antialias if vendor is NVIDIA.
const char* vendor = reinterpret_cast<const char*>(glGetString(GL_VENDOR));
if (!strstr(vendor, "NVIDIA"))
isValidVendor = false;
#endif
if (!isValidVendor || !strstr(extensions, "GL_EXT_framebuffer_multisample"))
m_attributes.antialias = false;
}
// FIXME: instead of enforcing premultipliedAlpha = true, implement the
// correct behavior when premultipliedAlpha = false is requested.
m_attributes.premultipliedAlpha = true;
}
bool WebGraphicsContext3DDefaultImpl::makeContextCurrent()
{
return m_glContext->MakeCurrent();
}
int WebGraphicsContext3DDefaultImpl::width()
{
return m_cachedWidth;
}
int WebGraphicsContext3DDefaultImpl::height()
{
return m_cachedHeight;
}
int WebGraphicsContext3DDefaultImpl::sizeInBytes(int type)
{
switch (type) {
case GL_BYTE:
return sizeof(GLbyte);
case GL_UNSIGNED_BYTE:
return sizeof(GLubyte);
case GL_SHORT:
return sizeof(GLshort);
case GL_UNSIGNED_SHORT:
return sizeof(GLushort);
case GL_INT:
return sizeof(GLint);
case GL_UNSIGNED_INT:
return sizeof(GLuint);
case GL_FLOAT:
return sizeof(GLfloat);
}
return 0;
}
bool WebGraphicsContext3DDefaultImpl::isGLES2Compliant()
{
return false;
}
bool WebGraphicsContext3DDefaultImpl::isGLES2NPOTStrict()
{
return false;
}
bool WebGraphicsContext3DDefaultImpl::isErrorGeneratedOnOutOfBoundsAccesses()
{
return false;
}
unsigned int WebGraphicsContext3DDefaultImpl::getPlatformTextureId()
{
ASSERT_NOT_REACHED();
return 0;
}
void WebGraphicsContext3DDefaultImpl::prepareTexture()
{
ASSERT_NOT_REACHED();
}
static int createTextureObject(GLenum target)
{
GLuint texture = 0;
glGenTextures(1, &texture);
glBindTexture(target, texture);
glTexParameterf(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterf(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
return texture;
}
void WebGraphicsContext3DDefaultImpl::reshape(int width, int height)
{
m_cachedWidth = width;
m_cachedHeight = height;
makeContextCurrent();
GLenum target = GL_TEXTURE_2D;
if (!m_texture) {
// Generate the texture object
m_texture = createTextureObject(target);
// Generate the framebuffer object
glGenFramebuffersEXT(1, &m_fbo);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo);
m_boundFBO = m_fbo;
if (m_attributes.depth || m_attributes.stencil)
glGenRenderbuffersEXT(1, &m_depthStencilBuffer);
// Generate the multisample framebuffer object
if (m_attributes.antialias) {
glGenFramebuffersEXT(1, &m_multisampleFBO);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_multisampleFBO);
m_boundFBO = m_multisampleFBO;
glGenRenderbuffersEXT(1, &m_multisampleColorBuffer);
if (m_attributes.depth || m_attributes.stencil)
glGenRenderbuffersEXT(1, &m_multisampleDepthStencilBuffer);
}
}
GLint internalColorFormat, colorFormat, internalDepthStencilFormat = 0;
if (m_attributes.alpha) {
internalColorFormat = GL_RGBA8;
colorFormat = GL_RGBA;
} else {
internalColorFormat = GL_RGB8;
colorFormat = GL_RGB;
}
if (m_attributes.stencil || m_attributes.depth) {
// We don't allow the logic where stencil is required and depth is not.
// See GraphicsContext3DInternal constructor.
if (m_attributes.stencil && m_attributes.depth)
internalDepthStencilFormat = GL_DEPTH24_STENCIL8_EXT;
else
internalDepthStencilFormat = GL_DEPTH_COMPONENT;
}
bool mustRestoreFBO = false;
// Resize multisampling FBO
if (m_attributes.antialias) {
GLint maxSampleCount;
glGetIntegerv(GL_MAX_SAMPLES_EXT, &maxSampleCount);
GLint sampleCount = std::min(8, maxSampleCount);
if (m_boundFBO != m_multisampleFBO) {
mustRestoreFBO = true;
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_multisampleFBO);
}
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_multisampleColorBuffer);
glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, sampleCount, internalColorFormat, width, height);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, m_multisampleColorBuffer);
if (m_attributes.stencil || m_attributes.depth) {
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_multisampleDepthStencilBuffer);
glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, sampleCount, internalDepthStencilFormat, width, height);
if (m_attributes.stencil)
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_multisampleDepthStencilBuffer);
if (m_attributes.depth)
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_multisampleDepthStencilBuffer);
}
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
printf("GraphicsContext3D: multisampling framebuffer was incomplete\n");
// FIXME: cleanup.
notImplemented();
}
}
// Resize regular FBO
if (m_boundFBO != m_fbo) {
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo);
mustRestoreFBO = true;
}
glBindTexture(target, m_texture);
glTexImage2D(target, 0, internalColorFormat, width, height, 0, colorFormat, GL_UNSIGNED_BYTE, 0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, target, m_texture, 0);
glBindTexture(target, 0);
if (!m_attributes.antialias && (m_attributes.stencil || m_attributes.depth)) {
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_depthStencilBuffer);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, internalDepthStencilFormat, width, height);
if (m_attributes.stencil)
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depthStencilBuffer);
if (m_attributes.depth)
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depthStencilBuffer);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
}
GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
printf("WebGraphicsContext3DDefaultImpl: framebuffer was incomplete\n");
// FIXME: cleanup.
notImplemented();
}
if (m_attributes.antialias) {
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_multisampleFBO);
if (m_boundFBO == m_multisampleFBO)
mustRestoreFBO = false;
}
// Initialize renderbuffers to 0.
GLboolean colorMask[] = {GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE}, depthMask = GL_TRUE, stencilMask = GL_TRUE;
GLboolean isScissorEnabled = GL_FALSE;
GLboolean isDitherEnabled = GL_FALSE;
GLbitfield clearMask = GL_COLOR_BUFFER_BIT;
glGetBooleanv(GL_COLOR_WRITEMASK, colorMask);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
if (m_attributes.depth) {
glGetBooleanv(GL_DEPTH_WRITEMASK, &depthMask);
glDepthMask(GL_TRUE);
clearMask |= GL_DEPTH_BUFFER_BIT;
}
if (m_attributes.stencil) {
glGetBooleanv(GL_STENCIL_WRITEMASK, &stencilMask);
glStencilMask(GL_TRUE);
clearMask |= GL_STENCIL_BUFFER_BIT;
}
isScissorEnabled = glIsEnabled(GL_SCISSOR_TEST);
glDisable(GL_SCISSOR_TEST);
isDitherEnabled = glIsEnabled(GL_DITHER);
glDisable(GL_DITHER);
glClear(clearMask);
glColorMask(colorMask[0], colorMask[1], colorMask[2], colorMask[3]);
if (m_attributes.depth)
glDepthMask(depthMask);
if (m_attributes.stencil)
glStencilMask(stencilMask);
if (isScissorEnabled)
glEnable(GL_SCISSOR_TEST);
else
glDisable(GL_SCISSOR_TEST);
if (isDitherEnabled)
glEnable(GL_DITHER);
else
glDisable(GL_DITHER);
if (mustRestoreFBO)
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_boundFBO);
#ifdef FLIP_FRAMEBUFFER_VERTICALLY
if (m_scanline) {
delete[] m_scanline;
m_scanline = 0;
}
m_scanline = new unsigned char[width * 4];
#endif // FLIP_FRAMEBUFFER_VERTICALLY
}
#ifdef FLIP_FRAMEBUFFER_VERTICALLY
void WebGraphicsContext3DDefaultImpl::flipVertically(unsigned char* framebuffer,
unsigned int width,
unsigned int height)
{
unsigned char* scanline = m_scanline;
if (!scanline)
return;
unsigned int rowBytes = width * 4;
unsigned int count = height / 2;
for (unsigned int i = 0; i < count; i++) {
unsigned char* rowA = framebuffer + i * rowBytes;
unsigned char* rowB = framebuffer + (height - i - 1) * rowBytes;
// FIXME: this is where the multiplication of the alpha
// channel into the color buffer will need to occur if the
// user specifies the "premultiplyAlpha" flag in the context
// creation attributes.
memcpy(scanline, rowB, rowBytes);
memcpy(rowB, rowA, rowBytes);
memcpy(rowA, scanline, rowBytes);
}
}
#endif
bool WebGraphicsContext3DDefaultImpl::readBackFramebuffer(unsigned char* pixels, size_t bufferSize)
{
if (bufferSize != static_cast<size_t>(4 * width() * height()))
return false;
makeContextCurrent();
// Earlier versions of this code used the GPU to flip the
// framebuffer vertically before reading it back for compositing
// via software. This code was quite complicated, used a lot of
// GPU memory, and didn't provide an obvious speedup. Since this
// vertical flip is only a temporary solution anyway until Chrome
// is fully GPU composited, it wasn't worth the complexity.
bool mustRestoreFBO = false;
if (m_attributes.antialias) {
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, m_multisampleFBO);
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, m_fbo);
glBlitFramebufferEXT(0, 0, m_cachedWidth, m_cachedHeight, 0, 0, m_cachedWidth, m_cachedHeight, GL_COLOR_BUFFER_BIT, GL_LINEAR);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo);
mustRestoreFBO = true;
} else {
if (m_boundFBO != m_fbo) {
mustRestoreFBO = true;
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo);
}
}
GLint packAlignment = 4;
bool mustRestorePackAlignment = false;
glGetIntegerv(GL_PACK_ALIGNMENT, &packAlignment);
if (packAlignment > 4) {
glPixelStorei(GL_PACK_ALIGNMENT, 4);
mustRestorePackAlignment = true;
}
// FIXME: OpenGL ES 2 does not support GL_BGRA so this fails when
// using that backend.
glReadPixels(0, 0, m_cachedWidth, m_cachedHeight, GL_BGRA, GL_UNSIGNED_BYTE, pixels);
if (mustRestorePackAlignment)
glPixelStorei(GL_PACK_ALIGNMENT, packAlignment);
if (mustRestoreFBO)
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_boundFBO);
#ifdef FLIP_FRAMEBUFFER_VERTICALLY
if (pixels)
flipVertically(pixels, m_cachedWidth, m_cachedHeight);
#endif
return true;
}
void WebGraphicsContext3DDefaultImpl::synthesizeGLError(unsigned long error)
{
m_syntheticErrors.add(error);
}
bool WebGraphicsContext3DDefaultImpl::supportsBGRA()
{
// Supported since OpenGL 1.2. However, glTexImage2D() must be modified
// to translate the internalFormat from GL_BGRA to GL_RGBA, since the
// former is not accepted by desktop GL. Return false until this is done.
return false;
}
// Helper macros to reduce the amount of code.
#define DELEGATE_TO_GL(name, glname) \
void WebGraphicsContext3DDefaultImpl::name() \
{ \
makeContextCurrent(); \
gl##glname(); \
}
#define DELEGATE_TO_GL_1(name, glname, t1) \
void WebGraphicsContext3DDefaultImpl::name(t1 a1) \
{ \
makeContextCurrent(); \
gl##glname(a1); \
}
#define DELEGATE_TO_GL_1R(name, glname, t1, rt) \
rt WebGraphicsContext3DDefaultImpl::name(t1 a1) \
{ \
makeContextCurrent(); \
return gl##glname(a1); \
}
#define DELEGATE_TO_GL_2(name, glname, t1, t2) \
void WebGraphicsContext3DDefaultImpl::name(t1 a1, t2 a2) \
{ \
makeContextCurrent(); \
gl##glname(a1, a2); \
}
#define DELEGATE_TO_GL_2R(name, glname, t1, t2, rt) \
rt WebGraphicsContext3DDefaultImpl::name(t1 a1, t2 a2) \
{ \
makeContextCurrent(); \
return gl##glname(a1, a2); \
}
#define DELEGATE_TO_GL_3(name, glname, t1, t2, t3) \
void WebGraphicsContext3DDefaultImpl::name(t1 a1, t2 a2, t3 a3) \
{ \
makeContextCurrent(); \
gl##glname(a1, a2, a3); \
}
#define DELEGATE_TO_GL_4(name, glname, t1, t2, t3, t4) \
void WebGraphicsContext3DDefaultImpl::name(t1 a1, t2 a2, t3 a3, t4 a4) \
{ \
makeContextCurrent(); \
gl##glname(a1, a2, a3, a4); \
}
#define DELEGATE_TO_GL_5(name, glname, t1, t2, t3, t4, t5) \
void WebGraphicsContext3DDefaultImpl::name(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5) \
{ \
makeContextCurrent(); \
gl##glname(a1, a2, a3, a4, a5); \
}
#define DELEGATE_TO_GL_6(name, glname, t1, t2, t3, t4, t5, t6) \
void WebGraphicsContext3DDefaultImpl::name(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5, t6 a6) \
{ \
makeContextCurrent(); \
gl##glname(a1, a2, a3, a4, a5, a6); \
}
#define DELEGATE_TO_GL_7(name, glname, t1, t2, t3, t4, t5, t6, t7) \
void WebGraphicsContext3DDefaultImpl::name(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5, t6 a6, t7 a7) \
{ \
makeContextCurrent(); \
gl##glname(a1, a2, a3, a4, a5, a6, a7); \
}
#define DELEGATE_TO_GL_8(name, glname, t1, t2, t3, t4, t5, t6, t7, t8) \
void WebGraphicsContext3DDefaultImpl::name(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5, t6 a6, t7 a7, t8 a8) \
{ \
makeContextCurrent(); \
gl##glname(a1, a2, a3, a4, a5, a6, a7, a8); \
}
#define DELEGATE_TO_GL_9(name, glname, t1, t2, t3, t4, t5, t6, t7, t8, t9) \
void WebGraphicsContext3DDefaultImpl::name(t1 a1, t2 a2, t3 a3, t4 a4, t5 a5, t6 a6, t7 a7, t8 a8, t9 a9) \
{ \
makeContextCurrent(); \
gl##glname(a1, a2, a3, a4, a5, a6, a7, a8, a9); \
}
void WebGraphicsContext3DDefaultImpl::activeTexture(unsigned long texture)
{
// FIXME: query number of textures available.
if (texture < GL_TEXTURE0 || texture > GL_TEXTURE0+32)
// FIXME: raise exception.
return;
makeContextCurrent();
glActiveTexture(texture);
}
DELEGATE_TO_GL_2(attachShader, AttachShader, WebGLId, WebGLId)
DELEGATE_TO_GL_3(bindAttribLocation, BindAttribLocation, WebGLId, unsigned long, const char*)
void WebGraphicsContext3DDefaultImpl::bindBuffer(unsigned long target, WebGLId buffer)
{
makeContextCurrent();
if (target == GL_ARRAY_BUFFER)
m_boundArrayBuffer = buffer;
glBindBuffer(target, buffer);
}
void WebGraphicsContext3DDefaultImpl::bindFramebuffer(unsigned long target, WebGLId framebuffer)
{
makeContextCurrent();
if (!framebuffer)
framebuffer = (m_attributes.antialias ? m_multisampleFBO : m_fbo);
if (framebuffer != m_boundFBO) {
glBindFramebufferEXT(target, framebuffer);
m_boundFBO = framebuffer;
}
}
DELEGATE_TO_GL_2(bindRenderbuffer, BindRenderbufferEXT, unsigned long, WebGLId)
DELEGATE_TO_GL_2(bindTexture, BindTexture, unsigned long, WebGLId)
DELEGATE_TO_GL_4(blendColor, BlendColor, double, double, double, double)
DELEGATE_TO_GL_1(blendEquation, BlendEquation, unsigned long)
DELEGATE_TO_GL_2(blendEquationSeparate, BlendEquationSeparate, unsigned long, unsigned long)
DELEGATE_TO_GL_2(blendFunc, BlendFunc, unsigned long, unsigned long)
DELEGATE_TO_GL_4(blendFuncSeparate, BlendFuncSeparate, unsigned long, unsigned long, unsigned long, unsigned long)
DELEGATE_TO_GL_4(bufferData, BufferData, unsigned long, int, const void*, unsigned long)
DELEGATE_TO_GL_4(bufferSubData, BufferSubData, unsigned long, long, int, const void*)
DELEGATE_TO_GL_1R(checkFramebufferStatus, CheckFramebufferStatusEXT, unsigned long, unsigned long)
DELEGATE_TO_GL_1(clear, Clear, unsigned long)
DELEGATE_TO_GL_4(clearColor, ClearColor, double, double, double, double)
DELEGATE_TO_GL_1(clearDepth, ClearDepth, double)
DELEGATE_TO_GL_1(clearStencil, ClearStencil, long)
DELEGATE_TO_GL_4(colorMask, ColorMask, bool, bool, bool, bool)
DELEGATE_TO_GL_1(compileShader, CompileShader, WebGLId)
void WebGraphicsContext3DDefaultImpl::copyTexImage2D(unsigned long target, long level, unsigned long internalformat,
long x, long y, unsigned long width, unsigned long height, long border)
{
makeContextCurrent();
if (m_attributes.antialias && m_boundFBO == m_multisampleFBO) {
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, m_multisampleFBO);
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, m_fbo);
glBlitFramebufferEXT(x, y, x + width, y + height, x, y, x + width, y + height, GL_COLOR_BUFFER_BIT, GL_LINEAR);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo);
}
glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
if (m_attributes.antialias && m_boundFBO == m_multisampleFBO)
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_boundFBO);
}
void WebGraphicsContext3DDefaultImpl::copyTexSubImage2D(unsigned long target, long level, long xoffset, long yoffset,
long x, long y, unsigned long width, unsigned long height)
{
makeContextCurrent();
if (m_attributes.antialias && m_boundFBO == m_multisampleFBO) {
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, m_multisampleFBO);
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, m_fbo);
glBlitFramebufferEXT(x, y, x + width, y + height, x, y, x + width, y + height, GL_COLOR_BUFFER_BIT, GL_LINEAR);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo);
}
glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
if (m_attributes.antialias && m_boundFBO == m_multisampleFBO)
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_boundFBO);
}
DELEGATE_TO_GL_1(cullFace, CullFace, unsigned long)
DELEGATE_TO_GL_1(depthFunc, DepthFunc, unsigned long)
DELEGATE_TO_GL_1(depthMask, DepthMask, bool)
DELEGATE_TO_GL_2(depthRange, DepthRange, double, double)
DELEGATE_TO_GL_2(detachShader, DetachShader, WebGLId, WebGLId)
DELEGATE_TO_GL_1(disable, Disable, unsigned long)
void WebGraphicsContext3DDefaultImpl::disableVertexAttribArray(unsigned long index)
{
makeContextCurrent();
if (index < NumTrackedPointerStates)
m_vertexAttribPointerState[index].enabled = false;
glDisableVertexAttribArray(index);
}
DELEGATE_TO_GL_3(drawArrays, DrawArrays, unsigned long, long, long)
void WebGraphicsContext3DDefaultImpl::drawElements(unsigned long mode, unsigned long count, unsigned long type, long offset)
{
makeContextCurrent();
glDrawElements(mode, count, type,
reinterpret_cast<void*>(static_cast<intptr_t>(offset)));
}
DELEGATE_TO_GL_1(enable, Enable, unsigned long)
void WebGraphicsContext3DDefaultImpl::enableVertexAttribArray(unsigned long index)
{
makeContextCurrent();
if (index < NumTrackedPointerStates)
m_vertexAttribPointerState[index].enabled = true;
glEnableVertexAttribArray(index);
}
DELEGATE_TO_GL(finish, Finish)
DELEGATE_TO_GL(flush, Flush)
void WebGraphicsContext3DDefaultImpl::framebufferRenderbuffer(unsigned long target, unsigned long attachment,
unsigned long renderbuffertarget, WebGLId buffer)
{
makeContextCurrent();
if (attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
glFramebufferRenderbufferEXT(target, GL_DEPTH_ATTACHMENT, renderbuffertarget, buffer);
glFramebufferRenderbufferEXT(target, GL_STENCIL_ATTACHMENT, renderbuffertarget, buffer);
} else
glFramebufferRenderbufferEXT(target, attachment, renderbuffertarget, buffer);
}
DELEGATE_TO_GL_5(framebufferTexture2D, FramebufferTexture2DEXT, unsigned long, unsigned long, unsigned long, WebGLId, long)
DELEGATE_TO_GL_1(frontFace, FrontFace, unsigned long)
void WebGraphicsContext3DDefaultImpl::generateMipmap(unsigned long target)
{
makeContextCurrent();
if (glGenerateMipmapEXT)
glGenerateMipmapEXT(target);
// FIXME: provide alternative code path? This will be unpleasant
// to implement if glGenerateMipmapEXT is not available -- it will
// require a texture readback and re-upload.
}
bool WebGraphicsContext3DDefaultImpl::getActiveAttrib(WebGLId program, unsigned long index, ActiveInfo& info)
{
makeContextCurrent();
if (!program) {
synthesizeGLError(GL_INVALID_VALUE);
return false;
}
GLint maxNameLength = -1;
glGetProgramiv(program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &maxNameLength);
if (maxNameLength < 0)
return false;
GLchar* name = 0;
if (!tryFastMalloc(maxNameLength * sizeof(GLchar)).getValue(name)) {
synthesizeGLError(GL_OUT_OF_MEMORY);
return false;
}
GLsizei length = 0;
GLint size = -1;
GLenum type = 0;
glGetActiveAttrib(program, index, maxNameLength,
&length, &size, &type, name);
if (size < 0) {
fastFree(name);
return false;
}
info.name = WebString::fromUTF8(name, length);
info.type = type;
info.size = size;
fastFree(name);
return true;
}
bool WebGraphicsContext3DDefaultImpl::getActiveUniform(WebGLId program, unsigned long index, ActiveInfo& info)
{
makeContextCurrent();
GLint maxNameLength = -1;
glGetProgramiv(program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxNameLength);
if (maxNameLength < 0)
return false;
GLchar* name = 0;
if (!tryFastMalloc(maxNameLength * sizeof(GLchar)).getValue(name)) {
synthesizeGLError(GL_OUT_OF_MEMORY);
return false;
}
GLsizei length = 0;
GLint size = -1;
GLenum type = 0;
glGetActiveUniform(program, index, maxNameLength,
&length, &size, &type, name);
if (size < 0) {
fastFree(name);
return false;
}
info.name = WebString::fromUTF8(name, length);
info.type = type;
info.size = size;
fastFree(name);
return true;
}
DELEGATE_TO_GL_4(getAttachedShaders, GetAttachedShaders, WebGLId, int, int*, unsigned int*)
DELEGATE_TO_GL_2R(getAttribLocation, GetAttribLocation, WebGLId, const char*, int)
DELEGATE_TO_GL_2(getBooleanv, GetBooleanv, unsigned long, unsigned char*)
DELEGATE_TO_GL_3(getBufferParameteriv, GetBufferParameteriv, unsigned long, unsigned long, int*)
WebGraphicsContext3D::Attributes WebGraphicsContext3DDefaultImpl::getContextAttributes()
{
return m_attributes;
}
unsigned long WebGraphicsContext3DDefaultImpl::getError()
{
if (m_syntheticErrors.size() > 0) {
ListHashSet<unsigned long>::iterator iter = m_syntheticErrors.begin();
unsigned long err = *iter;
m_syntheticErrors.remove(iter);
return err;
}
makeContextCurrent();
return glGetError();
}
DELEGATE_TO_GL_2(getFloatv, GetFloatv, unsigned long, float*)
void WebGraphicsContext3DDefaultImpl::getFramebufferAttachmentParameteriv(unsigned long target, unsigned long attachment,
unsigned long pname, int* value)
{
makeContextCurrent();
if (attachment == GL_DEPTH_STENCIL_ATTACHMENT)
attachment = GL_DEPTH_ATTACHMENT; // Or GL_STENCIL_ATTACHMENT, either works.
glGetFramebufferAttachmentParameterivEXT(target, attachment, pname, value);
}
void WebGraphicsContext3DDefaultImpl::getIntegerv(unsigned long pname, int* value)
{
// Need to emulate IMPLEMENTATION_COLOR_READ_FORMAT/TYPE for GL. Any valid
// combination should work, but GL_RGB/GL_UNSIGNED_BYTE might be the most
// useful for desktop WebGL users.
// Need to emulate MAX_FRAGMENT/VERTEX_UNIFORM_VECTORS and MAX_VARYING_VECTORS
// because desktop GL's corresponding queries return the number of components
// whereas GLES2 return the number of vectors (each vector has 4 components).
// Therefore, the value returned by desktop GL needs to be divided by 4.
makeContextCurrent();
switch (pname) {
case 0x8B9B: // IMPLEMENTATION_COLOR_READ_FORMAT
*value = GL_RGB;
break;
case 0x8B9A: // IMPLEMENTATION_COLOR_READ_TYPE
*value = GL_UNSIGNED_BYTE;
break;
case 0x8DFD: // MAX_FRAGMENT_UNIFORM_VECTORS
glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, value);
*value /= 4;
break;
case 0x8DFB: // MAX_VERTEX_UNIFORM_VECTORS
glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS, value);
*value /= 4;
break;
case 0x8DFC: // MAX_VARYING_VECTORS
glGetIntegerv(GL_MAX_VARYING_FLOATS, value);
*value /= 4;
break;
default:
glGetIntegerv(pname, value);
}
}
DELEGATE_TO_GL_3(getProgramiv, GetProgramiv, WebGLId, unsigned long, int*)
WebString WebGraphicsContext3DDefaultImpl::getProgramInfoLog(WebGLId program)
{
makeContextCurrent();
GLint logLength;
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength);
if (!logLength)
return WebString();
GLchar* log = 0;
if (!tryFastMalloc(logLength * sizeof(GLchar)).getValue(log))
return WebString();
GLsizei returnedLogLength;
glGetProgramInfoLog(program, logLength, &returnedLogLength, log);
ASSERT(logLength == returnedLogLength + 1);
WebString res = WebString::fromUTF8(log, returnedLogLength);
fastFree(log);
return res;
}
DELEGATE_TO_GL_3(getRenderbufferParameteriv, GetRenderbufferParameterivEXT, unsigned long, unsigned long, int*)
DELEGATE_TO_GL_3(getShaderiv, GetShaderiv, WebGLId, unsigned long, int*)
WebString WebGraphicsContext3DDefaultImpl::getShaderInfoLog(WebGLId shader)
{
makeContextCurrent();
GLint logLength;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &logLength);
if (!logLength)
return WebString();
GLchar* log = 0;
if (!tryFastMalloc(logLength * sizeof(GLchar)).getValue(log))
return WebString();
GLsizei returnedLogLength;
glGetShaderInfoLog(shader, logLength, &returnedLogLength, log);
ASSERT(logLength == returnedLogLength + 1);
WebString res = WebString::fromUTF8(log, returnedLogLength);
fastFree(log);
return res;
}
WebString WebGraphicsContext3DDefaultImpl::getShaderSource(WebGLId shader)
{
makeContextCurrent();
GLint logLength;
glGetShaderiv(shader, GL_SHADER_SOURCE_LENGTH, &logLength);
if (!logLength)
return WebString();
GLchar* log = 0;
if (!tryFastMalloc(logLength * sizeof(GLchar)).getValue(log))
return WebString();
GLsizei returnedLogLength;
glGetShaderSource(shader, logLength, &returnedLogLength, log);
ASSERT(logLength == returnedLogLength + 1);
WebString res = WebString::fromUTF8(log, returnedLogLength);
fastFree(log);
return res;
}
WebString WebGraphicsContext3DDefaultImpl::getString(unsigned long name)
{
makeContextCurrent();
return WebString::fromUTF8(reinterpret_cast<const char*>(glGetString(name)));
}
DELEGATE_TO_GL_3(getTexParameterfv, GetTexParameterfv, unsigned long, unsigned long, float*)
DELEGATE_TO_GL_3(getTexParameteriv, GetTexParameteriv, unsigned long, unsigned long, int*)
DELEGATE_TO_GL_3(getUniformfv, GetUniformfv, WebGLId, long, float*)
DELEGATE_TO_GL_3(getUniformiv, GetUniformiv, WebGLId, long, int*)
DELEGATE_TO_GL_2R(getUniformLocation, GetUniformLocation, WebGLId, const char*, long)
DELEGATE_TO_GL_3(getVertexAttribfv, GetVertexAttribfv, unsigned long, unsigned long, float*)
DELEGATE_TO_GL_3(getVertexAttribiv, GetVertexAttribiv, unsigned long, unsigned long, int*)
long WebGraphicsContext3DDefaultImpl::getVertexAttribOffset(unsigned long index, unsigned long pname)
{
makeContextCurrent();
void* pointer;
glGetVertexAttribPointerv(index, pname, &pointer);
return reinterpret_cast<long>(pointer);
}
DELEGATE_TO_GL_2(hint, Hint, unsigned long, unsigned long)
DELEGATE_TO_GL_1R(isBuffer, IsBuffer, WebGLId, bool)
DELEGATE_TO_GL_1R(isEnabled, IsEnabled, unsigned long, bool)
DELEGATE_TO_GL_1R(isFramebuffer, IsFramebufferEXT, WebGLId, bool)
DELEGATE_TO_GL_1R(isProgram, IsProgram, WebGLId, bool)
DELEGATE_TO_GL_1R(isRenderbuffer, IsRenderbufferEXT, WebGLId, bool)
DELEGATE_TO_GL_1R(isShader, IsShader, WebGLId, bool)
DELEGATE_TO_GL_1R(isTexture, IsTexture, WebGLId, bool)
DELEGATE_TO_GL_1(lineWidth, LineWidth, double)
DELEGATE_TO_GL_1(linkProgram, LinkProgram, WebGLId)
DELEGATE_TO_GL_2(pixelStorei, PixelStorei, unsigned long, long)
DELEGATE_TO_GL_2(polygonOffset, PolygonOffset, double, double)
void WebGraphicsContext3DDefaultImpl::readPixels(long x, long y, unsigned long width, unsigned long height, unsigned long format, unsigned long type, void* pixels)
{
makeContextCurrent();
// FIXME: remove the two glFlush calls when the driver bug is fixed, i.e.,
// all previous rendering calls should be done before reading pixels.
glFlush();
if (m_attributes.antialias && m_boundFBO == m_multisampleFBO) {
glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, m_multisampleFBO);
glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, m_fbo);
glBlitFramebufferEXT(x, y, x + width, y + height, x, y, x + width, y + height, GL_COLOR_BUFFER_BIT, GL_LINEAR);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo);
glFlush();
}
glReadPixels(x, y, width, height, format, type, pixels);
if (m_attributes.antialias && m_boundFBO == m_multisampleFBO)
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_boundFBO);
}
void WebGraphicsContext3DDefaultImpl::releaseShaderCompiler()
{
}
void WebGraphicsContext3DDefaultImpl::renderbufferStorage(unsigned long target,
unsigned long internalformat,
unsigned long width,
unsigned long height)
{
makeContextCurrent();
switch (internalformat) {
case GL_DEPTH_STENCIL:
internalformat = GL_DEPTH24_STENCIL8_EXT;
break;
case GL_DEPTH_COMPONENT16:
internalformat = GL_DEPTH_COMPONENT;
break;
case GL_RGBA4:
case GL_RGB5_A1:
internalformat = GL_RGBA;
break;
case 0x8D62: // GL_RGB565
internalformat = GL_RGB;
break;
}
glRenderbufferStorageEXT(target, internalformat, width, height);
}
DELEGATE_TO_GL_2(sampleCoverage, SampleCoverage, double, bool)
DELEGATE_TO_GL_4(scissor, Scissor, long, long, unsigned long, unsigned long)
void WebGraphicsContext3DDefaultImpl::shaderSource(WebGLId shader, const char* string)
{
makeContextCurrent();
GLint length = strlen(string);
glShaderSource(shader, 1, &string, &length);
}
DELEGATE_TO_GL_3(stencilFunc, StencilFunc, unsigned long, long, unsigned long)
DELEGATE_TO_GL_4(stencilFuncSeparate, StencilFuncSeparate, unsigned long, unsigned long, long, unsigned long)
DELEGATE_TO_GL_1(stencilMask, StencilMask, unsigned long)
DELEGATE_TO_GL_2(stencilMaskSeparate, StencilMaskSeparate, unsigned long, unsigned long)
DELEGATE_TO_GL_3(stencilOp, StencilOp, unsigned long, unsigned long, unsigned long)
DELEGATE_TO_GL_4(stencilOpSeparate, StencilOpSeparate, unsigned long, unsigned long, unsigned long, unsigned long)
DELEGATE_TO_GL_9(texImage2D, TexImage2D, unsigned, unsigned, unsigned, unsigned, unsigned, unsigned, unsigned, unsigned, const void*)
DELEGATE_TO_GL_3(texParameterf, TexParameterf, unsigned, unsigned, float);
DELEGATE_TO_GL_3(texParameteri, TexParameteri, unsigned, unsigned, int);
DELEGATE_TO_GL_9(texSubImage2D, TexSubImage2D, unsigned, unsigned, unsigned, unsigned, unsigned, unsigned, unsigned, unsigned, const void*)
DELEGATE_TO_GL_2(uniform1f, Uniform1f, long, float)
DELEGATE_TO_GL_3(uniform1fv, Uniform1fv, long, int, float*)
DELEGATE_TO_GL_2(uniform1i, Uniform1i, long, int)
DELEGATE_TO_GL_3(uniform1iv, Uniform1iv, long, int, int*)
DELEGATE_TO_GL_3(uniform2f, Uniform2f, long, float, float)
DELEGATE_TO_GL_3(uniform2fv, Uniform2fv, long, int, float*)
DELEGATE_TO_GL_3(uniform2i, Uniform2i, long, int, int)
DELEGATE_TO_GL_3(uniform2iv, Uniform2iv, long, int, int*)
DELEGATE_TO_GL_4(uniform3f, Uniform3f, long, float, float, float)
DELEGATE_TO_GL_3(uniform3fv, Uniform3fv, long, int, float*)
DELEGATE_TO_GL_4(uniform3i, Uniform3i, long, int, int, int)
DELEGATE_TO_GL_3(uniform3iv, Uniform3iv, long, int, int*)
DELEGATE_TO_GL_5(uniform4f, Uniform4f, long, float, float, float, float)
DELEGATE_TO_GL_3(uniform4fv, Uniform4fv, long, int, float*)
DELEGATE_TO_GL_5(uniform4i, Uniform4i, long, int, int, int, int)
DELEGATE_TO_GL_3(uniform4iv, Uniform4iv, long, int, int*)
DELEGATE_TO_GL_4(uniformMatrix2fv, UniformMatrix2fv, long, int, bool, const float*)
DELEGATE_TO_GL_4(uniformMatrix3fv, UniformMatrix3fv, long, int, bool, const float*)
DELEGATE_TO_GL_4(uniformMatrix4fv, UniformMatrix4fv, long, int, bool, const float*)
DELEGATE_TO_GL_1(useProgram, UseProgram, WebGLId)
DELEGATE_TO_GL_1(validateProgram, ValidateProgram, WebGLId)
DELEGATE_TO_GL_2(vertexAttrib1f, VertexAttrib1f, unsigned long, float)
DELEGATE_TO_GL_2(vertexAttrib1fv, VertexAttrib1fv, unsigned long, const float*)
DELEGATE_TO_GL_3(vertexAttrib2f, VertexAttrib2f, unsigned long, float, float)
DELEGATE_TO_GL_2(vertexAttrib2fv, VertexAttrib2fv, unsigned long, const float*)
DELEGATE_TO_GL_4(vertexAttrib3f, VertexAttrib3f, unsigned long, float, float, float)
DELEGATE_TO_GL_2(vertexAttrib3fv, VertexAttrib3fv, unsigned long, const float*)
DELEGATE_TO_GL_5(vertexAttrib4f, VertexAttrib4f, unsigned long, float, float, float, float)
DELEGATE_TO_GL_2(vertexAttrib4fv, VertexAttrib4fv, unsigned long, const float*)
void WebGraphicsContext3DDefaultImpl::vertexAttribPointer(unsigned long indx, int size, int type, bool normalized,
unsigned long stride, unsigned long offset)
{
makeContextCurrent();
if (m_boundArrayBuffer <= 0) {
// FIXME: raise exception.
// LogMessagef(("bufferData: no buffer bound"));
return;
}
if (indx < NumTrackedPointerStates) {
VertexAttribPointerState& state = m_vertexAttribPointerState[indx];
state.buffer = m_boundArrayBuffer;
state.indx = indx;
state.size = size;
state.type = type;
state.normalized = normalized;
state.stride = stride;
state.offset = offset;
}
glVertexAttribPointer(indx, size, type, normalized, stride,
reinterpret_cast<void*>(static_cast<intptr_t>(offset)));
}
DELEGATE_TO_GL_4(viewport, Viewport, long, long, unsigned long, unsigned long)
unsigned WebGraphicsContext3DDefaultImpl::createBuffer()
{
makeContextCurrent();
GLuint o;
glGenBuffersARB(1, &o);
return o;
}
unsigned WebGraphicsContext3DDefaultImpl::createFramebuffer()
{
makeContextCurrent();
GLuint o = 0;
glGenFramebuffersEXT(1, &o);
return o;
}
unsigned WebGraphicsContext3DDefaultImpl::createProgram()
{
makeContextCurrent();
return glCreateProgram();
}
unsigned WebGraphicsContext3DDefaultImpl::createRenderbuffer()
{
makeContextCurrent();
GLuint o;
glGenRenderbuffersEXT(1, &o);
return o;
}
DELEGATE_TO_GL_1R(createShader, CreateShader, unsigned long, unsigned);
unsigned WebGraphicsContext3DDefaultImpl::createTexture()
{
makeContextCurrent();
GLuint o;
glGenTextures(1, &o);
return o;
}
void WebGraphicsContext3DDefaultImpl::deleteBuffer(unsigned buffer)
{
makeContextCurrent();
glDeleteBuffersARB(1, &buffer);
}
void WebGraphicsContext3DDefaultImpl::deleteFramebuffer(unsigned framebuffer)
{
makeContextCurrent();
glDeleteFramebuffersEXT(1, &framebuffer);
}
void WebGraphicsContext3DDefaultImpl::deleteProgram(unsigned program)
{
makeContextCurrent();
glDeleteProgram(program);
}
void WebGraphicsContext3DDefaultImpl::deleteRenderbuffer(unsigned renderbuffer)
{
makeContextCurrent();
glDeleteRenderbuffersEXT(1, &renderbuffer);
}
void WebGraphicsContext3DDefaultImpl::deleteShader(unsigned shader)
{
makeContextCurrent();
glDeleteShader(shader);
}
void WebGraphicsContext3DDefaultImpl::deleteTexture(unsigned texture)
{
makeContextCurrent();
glDeleteTextures(1, &texture);
}
} // namespace WebKit
#endif // ENABLE(3D_CANVAS)
| [
"[email protected]"
]
| [
[
[
1,
1208
]
]
]
|
c3e1015d6ee9bbb52ccc5ec754eaea08da874370 | 23017336d25e6ec49c4a51f11c1b3a3aa10acf22 | /csc3750/prog4/Vector.cpp | 02c783ea7bbd3a30630aa9c9817f9b8156766bec | []
| no_license | tjshaffer21/School | 5e7681c96e0c10966fc7362931412c4244507911 | 4aa5fc3a8bbbbb8d46d045244e8a7f84e71c768f | refs/heads/master | 2020-05-27T19:05:06.422314 | 2011-05-17T19:55:40 | 2011-05-17T19:55:40 | 1,681,224 | 1 | 1 | null | 2017-07-29T13:35:54 | 2011-04-29T15:36:55 | C++ | UTF-8 | C++ | false | false | 2,180 | cpp | #include "Vector.h"
#include <math.h>
Vector::Vector(double x, double y, double z)
{
vector = new Matrix(4, 1);
vector->setElement(1, 1, x);
vector->setElement(2, 1, y);
vector->setElement(3, 1, z);
vector->setElement(4, 1, 0.0); //4th coordinate 0 for vectors
}
Vector::~Vector()
{
delete vector;
}
void Vector::setX(double x)
{
vector->setElement(1, 1, x);
}
void Vector::setY(double y)
{
vector->setElement(2, 1, y);
}
void Vector::setZ(double z)
{
vector->setElement(3, 1, z);
}
double Vector::getX()
{
return vector->getElement(1, 1);
}
double Vector::getY()
{
return vector->getElement(2, 1);
}
double Vector::getZ()
{
return vector->getElement(3, 1);
}
void Vector::printVector()
{
vector->printMatrix();
}
/**
* dotProduct
* Performs dot product on the two Vertices.
* Preconditions:
* The vector to perform the manipulation on.
* Postconditions:
* Returns the result of the dot product.
*/
double Vector::dotProduct( Vector* other )
{
double x = this->getX() * other->getX();
double y = this->getY() * other->getY();
double z = this->getZ() * other->getZ();
return (x+y+z);
}
/**
* crossProduct
* Performs cross product on two Vectors.
* Preconditions:
* The vector the perform the cross product on.
* Postconditions:
* Returns the result of the cross product.
*/
Vector* Vector::crossProduct( Vector* other )
{
double x = (this->getY()*other->getZ()) - (this->getZ()*other->getY() );
double y = (this->getZ()*other->getX()) - (this->getX()*other->getZ() );
double z = (this->getX()*other->getY()) - (this->getY()*other->getX() );
return (new Vector(x, y, z) );
}
/**
* normalize
*
* Preconditions:
*
* Postconditions:
*
*/
void Vector::normalize()
{
double len = (this->getX()*this->getX()) +
(this->getY()*this->getY()) +
(this->getZ()*this->getZ());
len = sqrt( len );
this->setX( this->getX()/len );
this->setY( this->getY()/len );
this->setZ( this->getZ()/len );
}
| [
"[email protected]"
]
| [
[
[
1,
109
]
]
]
|
7045dfa83b515d304fdce5cdd3ccc89c9b17a315 | 463c3b62132d215e245a097a921859ecb498f723 | /lib/dlib/gui_widgets/fonts.h | b7579b9e757569593cadc5a8ea110e31f2a3a93e | [
"LicenseRef-scancode-unknown-license-reference",
"BSL-1.0"
]
| permissive | athulan/cppagent | 58f078cee55b68c08297acdf04a5424c2308cfdc | 9027ec4e32647e10c38276e12bcfed526a7e27dd | refs/heads/master | 2021-01-18T23:34:34.691846 | 2009-05-05T00:19:54 | 2009-05-05T00:19:54 | 197,038 | 4 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 21,009 | h | // Copyright (C) 2005 Davis E. King ([email protected]), and Nils Labugt, Keita Mochizuki
// License: Boost Software License See LICENSE.txt for the full license.
#ifndef DLIB_FONTs_
#define DLIB_FONTs_
#include "fonts_abstract.h"
#include "../gui_core.h"
#include <string>
#include "../algs.h"
#include "../serialize.h"
#include "../unicode.h"
#include "../array.h"
#include "../array2d.h"
#include "../threads.h"
#include "../smart_pointers_thread_safe.h"
namespace dlib
{
// ----------------------------------------------------------------------------------------
class letter
{
/*!
INITIAL VALUE
- defined by constructor
CONVENTION
- if (points != 0) then
- points == an array of count point structs
- w == width()
- count == num_of_points()
!*/
public:
struct point
{
point (){}
point (
signed char x_,
signed char y_
) :
x(x_),
y(y_)
{}
signed char x;
signed char y;
};
letter (
) :
points(0),
w(0),
count(0)
{}
letter (
unsigned short width_,
unsigned short point_count
) :
points(new point[point_count]),
w(width_),
count(point_count)
{}
~letter(
)
{
if (points)
delete [] points;
}
unsigned short width (
) const { return w; }
unsigned short num_of_points (
) const { return count;}
point& operator[] (
unsigned short i
)
{
DLIB_ASSERT (i < num_of_points(),
"\tvoid letter::operator[]()"
<< "\n\ti: " << i
<< "\n\tnum_of_points(): " << num_of_points() );
return points[i];
}
const point& operator[] (
unsigned short i
) const
{
DLIB_ASSERT (i < num_of_points(),
"\tvoid letter::operator[]()"
<< "\n\ti: " << i
<< "\n\tnum_of_points(): " << num_of_points() );
return points[i];
}
friend void serialize (
const letter& item,
std::ostream& out
);
friend void deserialize (
letter& item,
std::istream& in
);
void swap (
letter& item
)
{
exchange(points, item.points);
exchange(w, item.w);
exchange(count, item.count);
}
private:
// restricted functions
letter(letter&); // copy constructor
letter& operator=(letter&); // assignment operator
point* points;
unsigned short w;
unsigned short count;
};
inline void swap (
letter& a,
letter& b
) { a.swap(b); }
// ----------------------------------------------------------------------------------------
class font
{
public:
virtual ~font() {}
virtual bool has_character (
unichar ch
)const=0;
bool has_character(char ch) const { return this->has_character(zero_extend_cast<unichar>(ch)); }
bool has_character(wchar_t ch) const { return this->has_character(zero_extend_cast<unichar>(ch)); }
const letter& operator[] (char ch) const { return (*this)[zero_extend_cast<unichar>(ch)]; };
const letter& operator[] (wchar_t ch)const { return (*this)[zero_extend_cast<unichar>(ch)]; };
virtual const letter& operator[] (
unichar ch
)const=0;
virtual unsigned long height (
) const = 0;
virtual unsigned long ascender (
) const = 0;
virtual unsigned long left_overflow (
) const = 0;
virtual unsigned long right_overflow (
) const = 0;
// ------------------------------------------------------------------------------------
template <typename T, typename traits, typename alloc>
void compute_size (
const std::basic_string<T,traits,alloc>& str,
unsigned long& width,
unsigned long& height,
typename std::basic_string<T,traits,alloc>::size_type first = 0,
typename std::basic_string<T,traits,alloc>::size_type last = (std::basic_string<T,traits,alloc>::npos)
) const
{
typedef std::basic_string<T,traits,alloc> string;
DLIB_ASSERT ( (last == string::npos) || (first <= last && last < str.size()) ,
"\tvoid font::compute_size()"
<< "\n\tlast == string::npos: " << ((last == string::npos)?"true":"false")
<< "\n\tfirst: " << (unsigned long)first
<< "\n\tlast: " << (unsigned long)last
<< "\n\tstr.size(): " << (unsigned long)str.size() );
unsigned long line_width = 0;
unsigned long newlines = 0;
width = 0;
height = 0;
if (str.size())
{
if (last == string::npos)
last = str.size()-1;
const font& f = *this;
for (typename string::size_type i = first; i <= last; ++i)
{
// ignore '\r' characters
if (str[i] == '\r')
continue;
if (str[i] == '\n')
{
++newlines;
width = std::max(width,line_width);
line_width = 0;
}
else
{
if (is_combining_char(str[i]) == false)
line_width += f[str[i]].width();
}
}
width = std::max(width,line_width);
height = (newlines+1)*f.height();
width += f.left_overflow() + f.right_overflow();
}
}
// ------------------------------------------------------------------------------------
template <typename T, typename traits, typename alloc, typename pixel_type>
void draw_string (
const canvas& c,
const rectangle& rect,
const std::basic_string<T,traits,alloc>& str,
const pixel_type& color,
typename std::basic_string<T,traits,alloc>::size_type first = 0,
typename std::basic_string<T,traits,alloc>::size_type last = (std::basic_string<T,traits,alloc>::npos),
const rectangle area_ = rectangle(std::numeric_limits<long>::min(), std::numeric_limits<long>::min(),
std::numeric_limits<long>::max(), std::numeric_limits<long>::max())
) const
{
typedef std::basic_string<T,traits,alloc> string;
DLIB_ASSERT ( (last == string::npos) || (first <= last && last < str.size()) ,
"\tvoid font::draw_string()"
<< "\n\tlast == string::npos: " << ((last == string::npos)?"true":"false")
<< "\n\tfirst: " << (unsigned long)first
<< "\n\tlast: " << (unsigned long)last
<< "\n\tstr.size(): " << (unsigned long)str.size() );
rectangle area = rect.intersect(c).intersect(area_);
if (area.is_empty() || str.size() == 0)
return;
if (last == string::npos)
last = str.size()-1;
const font& f = *this;
long y_offset = rect.top() + f.ascender() - 1;
long pos = rect.left()+f.left_overflow();
for (typename string::size_type i = first; i <= last; ++i)
{
// ignore the '\r' character
if (str[i] == '\r')
continue;
// A combining character should be applied to the previous character, and we
// therefore make one step back. If a combining comes right after a newline,
// then there must be some kind of error in the string, and we don't combine.
if(is_combining_char(str[i]) &&
pos > rect.left() + static_cast<long>(f.left_overflow()))
{
pos -= f[str[i]].width();
}
if (str[i] == '\n')
{
y_offset += f.height();
pos = rect.left()+f.left_overflow();
continue;
}
// only look at letters in the intersection area
if (area.bottom() + static_cast<long>(f.height()) < y_offset)
{
// the string is now below our rectangle so we are done
break;
}
else if (area.left() > pos - static_cast<long>(f.left_overflow()) &&
pos + static_cast<long>(f[str[i]].width() + f.right_overflow()) < area.left() )
{
pos += f[str[i]].width();
continue;
}
else if (area.right() + static_cast<long>(f.right_overflow()) < pos)
{
// keep looking because there might be a '\n' in the string that
// will wrap us around and put us back into our rectangle.
continue;
}
// at this point in the loop we know that f[str[i]] overlaps
// horizontally with the intersection rectangle area.
const letter& l = f[str[i]];
for (unsigned short i = 0; i < l.num_of_points(); ++i)
{
const long x = l[i].x + pos;
const long y = l[i].y + y_offset;
// draw each pixel of the letter if it is inside the intersection
// rectangle
if (area.contains(x,y))
{
assign_pixel(c[y-c.top()][x-c.left()], color);
}
}
pos += l.width();
}
}
template <typename T, typename traits, typename alloc>
void draw_string (
const canvas& c,
const rectangle& rect,
const std::basic_string<T,traits,alloc>& str
) const
{
draw_string(c,rect, str, 0, 0, (std::basic_string<T,traits,alloc>::npos),
rectangle(std::numeric_limits<long>::min(), std::numeric_limits<long>::min(),
std::numeric_limits<long>::max(), std::numeric_limits<long>::max()));
}
// ------------------------------------------------------------------------------------
template <typename T, typename traits, typename alloc>
const rectangle compute_cursor_rect (
const rectangle& rect,
const std::basic_string<T,traits,alloc>& str,
unsigned long index,
typename std::basic_string<T,traits,alloc>::size_type first = 0,
typename std::basic_string<T,traits,alloc>::size_type last = (std::basic_string<T,traits,alloc>::npos)
) const
{
typedef std::basic_string<T,traits,alloc> string;
DLIB_ASSERT ( (last == string::npos) || (first <= last && last < str.size()) ,
"\trectangle font::compute_cursor_rect()"
<< "\n\tlast == string::npos: " << ((last == string::npos)?"true":"false")
<< "\n\tfirst: " << (unsigned long)first
<< "\n\tlast: " << (unsigned long)last
<< "\n\tindex: " << index
<< "\n\tstr.size(): " << (unsigned long)str.size() );
const font& f = *this;
if (last == string::npos)
last = str.size()-1;
long x = f.left_overflow();
long y = 0;
int count = 0;
if (str.size() != 0)
{
for (typename string::size_type i = first; i <= last && i < index; ++i)
{
++count;
if (str[i] == '\n')
{
x = f.left_overflow();
y += f.height();
count = 0;
}
else if (is_combining_char(str[i]) == false &&
str[i] != '\r')
{
x += f[str[i]].width();
}
}
}
x += rect.left();
y += rect.top();
// if the cursor is at the start of a line then back it up one pixel
if (count == 0)
--x;
return rectangle(x,y,x,y+f.height()-1);
}
// ------------------------------------------------------------------------------------
template <typename T, typename traits, typename alloc>
unsigned long compute_cursor_pos (
const rectangle& rect,
const std::basic_string<T,traits,alloc>& str,
long x,
long y,
typename std::basic_string<T,traits,alloc>::size_type first = 0,
typename std::basic_string<T,traits,alloc>::size_type last = (std::basic_string<T,traits,alloc>::npos)
) const
{
typedef std::basic_string<T,traits,alloc> string;
DLIB_ASSERT ( (last == string::npos) || (first <= last && last < str.size()) ,
"\tunsigned long font::compute_cursor_pos()"
<< "\n\tlast == string::npos: " << ((last == string::npos)?"true":"false")
<< "\n\tfirst: " << (unsigned long)first
<< "\n\tlast: " << (unsigned long)last
<< "\n\tx: " << x
<< "\n\ty: " << y
<< "\n\tstr.size(): " << (unsigned long)str.size() );
const font& f = *this;
if (str.size() == 0)
return 0;
else if (first >= str.size())
return static_cast<unsigned long>(str.size());
y -= rect.top();
x -= rect.left();
if (y < 0)
y = 0;
if (x < 0)
x = 0;
if (last == string::npos)
last = str.size()-1;
// first figure out what line we are on
typename string::size_type pos = first;
long line = 0;
while (static_cast<unsigned long>(y) >= f.height())
{
++line;
y -= f.height();
}
// find the start of the given line
for (typename string::size_type i = first; i <= last && line != 0; ++i)
{
if (str[i] == '\n')
{
--line;
pos = i + 1;
}
}
// now str[pos] == the first character of the start of the line
// that contains the cursor.
const typename string::size_type start_of_line = pos;
long cur_x = f.left_overflow();
// set the current cursor position to where the mouse clicked
while (pos <= last)
{
if (x <= cur_x || str[pos] == '\n')
break;
if (is_combining_char(str[pos]) == false &&
str[pos] != '\r')
{
cur_x += f[str[pos]].width();
}
++pos;
}
if (x <= cur_x)
{
if (pos != start_of_line)
{
// we might actually be closer to the previous character
// so check for that and if so then jump us back one.
const long width = f[str[pos-1]].width();
if (x < cur_x - width/2)
--pos;
}
}
return static_cast<unsigned long>(pos);
}
};
// ----------------------------------------------------------------------------------------
const shared_ptr_thread_safe<font> get_native_font ();
// ----------------------------------------------------------------------------------------
class default_font : public font
{
letter* l;
default_font(
);
default_font(default_font&); // copy constructor
default_font& operator=(default_font&); // assignment operator
public:
static const shared_ptr_thread_safe<font>& get_font (
)
{
static mutex m;
static shared_ptr_thread_safe<font> f;
auto_mutex M(m);
if (f.get() == 0)
f.reset(new default_font);
return f;
}
~default_font(
)
{
delete [] l;
}
unsigned long height (
) const { return 16; }
unsigned long ascender (
) const { return 12; }
unsigned long left_overflow (
) const { return 1; }
unsigned long right_overflow (
) const { return 2; }
bool has_character (
unichar ch
)const
{
if (ch < 256 && (l[ch].width() != 0 || l[ch].num_of_points() != 0))
return true;
else
return false;
}
const letter& operator[] (
unichar ch
) const
{
if(ch < 256)
return l[ch];
return l[0]; // just return one of the empty characters in this case
}
};
// ----------------------------------------------------------------------------------------
class bdf_font : public font
{
public:
bdf_font( long default_char_ = -1 );
long read_bdf_file( std::istream& in, unichar max_enc, unichar min_enc = 0 );
unsigned long height() const
{
return fbb.height();
}
unsigned long ascender() const
{
return std::max( 0L, 1 - fbb.top() );
}
unsigned long left_overflow() const
{
return std::max( 0L, -fbb.left() );
}
unsigned long right_overflow() const
{
return right_overflow_;
}
const letter& operator[] ( unichar uch ) const
{
if ( !has_character(uch) )
{
return gl[default_char];
}
return gl[uch];
}
bool has_character (
unichar ch
)const
{
if (ch < gl.size() && (gl[ch].width() != 0 || gl[ch].num_of_points() != 0))
return true;
else
return false;
}
void adjust_metrics();
private:
bool bitmap_to_letter( array2d<char>::kernel_1a& bitmap, unichar enc, unsigned long width, int x_offset, int y_offset );
array<letter>::expand_1b_c gl;
unichar default_char; // if (is_intialized == true), then this MUST be an actual glyph
bool is_initialized;
rectangle fbb;
unsigned long right_overflow_;
unsigned global_width;
bool has_global_width;
long specified_default_char;
bdf_font( bdf_font& ); // copy constructor
bdf_font& operator=( bdf_font& ); // assignment operator
};
// ----------------------------------------------------------------------------------------
}
#ifdef NO_MAKEFILE
#include "fonts.cpp"
#endif
#endif // DLIB_FONTs_
| [
"jimmy@DGJ3X3B1.(none)"
]
| [
[
[
1,
627
]
]
]
|
235a9cb6c787bc91c4378196308e417fee6c2b09 | b14d5833a79518a40d302e5eb40ed5da193cf1b2 | /cpp/extern/xercesc++/2.6.0/samples/DOMPrint/DOMTreeErrorReporter.hpp | fe8bab50d2f80f52d0155397f46a68c2153f27b6 | [
"Apache-2.0"
]
| permissive | andyburke/bitflood | dcb3fb62dad7fa5e20cf9f1d58aaa94be30e82bf | fca6c0b635d07da4e6c7fbfa032921c827a981d6 | refs/heads/master | 2016-09-10T02:14:35.564530 | 2011-11-17T09:51:49 | 2011-11-17T09:51:49 | 2,794,411 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,969 | hpp | /*
* Copyright 1999-2002,2004 The Apache Software Foundation.
*
* 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.
*/
/*
* $Id: DOMTreeErrorReporter.hpp,v 1.12 2004/09/08 13:55:31 peiyongz Exp $
*/
#include <xercesc/util/XercesDefs.hpp>
#include <xercesc/sax/ErrorHandler.hpp>
#if defined(XERCES_NEW_IOSTREAMS)
#include <iostream>
#else
#include <iostream.h>
#endif
XERCES_CPP_NAMESPACE_USE
class DOMTreeErrorReporter : public ErrorHandler
{
public:
// -----------------------------------------------------------------------
// Constructors and Destructor
// -----------------------------------------------------------------------
DOMTreeErrorReporter() :
fSawErrors(false)
{
}
~DOMTreeErrorReporter()
{
}
// -----------------------------------------------------------------------
// Implementation of the error handler interface
// -----------------------------------------------------------------------
void warning(const SAXParseException& toCatch);
void error(const SAXParseException& toCatch);
void fatalError(const SAXParseException& toCatch);
void resetErrors();
// -----------------------------------------------------------------------
// Getter methods
// -----------------------------------------------------------------------
bool getSawErrors() const;
// -----------------------------------------------------------------------
// Private data members
//
// fSawErrors
// This is set if we get any errors, and is queryable via a getter
// method. Its used by the main code to suppress output if there are
// errors.
// -----------------------------------------------------------------------
bool fSawErrors;
};
inline bool DOMTreeErrorReporter::getSawErrors() const
{
return fSawErrors;
}
// ---------------------------------------------------------------------------
// This is a simple class that lets us do easy (though not terribly efficient)
// trancoding of XMLCh data to local code page for display.
// ---------------------------------------------------------------------------
class StrX
{
public :
// -----------------------------------------------------------------------
// Constructors and Destructor
// -----------------------------------------------------------------------
StrX(const XMLCh* const toTranscode)
{
// Call the private transcoding method
fLocalForm = XMLString::transcode(toTranscode);
}
~StrX()
{
XMLString::release(&fLocalForm);
}
// -----------------------------------------------------------------------
// Getter methods
// -----------------------------------------------------------------------
const char* localForm() const
{
return fLocalForm;
}
private :
// -----------------------------------------------------------------------
// Private data members
//
// fLocalForm
// This is the local code page form of the string.
// -----------------------------------------------------------------------
char* fLocalForm;
};
inline XERCES_STD_QUALIFIER ostream& operator<<(XERCES_STD_QUALIFIER ostream& target, const StrX& toDump)
{
target << toDump.localForm();
return target;
}
| [
"[email protected]"
]
| [
[
[
1,
123
]
]
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.